diff --git a/.git-blame-ignore-revs b/.git-blame-ignore-revs
new file mode 100644
index 00000000..a854e574
--- /dev/null
+++ b/.git-blame-ignore-revs
@@ -0,0 +1,12 @@
+# Revisions for `git blame` to skip (mechanical changes, no authorship signal).
+#
+# Enable locally:  git config blame.ignoreRevsFile .git-blame-ignore-revs
+# GitHub honors this file automatically on the default branch.
+#
+# IMPORTANT: each SHA must be the commit as it lands on `main`. These entries
+# assume the PR merges with a *merge commit* (which preserves the SHA). A squash
+# or rebase merge rewrites the SHA and would make the entry silently match
+# nothing.
+
+# Tree-wide clang-format (clang-format 22.1.5; see scripts/ci/clang-format.sh).
+906d1088483418bbe347993fd909af054893fcd8
diff --git a/.github/workflows/clang-format.yml b/.github/workflows/clang-format.yml
new file mode 100644
index 00000000..fee45475
--- /dev/null
+++ b/.github/workflows/clang-format.yml
@@ -0,0 +1,24 @@
+name: clang-format
+
+on:
+  pull_request:
+    branches: [main]
+  push:
+    branches: [main]
+
+# Supersede in-flight runs on the same ref.
+concurrency:
+  group: clang-format-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  clang-format:
+    runs-on: blacksmith-2vcpu-ubuntu-2404
+    timeout-minutes: 10
+    steps:
+      - uses: actions/checkout@v6
+      - uses: astral-sh/setup-uv@v8.2.0
+      - name: clang-format gate
+        # Our C/C++ must match the pinned clang-format. Scope (vendored excluded)
+        # and the pinned version both live in scripts/ci/clang-format.sh.
+        run: scripts/ci/clang-format.sh --check
diff --git a/AGENTS.md b/AGENTS.md
index f8655732..c1bf31ed 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -24,6 +24,21 @@ uv run --project scripts/envs/<family> scripts/<script>.py ...
 cmake --build build --target transcribe-cli
 ```
 
+## Formatting
+
+- Format our C/C++ before committing. The formatter is pinned and fetched via
+  `uvx`, so do not rely on a system clang-format:
+
+```bash
+scripts/ci/clang-format.sh            # format our tree in place (default)
+scripts/ci/clang-format.sh --check    # verify, no changes
+```
+
+- Scope is our code only. Vendored trees (`ggml/`, `src/third_party/`) and
+  verbatim upstream copies (`src/transcribe-unicode-data.cpp`) are never
+  formatted. CI gates our C/C++ in
+  `.github/workflows/clang-format.yml`.
+
 ## Verification
 
 - End-to-end numerical checks:
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 565a4897..2cd33edc 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -142,9 +142,23 @@ Formatting rules:
 - Use `void * ptr` and `int & a` pointer/reference spacing.
 - Use vertical alignment when it improves readability and batch editing.
 - Clean up trailing whitespace.
-- Use the root `.clang-format` for new files and touched hunks. It is based on
-  llama.cpp's clang-format profile. Do not reformat unrelated code as part of a
-  behavior change.
+- Format with the pinned formatter rather than a system clang-format:
+
+  ```bash
+  scripts/ci/clang-format.sh            # format our tree in place
+  scripts/ci/clang-format.sh --check    # verify only, no changes
+  ```
+
+  It wraps clang-format `22.1.5` (fetched via `uvx`) against the root
+  `.clang-format`, a profile based on llama.cpp's. The version is pinned in the
+  script so local output matches CI byte-for-byte; bump it there and reformat
+  the tree in the same commit.
+- Formatting scope is our C/C++ only. Vendored trees (`ggml/`,
+  `src/third_party/`) and verbatim upstream copies
+  (`src/transcribe-unicode-data.cpp`) are never reformatted.
+- Do not reformat unrelated code as part of a behavior change. CI enforces this
+  through the `clang-format` workflow (`.github/workflows/clang-format.yml`),
+  which gates our C/C++ against the pinned formatter.
 
 Naming rules:
 
@@ -206,6 +220,7 @@ Required before merge:
 
 | Gate | Command / owner | Requirement |
 | --- | --- | --- |
+| Formatting | `scripts/ci/clang-format.sh --check` (CI: clang-format workflow) | All our C/C++ matches the pinned clang-format |
 | Intake signoff | human review | Schema-valid intake; `reference_framework`, `architecture_pattern`, and `known_risks` reviewed; dtype/frontend/tokenizer gaps resolved or explicitly accepted |
 | Preflight A | `uv run scripts/preflight.py --family <f> [--variant <v>] --gate A` | Pass, or warnings tied to accepted intake gaps |
 | Preflight B | `uv run scripts/preflight.py --family <f> [--variant <v>] --gate B` | Pass after converter exists |
diff --git a/examples/bench/batch_bench.cpp b/examples/bench/batch_bench.cpp
index 4c4812af..8a0fbefe 100644
--- a/examples/bench/batch_bench.cpp
+++ b/examples/bench/batch_bench.cpp
@@ -30,30 +30,42 @@ namespace {
 
 double now_ms() {
     using namespace std::chrono;
-    return duration<double, std::milli>(
-               steady_clock::now().time_since_epoch())
-        .count();
+    return duration<double, std::milli>(steady_clock::now().time_since_epoch()).count();
 }
 
 transcribe_backend_request parse_backend(const char * s) {
-    if (!std::strcmp(s, "cpu"))       return TRANSCRIBE_BACKEND_CPU;
-    if (!std::strcmp(s, "cpu_accel")) return TRANSCRIBE_BACKEND_CPU_ACCEL;
-    if (!std::strcmp(s, "metal"))     return TRANSCRIBE_BACKEND_METAL;
-    if (!std::strcmp(s, "vulkan"))    return TRANSCRIBE_BACKEND_VULKAN;
-    if (!std::strcmp(s, "cuda"))      return TRANSCRIBE_BACKEND_CUDA;
+    if (!std::strcmp(s, "cpu")) {
+        return TRANSCRIBE_BACKEND_CPU;
+    }
+    if (!std::strcmp(s, "cpu_accel")) {
+        return TRANSCRIBE_BACKEND_CPU_ACCEL;
+    }
+    if (!std::strcmp(s, "metal")) {
+        return TRANSCRIBE_BACKEND_METAL;
+    }
+    if (!std::strcmp(s, "vulkan")) {
+        return TRANSCRIBE_BACKEND_VULKAN;
+    }
+    if (!std::strcmp(s, "cuda")) {
+        return TRANSCRIBE_BACKEND_CUDA;
+    }
     return TRANSCRIBE_BACKEND_AUTO;
 }
 
 std::vector<int> parse_sizes(const std::string & csv) {
     std::vector<int> out;
-    size_t i = 0;
+    size_t           i = 0;
     while (i < csv.size()) {
         size_t j = csv.find(',', i);
-        if (j == std::string::npos) j = csv.size();
+        if (j == std::string::npos) {
+            j = csv.size();
+        }
         const std::string tok = csv.substr(i, j - i);
         if (!tok.empty()) {
             const int n = std::atoi(tok.c_str());
-            if (n > 0) out.push_back(n);
+            if (n > 0) {
+                out.push_back(n);
+            }
         }
         i = j + 1;
     }
@@ -63,94 +75,114 @@ std::vector<int> parse_sizes(const std::string & csv) {
 std::string json_escape(const std::string & s) {
     std::string o;
     for (char c : s) {
-        if (c == '"' || c == '\\') { o += '\\'; o += c; }
-        else if (c == '\n')        { o += "\\n"; }
-        else                        { o += c; }
+        if (c == '"' || c == '\\') {
+            o += '\\';
+            o += c;
+        } else if (c == '\n') {
+            o += "\\n";
+        } else {
+            o += c;
+        }
     }
     return o;
 }
 
-} // namespace
+}  // namespace
 
 int main(int argc, char ** argv) {
-    std::string model_path;
-    std::string wav_path;
-    std::string out_path;
-    std::string sizes_csv = "1,2,4,8,16,32";
-    transcribe_backend_request backend = TRANSCRIBE_BACKEND_AUTO;
-    int iters = 3;
-    int n_threads = 0;
+    std::string                model_path;
+    std::string                wav_path;
+    std::string                out_path;
+    std::string                sizes_csv = "1,2,4,8,16,32";
+    transcribe_backend_request backend   = TRANSCRIBE_BACKEND_AUTO;
+    int                        iters     = 3;
+    int                        n_threads = 0;
 
     for (int i = 1; i < argc; ++i) {
-        const std::string a = argv[i];
-        auto next = [&](const char * flag) -> const char * {
+        const std::string a    = argv[i];
+        auto              next = [&](const char * flag) -> const char * {
             if (i + 1 >= argc) {
                 std::fprintf(stderr, "error: %s needs a value\n", flag);
                 std::exit(2);
             }
             return argv[++i];
         };
-        if (a == "-m" || a == "--model")          model_path = next(a.c_str());
-        else if (a == "--backend")                backend = parse_backend(next(a.c_str()));
-        else if (a == "--batch-sizes")            sizes_csv = next(a.c_str());
-        else if (a == "--iters")                  iters = std::atoi(next(a.c_str()));
-        else if (a == "--threads")                n_threads = std::atoi(next(a.c_str()));
-        else if (a == "--out")                    out_path = next(a.c_str());
-        else if (!a.empty() && a[0] != '-')       wav_path = a;
-        else { std::fprintf(stderr, "unknown arg: %s\n", a.c_str()); return 2; }
+        if (a == "-m" || a == "--model") {
+            model_path = next(a.c_str());
+        } else if (a == "--backend") {
+            backend = parse_backend(next(a.c_str()));
+        } else if (a == "--batch-sizes") {
+            sizes_csv = next(a.c_str());
+        } else if (a == "--iters") {
+            iters = std::atoi(next(a.c_str()));
+        } else if (a == "--threads") {
+            n_threads = std::atoi(next(a.c_str()));
+        } else if (a == "--out") {
+            out_path = next(a.c_str());
+        } else if (!a.empty() && a[0] != '-') {
+            wav_path = a;
+        } else {
+            std::fprintf(stderr, "unknown arg: %s\n", a.c_str());
+            return 2;
+        }
     }
     if (model_path.empty() || wav_path.empty()) {
         std::fprintf(stderr,
-            "usage: %s -m model.gguf clip.wav [--backend B] "
-            "[--batch-sizes 1,2,4,8] [--iters N] [--threads N] [--out f.json]\n",
-            argv[0]);
+                     "usage: %s -m model.gguf clip.wav [--backend B] "
+                     "[--batch-sizes 1,2,4,8] [--iters N] [--threads N] [--out f.json]\n",
+                     argv[0]);
         return 2;
     }
-    if (iters < 1) iters = 1;
+    if (iters < 1) {
+        iters = 1;
+    }
 
-    struct transcribe_model_load_params lp; transcribe_model_load_params_init(&lp);
+    struct transcribe_model_load_params lp;
+    transcribe_model_load_params_init(&lp);
     lp.backend = backend;
-    struct transcribe_session_params sp; transcribe_session_params_init(&sp);
-    sp.n_threads = n_threads;
+    struct transcribe_session_params sp;
+    transcribe_session_params_init(&sp);
+    sp.n_threads                  = n_threads;
     struct transcribe_session * s = nullptr;
-    if (auto st = transcribe_open(model_path.c_str(), &lp, &sp, &s);
-        st != TRANSCRIBE_OK)
-    {
+    if (auto st = transcribe_open(model_path.c_str(), &lp, &sp, &s); st != TRANSCRIBE_OK) {
         std::fprintf(stderr, "open failed: %s\n", transcribe_status_string(st));
         return 1;
     }
     const char * dev = transcribe_model_backend(transcribe_get_model(s));
 
     std::vector<float> pcm;
-    std::string err;
+    std::string        err;
     if (!transcribe_cli::load_wav_mono_16k(wav_path, pcm, err)) {
         std::fprintf(stderr, "wav: %s\n", err.c_str());
         transcribe_session_free(s);
         return 1;
     }
-    const double audio_s = (double)pcm.size() / 16000.0;
-    const std::vector<int> sizes = parse_sizes(sizes_csv);
+    const double           audio_s = (double) pcm.size() / 16000.0;
+    const std::vector<int> sizes   = parse_sizes(sizes_csv);
 
     std::string json = "[\n";
     for (size_t si = 0; si < sizes.size(); ++si) {
-        const int N = sizes[si];
+        const int                  N = sizes[si];
         std::vector<const float *> pcm_ptrs(N, pcm.data());
-        std::vector<int>           n_samps(N, (int)pcm.size());
+        std::vector<int>           n_samps(N, (int) pcm.size());
 
         // Warmup (allocates the batch graph / buffers for this shape).
-        auto wst = transcribe_run_batch(s, pcm_ptrs.data(), n_samps.data(), N, nullptr);
+        auto        wst = transcribe_run_batch(s, pcm_ptrs.data(), n_samps.data(), N, nullptr);
         std::string row_err;
         if (wst != TRANSCRIBE_OK) {
             row_err = transcribe_status_string(wst);
         }
 
         const double t_sweep0 = now_ms();
-        double wall_sum = 0.0;
+        double       wall_sum = 0.0;
         for (int it = 0; it < iters && row_err.empty(); ++it) {
             const double t0 = now_ms();
-            auto st = transcribe_run_batch(s, pcm_ptrs.data(), n_samps.data(), N, nullptr);
+            auto         st = transcribe_run_batch(s, pcm_ptrs.data(), n_samps.data(), N, nullptr);
             const double t1 = now_ms();
-            if (st != TRANSCRIBE_OK) { row_err = transcribe_status_string(st); break; }
+            if (st != TRANSCRIBE_OK) {
+                row_err = transcribe_status_string(st);
+                break;
+            }
             wall_sum += (t1 - t0);
         }
         const double elapsed_s = (now_ms() - t_sweep0) / 1000.0;
@@ -159,24 +191,25 @@ int main(int argc, char ** argv) {
 
         char buf[512];
         std::snprintf(buf, sizeof(buf),
-            "  {\"n_batch\": %d, \"wall_mean_ms\": %.3f, \"per_utt_ms\": %.4f, "
-            "\"audio_s\": %.3f, \"n_iters\": %d, \"elapsed_s\": %.4f, "
-            "\"backend\": \"%s\", \"error\": %s}%s\n",
-            N, wall_mean, per_utt, audio_s, iters, elapsed_s,
-            dev ? dev : "",
-            row_err.empty() ? "null" : ("\"" + json_escape(row_err) + "\"").c_str(),
-            (si + 1 < sizes.size()) ? "," : "");
+                      "  {\"n_batch\": %d, \"wall_mean_ms\": %.3f, \"per_utt_ms\": %.4f, "
+                      "\"audio_s\": %.3f, \"n_iters\": %d, \"elapsed_s\": %.4f, "
+                      "\"backend\": \"%s\", \"error\": %s}%s\n",
+                      N, wall_mean, per_utt, audio_s, iters, elapsed_s, dev ? dev : "",
+                      row_err.empty() ? "null" : ("\"" + json_escape(row_err) + "\"").c_str(),
+                      (si + 1 < sizes.size()) ? "," : "");
         json += buf;
 
-        std::fprintf(stderr,
-            "n_batch=%-4d  per_utt=%8.2f ms  wall=%9.2f ms  %s\n",
-            N, per_utt, wall_mean, row_err.empty() ? "" : row_err.c_str());
+        std::fprintf(stderr, "n_batch=%-4d  per_utt=%8.2f ms  wall=%9.2f ms  %s\n", N, per_utt, wall_mean,
+                     row_err.empty() ? "" : row_err.c_str());
     }
     json += "]\n";
 
     if (!out_path.empty()) {
         FILE * f = std::fopen(out_path.c_str(), "w");
-        if (f) { std::fputs(json.c_str(), f); std::fclose(f); }
+        if (f) {
+            std::fputs(json.c_str(), f);
+            std::fclose(f);
+        }
         std::fprintf(stderr, "wrote %s\n", out_path.c_str());
     } else {
         std::fputs(json.c_str(), stdout);
diff --git a/examples/cli/main.cpp b/examples/cli/main.cpp
index 4186caa4..c407f98b 100644
--- a/examples/cli/main.cpp
+++ b/examples/cli/main.cpp
@@ -29,12 +29,17 @@ std::string json_escape(const char * s) {
     std::string out;
     for (const char * p = s ? s : ""; *p; ++p) {
         const unsigned char c = static_cast<unsigned char>(*p);
-        if      (c == '"')  out += "\\\"";
-        else if (c == '\\') out += "\\\\";
-        else if (c == '\n') out += "\\n";
-        else if (c == '\r') out += "\\r";
-        else if (c == '\t') out += "\\t";
-        else if (c < 0x20) {
+        if (c == '"') {
+            out += "\\\"";
+        } else if (c == '\\') {
+            out += "\\\\";
+        } else if (c == '\n') {
+            out += "\\n";
+        } else if (c == '\r') {
+            out += "\\r";
+        } else if (c == '\t') {
+            out += "\\t";
+        } else if (c < 0x20) {
             char buf[8];
             std::snprintf(buf, sizeof(buf), "\\u%04x", c);
             out += buf;
@@ -54,17 +59,20 @@ std::string segments_json(const transcribe_session * ctx) {
         return {};
     }
     const int n_seg = transcribe_n_segments(ctx);
-    if (n_seg <= 0) return {};
+    if (n_seg <= 0) {
+        return {};
+    }
     std::string out = ",\"segments\":[";
     for (int s = 0; s < n_seg; ++s) {
-        if (s > 0) out += ",";
-        struct transcribe_segment seg; transcribe_segment_init(&seg);
-        (void)transcribe_get_segment(ctx, s, &seg);
+        if (s > 0) {
+            out += ",";
+        }
+        struct transcribe_segment seg;
+        transcribe_segment_init(&seg);
+        (void) transcribe_get_segment(ctx, s, &seg);
         char head[96];
-        std::snprintf(head, sizeof(head),
-                      "{\"t0_ms\":%lld,\"t1_ms\":%lld,\"text\":\"",
-                      static_cast<long long>(seg.t0_ms),
-                      static_cast<long long>(seg.t1_ms));
+        std::snprintf(head, sizeof(head), "{\"t0_ms\":%lld,\"t1_ms\":%lld,\"text\":\"",
+                      static_cast<long long>(seg.t0_ms), static_cast<long long>(seg.t1_ms));
         out += head;
         out += json_escape(seg.text != nullptr ? seg.text : "");
         out += "\"}";
@@ -80,17 +88,20 @@ std::string batch_segments_json(const transcribe_session * ctx, int i) {
         return {};
     }
     const int n_seg = transcribe_batch_n_segments(ctx, i);
-    if (n_seg <= 0) return {};
+    if (n_seg <= 0) {
+        return {};
+    }
     std::string out = ",\"segments\":[";
     for (int s = 0; s < n_seg; ++s) {
-        if (s > 0) out += ",";
-        struct transcribe_segment seg; transcribe_segment_init(&seg);
-        (void)transcribe_batch_get_segment(ctx, i, s, &seg);
+        if (s > 0) {
+            out += ",";
+        }
+        struct transcribe_segment seg;
+        transcribe_segment_init(&seg);
+        (void) transcribe_batch_get_segment(ctx, i, s, &seg);
         char head[96];
-        std::snprintf(head, sizeof(head),
-                      "{\"t0_ms\":%lld,\"t1_ms\":%lld,\"text\":\"",
-                      static_cast<long long>(seg.t0_ms),
-                      static_cast<long long>(seg.t1_ms));
+        std::snprintf(head, sizeof(head), "{\"t0_ms\":%lld,\"t1_ms\":%lld,\"text\":\"",
+                      static_cast<long long>(seg.t0_ms), static_cast<long long>(seg.t1_ms));
         out += head;
         out += json_escape(seg.text != nullptr ? seg.text : "");
         out += "\"}";
@@ -100,141 +111,141 @@ std::string batch_segments_json(const transcribe_session * ctx, int i) {
 }
 
 struct cli_args {
-    std::string wav_path;
-    std::string model_path;
-    std::string language;
-    std::string target_language; // --target-language: target lang for translation
-    std::string batch_file; // --batch: one wav path per line
-    int         batch_size = 0; // --batch-size: >1 groups utterances into
-                                // transcribe_run_batch calls (offline only).
-                                // 0/1 keeps the per-file serial loop.
-    bool        translate = false;
-    bool        quiet     = false;
-    bool        list_devices = false; // --list-devices: print devices and exit
-    bool        batch_jsonl = false; // --batch-jsonl: output JSONL
-    int         repeat    = 1;
-    int         n_threads = 0; // 0 = library default (all cores)
-    int         n_ctx     = 0; // 0 = model's true max; >0 lowers the cap
-    transcribe_kv_type kv_type = TRANSCRIBE_KV_TYPE_AUTO;
-    transcribe_backend_request backend = TRANSCRIBE_BACKEND_AUTO;
-    int         gpu_device = 0; // --device N: 0 = auto, >0 = registry index
-    transcribe_timestamp_kind timestamps = TRANSCRIBE_TIMESTAMPS_AUTO;
+    std::string                wav_path;
+    std::string                model_path;
+    std::string                language;
+    std::string                target_language;   // --target-language: target lang for translation
+    std::string                batch_file;        // --batch: one wav path per line
+    int                        batch_size   = 0;  // --batch-size: >1 groups utterances into
+                                                  // transcribe_run_batch calls (offline only).
+                                                  // 0/1 keeps the per-file serial loop.
+    bool                       translate    = false;
+    bool                       quiet        = false;
+    bool                       list_devices = false;  // --list-devices: print devices and exit
+    bool                       batch_jsonl  = false;  // --batch-jsonl: output JSONL
+    int                        repeat       = 1;
+    int                        n_threads    = 0;      // 0 = library default (all cores)
+    int                        n_ctx        = 0;      // 0 = model's true max; >0 lowers the cap
+    transcribe_kv_type         kv_type      = TRANSCRIBE_KV_TYPE_AUTO;
+    transcribe_backend_request backend      = TRANSCRIBE_BACKEND_AUTO;
+    int                        gpu_device   = 0;  // --device N: 0 = auto, >0 = registry index
+    transcribe_timestamp_kind  timestamps   = TRANSCRIBE_TIMESTAMPS_AUTO;
 
     // Whisper-family knobs. Ignored for non-Whisper models.
-    std::string initial_prompt;                // --initial-prompt TEXT
-    bool        whisper_set                  = false;
-    bool        temperature_set              = false; // --temperature F
-    float       temperature                  = 0.0f;  // tier-0 sampling temp
-    bool        condition_on_prev_tokens     = false; // --condition-on-prev-tokens
+    std::string                              initial_prompt;                    // --initial-prompt TEXT
+    bool                                     whisper_set              = false;
+    bool                                     temperature_set          = false;  // --temperature F
+    float                                    temperature              = 0.0f;   // tier-0 sampling temp
+    bool                                     condition_on_prev_tokens = false;  // --condition-on-prev-tokens
     enum transcribe_whisper_prompt_condition prompt_condition =
-        TRANSCRIBE_WHISPER_PROMPT_FIRST_SEGMENT;       // --prompt-condition first|all
+        TRANSCRIBE_WHISPER_PROMPT_FIRST_SEGMENT;                                // --prompt-condition first|all
 
     // SenseVoice / FunASR-Nano family knobs. The `--itn` flag is shared:
     // it routes to whichever family the loaded model belongs to. Ignored
     // by non-ITN-aware families.
-    bool        use_itn                      = false; // --itn
-    bool        itn_set                      = false;
-    bool        keep_special_tags            = false; // --raw-tokens
+    bool use_itn           = false;  // --itn
+    bool itn_set           = false;
+    bool keep_special_tags = false;  // --raw-tokens
 
     // Canary family knobs. Ignored by non-Canary families.
-    bool        canary_pnc                   = true;  // default: punctuation+caps on
-    bool        canary_pnc_set               = false; // --pnc / --no-pnc set this
+    bool canary_pnc     = true;   // default: punctuation+caps on
+    bool canary_pnc_set = false;  // --pnc / --no-pnc set this
 
     // Streaming demo: when > 0, the single-file path feeds the WAV
     // through transcribe_stream_begin/feed/finalize in fixed-size
     // ms-aligned chunks instead of one transcribe_run call. Requires
     // the loaded model to advertise supports_streaming. Set by
     // --stream-chunk-ms N.
-    int         stream_chunk_ms              = 0;
+    int stream_chunk_ms      = 0;
     // Parakeet streaming: pick a right-context (lookahead) setting
     // from the model's training menu. -1 = model default (max
     // accuracy / max latency); 0/1/6/13 select the published
     // nemotron-speech-streaming-en-0.6b settings. Set by
     // --stream-att-right N. Ignored when stream_chunk_ms == 0.
-    int         stream_att_right             = -1;
+    int stream_att_right     = -1;
     // Parakeet buffered streaming (parakeet-unified-en-0.6b): override
     // the (L, C, R) attention context tuple in milliseconds. -1 = use
     // the model's default (highest-accuracy row of the training menu).
     // Frame-aligned: the lib rounds each value down to the nearest
     // post-subsample frame (80ms at 4x subsampling). Ignored when
     // stream_chunk_ms == 0 or when the model is not buffered-streaming.
-    int         stream_buf_left_ms           = -1;
-    int         stream_buf_chunk_ms          = -1;
-    int         stream_buf_right_ms          = -1;
+    int stream_buf_left_ms   = -1;
+    int stream_buf_chunk_ms  = -1;
+    int stream_buf_right_ms  = -1;
     // Voxtral Realtime streaming: transcription delay in 12.5 Hz audio
     // tokens (80 ms each). -1 = model default (6 = 480 ms). Set by
     // --stream-voxtral-delay N. Ignored when stream_chunk_ms == 0 or when
     // the model is not voxtral_realtime.
-    int         stream_voxtral_delay         = -1;
+    int stream_voxtral_delay = -1;
     // Speculative-decode draft length passed through to
     // transcribe_run_params::spec_k_drafts on the offline path. -1 = family
     // default (each family picks its tuned K). 0 = explicitly off. >0 =
     // explicit K. Silently ignored by families without
     // supports_spec_decode. Set by --spec-k-drafts N.
-    int         spec_k_drafts                = -1;
+    int spec_k_drafts        = -1;
 };
 
 void print_usage(const char * argv0) {
     std::fprintf(stderr,
-        "usage: %s [options] audio.wav\n"
-        "       %s [options] --batch file.list -m model.gguf\n"
-        "options:\n"
-        "  -m, --model PATH      GGUF model file\n"
-        "  -l, --language ISO    BCP-47-ish language hint (e.g. en, de)\n"
-        "  -t, --translate       set task to TRANSLATE\n"
-        "  --target-language ISO target language for translation (e.g. de, es, fr)\n"
-        "  -q, --quiet           suppress library log output\n"
-        "  -r, --repeat N        run N times per file (benchmark)\n"
-        "  --threads N           CPU threads (default: all cores)\n"
-        "  --n-ctx N             session context/KV cap in tokens (bounds decoder\n"
-        "                        KV memory; cannot extend the model): 0 = model\n"
-        "                        max, >max is clamped down. Lowers the effective\n"
-        "                        max audio.\n"
-        "  --kv-type TYPE        flash-attn KV type: auto, f32, f16 (default: auto)\n"
-        "  --backend TYPE        compute backend: auto, cpu, cpu_accel, metal, vulkan, cuda\n"
-        "                        (default: auto)\n"
-        "  --device N            GPU device index from --list-devices: 0 = auto\n"
-        "                        (first of kind), >0 selects that registry index\n"
-        "  --timestamps TYPE     timestamps: auto, none, segment, word, token (default: auto)\n"
-        "  --batch FILE          batch mode: FILE has one wav path per line\n"
-        "  --batch-jsonl         output one JSON line per file (for batch)\n"
-        "  --batch-size N        group N utterances into one transcribe_run_batch\n"
-        "                        call (offline only; 0/1 = per-file serial loop)\n"
-        "  --initial-prompt TEXT (whisper) initial prompt text for context biasing\n"
-        "  --temperature F       (whisper) tier-0 sampling temperature (default 0 = greedy)\n"
-        "  --condition-on-prev-tokens (whisper) carry prev-chunk tokens across chunks\n"
-        "  --prompt-condition T  (whisper) prompt placement: first|all (default: first)\n"
-        "  --itn                 (sensevoice/funasr-nano) enable inverse text normalization\n"
-        "  --pnc                 (canary) emit punctuation and capitalization (default)\n"
-        "  --no-pnc              (canary) emit lowercase de-punctuated text\n"
-        "  --raw-tokens          keep <|...|> control tokens in output text\n"
-        "  --stream-chunk-ms N   single-file: drive the streaming API by feeding\n"
-        "                        N-ms PCM slices; requires model to advertise\n"
-        "                        supports_streaming\n"
-        "  --stream-att-right R  (parakeet streaming) pick the right-context\n"
-        "                        setting from the model's training menu;\n"
-        "                        nemotron-speech-streaming-en-0.6b accepts\n"
-        "                        R in {0,1,6,13}; default = model's first choice\n"
-        "  --stream-buf-left-ms N  (parakeet-unified buffered streaming)\n"
-        "                        left-context size in ms; -1 = model default\n"
-        "  --stream-buf-chunk-ms N (parakeet-unified buffered streaming)\n"
-        "                        chunk size in ms; -1 = model default\n"
-        "  --stream-buf-right-ms N (parakeet-unified buffered streaming)\n"
-        "                        right-context (lookahead) size in ms;\n"
-        "                        -1 = model default\n"
-        "  --stream-voxtral-delay N (voxtral_realtime streaming) transcription\n"
-        "                        delay in 12.5 Hz tokens (80 ms each); valid\n"
-        "                        N = 1..15 (80..1200 ms) or 30 (2400 ms);\n"
-        "                        -1 = model default (6 = 480 ms)\n"
-        "  --spec-k-drafts N     speculative-decode draft length on offline\n"
-        "                        autoregressive families that advertise\n"
-        "                        supports_spec_decode. -1 = family default,\n"
-        "                        0 = off, > 0 = explicit K. Silently ignored\n"
-        "                        by families without spec support.\n"
-        "  --list-devices        list registered compute devices (with memory)\n"
-        "                        and exit; ignores all other options\n"
-        "  -h, --help            show this help\n",
-        argv0, argv0);
+                 "usage: %s [options] audio.wav\n"
+                 "       %s [options] --batch file.list -m model.gguf\n"
+                 "options:\n"
+                 "  -m, --model PATH      GGUF model file\n"
+                 "  -l, --language ISO    BCP-47-ish language hint (e.g. en, de)\n"
+                 "  -t, --translate       set task to TRANSLATE\n"
+                 "  --target-language ISO target language for translation (e.g. de, es, fr)\n"
+                 "  -q, --quiet           suppress library log output\n"
+                 "  -r, --repeat N        run N times per file (benchmark)\n"
+                 "  --threads N           CPU threads (default: all cores)\n"
+                 "  --n-ctx N             session context/KV cap in tokens (bounds decoder\n"
+                 "                        KV memory; cannot extend the model): 0 = model\n"
+                 "                        max, >max is clamped down. Lowers the effective\n"
+                 "                        max audio.\n"
+                 "  --kv-type TYPE        flash-attn KV type: auto, f32, f16 (default: auto)\n"
+                 "  --backend TYPE        compute backend: auto, cpu, cpu_accel, metal, vulkan, cuda\n"
+                 "                        (default: auto)\n"
+                 "  --device N            GPU device index from --list-devices: 0 = auto\n"
+                 "                        (first of kind), >0 selects that registry index\n"
+                 "  --timestamps TYPE     timestamps: auto, none, segment, word, token (default: auto)\n"
+                 "  --batch FILE          batch mode: FILE has one wav path per line\n"
+                 "  --batch-jsonl         output one JSON line per file (for batch)\n"
+                 "  --batch-size N        group N utterances into one transcribe_run_batch\n"
+                 "                        call (offline only; 0/1 = per-file serial loop)\n"
+                 "  --initial-prompt TEXT (whisper) initial prompt text for context biasing\n"
+                 "  --temperature F       (whisper) tier-0 sampling temperature (default 0 = greedy)\n"
+                 "  --condition-on-prev-tokens (whisper) carry prev-chunk tokens across chunks\n"
+                 "  --prompt-condition T  (whisper) prompt placement: first|all (default: first)\n"
+                 "  --itn                 (sensevoice/funasr-nano) enable inverse text normalization\n"
+                 "  --pnc                 (canary) emit punctuation and capitalization (default)\n"
+                 "  --no-pnc              (canary) emit lowercase de-punctuated text\n"
+                 "  --raw-tokens          keep <|...|> control tokens in output text\n"
+                 "  --stream-chunk-ms N   single-file: drive the streaming API by feeding\n"
+                 "                        N-ms PCM slices; requires model to advertise\n"
+                 "                        supports_streaming\n"
+                 "  --stream-att-right R  (parakeet streaming) pick the right-context\n"
+                 "                        setting from the model's training menu;\n"
+                 "                        nemotron-speech-streaming-en-0.6b accepts\n"
+                 "                        R in {0,1,6,13}; default = model's first choice\n"
+                 "  --stream-buf-left-ms N  (parakeet-unified buffered streaming)\n"
+                 "                        left-context size in ms; -1 = model default\n"
+                 "  --stream-buf-chunk-ms N (parakeet-unified buffered streaming)\n"
+                 "                        chunk size in ms; -1 = model default\n"
+                 "  --stream-buf-right-ms N (parakeet-unified buffered streaming)\n"
+                 "                        right-context (lookahead) size in ms;\n"
+                 "                        -1 = model default\n"
+                 "  --stream-voxtral-delay N (voxtral_realtime streaming) transcription\n"
+                 "                        delay in 12.5 Hz tokens (80 ms each); valid\n"
+                 "                        N = 1..15 (80..1200 ms) or 30 (2400 ms);\n"
+                 "                        -1 = model default (6 = 480 ms)\n"
+                 "  --spec-k-drafts N     speculative-decode draft length on offline\n"
+                 "                        autoregressive families that advertise\n"
+                 "                        supports_spec_decode. -1 = family default,\n"
+                 "                        0 = off, > 0 = explicit K. Silently ignored\n"
+                 "                        by families without spec support.\n"
+                 "  --list-devices        list registered compute devices (with memory)\n"
+                 "                        and exit; ignores all other options\n"
+                 "  -h, --help            show this help\n",
+                 argv0, argv0);
 }
 
 // Print every registered compute device and its live memory, then return an
@@ -246,7 +257,8 @@ int list_devices_main() {
     if (st != TRANSCRIBE_OK) {
         std::fprintf(stderr,
                      "warning: transcribe_init_backends_default() returned %d; "
-                     "listing whatever registered\n", (int) st);
+                     "listing whatever registered\n",
+                     (int) st);
     }
     const int n = transcribe_backend_device_count();
     if (n <= 0) {
@@ -260,27 +272,25 @@ int list_devices_main() {
         if (transcribe_get_backend_device(i, &d) != TRANSCRIBE_OK) {
             continue;
         }
-        const char * type_str =
-            d.device_type == TRANSCRIBE_DEVICE_TYPE_CPU   ? "cpu"   :
-            d.device_type == TRANSCRIBE_DEVICE_TYPE_GPU   ? "gpu"   :
-            d.device_type == TRANSCRIBE_DEVICE_TYPE_IGPU  ? "igpu"  :
-            d.device_type == TRANSCRIBE_DEVICE_TYPE_ACCEL ? "accel" : "?";
-        const double gib = 1024.0 * 1024.0 * 1024.0;
-        std::printf("  [%d] %s\n", i,
-                    (d.description && *d.description) ? d.description : d.name);
-        std::printf("      name=%s  kind=%s  type=%s  id=%s\n",
-                    d.name ? d.name : "?", d.kind ? d.kind : "?", type_str,
+        const char * type_str = d.device_type == TRANSCRIBE_DEVICE_TYPE_CPU   ? "cpu" :
+                                d.device_type == TRANSCRIBE_DEVICE_TYPE_GPU   ? "gpu" :
+                                d.device_type == TRANSCRIBE_DEVICE_TYPE_IGPU  ? "igpu" :
+                                d.device_type == TRANSCRIBE_DEVICE_TYPE_ACCEL ? "accel" :
+                                                                                "?";
+        const double gib      = 1024.0 * 1024.0 * 1024.0;
+        std::printf("  [%d] %s\n", i, (d.description && *d.description) ? d.description : d.name);
+        std::printf("      name=%s  kind=%s  type=%s  id=%s\n", d.name ? d.name : "?", d.kind ? d.kind : "?", type_str,
                     (d.device_id && *d.device_id) ? d.device_id : "(none)");
-        std::printf("      memory: %.2f GiB total, %.2f GiB free\n",
-                    (double) d.memory_total / gib, (double) d.memory_free / gib);
+        std::printf("      memory: %.2f GiB total, %.2f GiB free\n", (double) d.memory_total / gib,
+                    (double) d.memory_free / gib);
     }
     return EXIT_SUCCESS;
 }
 
 bool parse_args(int argc, char ** argv, cli_args & out) {
     for (int i = 1; i < argc; ++i) {
-        const std::string a = argv[i];
-        auto take_value = [&](const char * name) -> const char * {
+        const std::string a          = argv[i];
+        auto              take_value = [&](const char * name) -> const char * {
             if (i + 1 >= argc) {
                 std::fprintf(stderr, "error: %s requires an argument\n", name);
                 return nullptr;
@@ -295,15 +305,21 @@ bool parse_args(int argc, char ** argv, cli_args & out) {
             out.list_devices = true;
         } else if (a == "-m" || a == "--model") {
             const char * v = take_value(a.c_str());
-            if (!v) return false;
+            if (!v) {
+                return false;
+            }
             out.model_path = v;
         } else if (a == "-l" || a == "--language") {
             const char * v = take_value(a.c_str());
-            if (!v) return false;
+            if (!v) {
+                return false;
+            }
             out.language = v;
         } else if (a == "--target-language") {
             const char * v = take_value(a.c_str());
-            if (!v) return false;
+            if (!v) {
+                return false;
+            }
             out.target_language = v;
         } else if (a == "-t" || a == "--translate") {
             out.translate = true;
@@ -311,51 +327,75 @@ bool parse_args(int argc, char ** argv, cli_args & out) {
             out.quiet = true;
         } else if (a == "-r" || a == "--repeat") {
             const char * v = take_value(a.c_str());
-            if (!v) return false;
+            if (!v) {
+                return false;
+            }
             out.repeat = std::atoi(v);
-            if (out.repeat < 1) out.repeat = 1;
+            if (out.repeat < 1) {
+                out.repeat = 1;
+            }
         } else if (a == "--n-ctx") {
             const char * v = take_value(a.c_str());
-            if (!v) return false;
+            if (!v) {
+                return false;
+            }
             out.n_ctx = std::atoi(v);
             if (out.n_ctx < 0) {
-                std::fprintf(stderr,
-                             "error: --n-ctx must be >= 0 (0 = model max)\n");
+                std::fprintf(stderr, "error: --n-ctx must be >= 0 (0 = model max)\n");
                 return false;
             }
         } else if (a == "--threads") {
             const char * v = take_value(a.c_str());
-            if (!v) return false;
+            if (!v) {
+                return false;
+            }
             out.n_threads = std::atoi(v);
-            if (out.n_threads < 1) out.n_threads = 1;
+            if (out.n_threads < 1) {
+                out.n_threads = 1;
+            }
         } else if (a == "--kv-type") {
             const char * v = take_value(a.c_str());
-            if (!v) return false;
+            if (!v) {
+                return false;
+            }
             const std::string vs = v;
-            if      (vs == "auto") out.kv_type = TRANSCRIBE_KV_TYPE_AUTO;
-            else if (vs == "f32")  out.kv_type = TRANSCRIBE_KV_TYPE_F32;
-            else if (vs == "f16")  out.kv_type = TRANSCRIBE_KV_TYPE_F16;
-            else {
+            if (vs == "auto") {
+                out.kv_type = TRANSCRIBE_KV_TYPE_AUTO;
+            } else if (vs == "f32") {
+                out.kv_type = TRANSCRIBE_KV_TYPE_F32;
+            } else if (vs == "f16") {
+                out.kv_type = TRANSCRIBE_KV_TYPE_F16;
+            } else {
                 std::fprintf(stderr, "error: --kv-type must be auto, f32, or f16\n");
                 return false;
             }
         } else if (a == "--backend") {
             const char * v = take_value(a.c_str());
-            if (!v) return false;
+            if (!v) {
+                return false;
+            }
             const std::string vs = v;
-            if      (vs == "auto")      out.backend = TRANSCRIBE_BACKEND_AUTO;
-            else if (vs == "cpu")       out.backend = TRANSCRIBE_BACKEND_CPU;
-            else if (vs == "cpu_accel") out.backend = TRANSCRIBE_BACKEND_CPU_ACCEL;
-            else if (vs == "metal")     out.backend = TRANSCRIBE_BACKEND_METAL;
-            else if (vs == "vulkan")    out.backend = TRANSCRIBE_BACKEND_VULKAN;
-            else if (vs == "cuda")      out.backend = TRANSCRIBE_BACKEND_CUDA;
-            else {
+            if (vs == "auto") {
+                out.backend = TRANSCRIBE_BACKEND_AUTO;
+            } else if (vs == "cpu") {
+                out.backend = TRANSCRIBE_BACKEND_CPU;
+            } else if (vs == "cpu_accel") {
+                out.backend = TRANSCRIBE_BACKEND_CPU_ACCEL;
+            } else if (vs == "metal") {
+                out.backend = TRANSCRIBE_BACKEND_METAL;
+            } else if (vs == "vulkan") {
+                out.backend = TRANSCRIBE_BACKEND_VULKAN;
+            } else if (vs == "cuda") {
+                out.backend = TRANSCRIBE_BACKEND_CUDA;
+            } else {
                 std::fprintf(stderr, "error: --backend must be auto, cpu, cpu_accel, metal, vulkan, or cuda\n");
                 return false;
             }
         } else if (a == "--device") {
             const char * v = take_value(a.c_str());
-            if (!v) return false;
+            if (!v) {
+                return false;
+            }
             out.gpu_device = std::atoi(v);
             if (out.gpu_device < 0) {
                 std::fprintf(stderr, "error: --device must be >= 0 (0 = auto)\n");
@@ -363,27 +403,37 @@ bool parse_args(int argc, char ** argv, cli_args & out) {
             }
         } else if (a == "--timestamps") {
             const char * v = take_value(a.c_str());
-            if (!v) return false;
+            if (!v) {
+                return false;
+            }
             const std::string vs = v;
-            if      (vs == "auto")    out.timestamps = TRANSCRIBE_TIMESTAMPS_AUTO;
-            else if (vs == "none")    out.timestamps = TRANSCRIBE_TIMESTAMPS_NONE;
-            else if (vs == "segment") out.timestamps = TRANSCRIBE_TIMESTAMPS_SEGMENT;
-            else if (vs == "word")    out.timestamps = TRANSCRIBE_TIMESTAMPS_WORD;
-            else if (vs == "token")   out.timestamps = TRANSCRIBE_TIMESTAMPS_TOKEN;
-            else {
-                std::fprintf(stderr,
-                             "error: --timestamps must be auto, none, segment, word, or token\n");
+            if (vs == "auto") {
+                out.timestamps = TRANSCRIBE_TIMESTAMPS_AUTO;
+            } else if (vs == "none") {
+                out.timestamps = TRANSCRIBE_TIMESTAMPS_NONE;
+            } else if (vs == "segment") {
+                out.timestamps = TRANSCRIBE_TIMESTAMPS_SEGMENT;
+            } else if (vs == "word") {
+                out.timestamps = TRANSCRIBE_TIMESTAMPS_WORD;
+            } else if (vs == "token") {
+                out.timestamps = TRANSCRIBE_TIMESTAMPS_TOKEN;
+            } else {
+                std::fprintf(stderr, "error: --timestamps must be auto, none, segment, word, or token\n");
                 return false;
             }
         } else if (a == "--batch") {
             const char * v = take_value(a.c_str());
-            if (!v) return false;
+            if (!v) {
+                return false;
+            }
             out.batch_file = v;
         } else if (a == "--batch-jsonl") {
             out.batch_jsonl = true;
         } else if (a == "--batch-size") {
             const char * v = take_value(a.c_str());
-            if (!v) return false;
+            if (!v) {
+                return false;
+            }
             out.batch_size = std::atoi(v);
             if (out.batch_size < 0) {
                 std::fprintf(stderr, "error: --batch-size must be >= 0\n");
@@ -391,12 +441,16 @@ bool parse_args(int argc, char ** argv, cli_args & out) {
             }
         } else if (a == "--initial-prompt") {
             const char * v = take_value(a.c_str());
-            if (!v) return false;
+            if (!v) {
+                return false;
+            }
             out.initial_prompt = v;
             out.whisper_set    = true;
         } else if (a == "--temperature") {
             const char * v = take_value(a.c_str());
-            if (!v) return false;
+            if (!v) {
+                return false;
+            }
             out.temperature     = static_cast<float>(std::atof(v));
             out.temperature_set = true;
             out.whisper_set     = true;
@@ -405,13 +459,16 @@ bool parse_args(int argc, char ** argv, cli_args & out) {
             out.whisper_set              = true;
         } else if (a == "--prompt-condition") {
             const char * v = take_value(a.c_str());
-            if (!v) return false;
+            if (!v) {
+                return false;
+            }
             const std::string vs = v;
-            if      (vs == "first") out.prompt_condition = TRANSCRIBE_WHISPER_PROMPT_FIRST_SEGMENT;
-            else if (vs == "all")   out.prompt_condition = TRANSCRIBE_WHISPER_PROMPT_ALL_SEGMENTS;
-            else {
-                std::fprintf(stderr,
-                             "error: --prompt-condition must be first or all\n");
+            if (vs == "first") {
+                out.prompt_condition = TRANSCRIBE_WHISPER_PROMPT_FIRST_SEGMENT;
+            } else if (vs == "all") {
+                out.prompt_condition = TRANSCRIBE_WHISPER_PROMPT_ALL_SEGMENTS;
+            } else {
+                std::fprintf(stderr, "error: --prompt-condition must be first or all\n");
                 return false;
             }
             out.whisper_set = true;
@@ -428,45 +485,56 @@ bool parse_args(int argc, char ** argv, cli_args & out) {
             out.keep_special_tags = true;
         } else if (a == "--stream-chunk-ms") {
             const char * v = take_value(a.c_str());
-            if (!v) return false;
+            if (!v) {
+                return false;
+            }
             out.stream_chunk_ms = std::atoi(v);
             if (out.stream_chunk_ms <= 0) {
-                std::fprintf(stderr,
-                             "error: --stream-chunk-ms must be > 0\n");
+                std::fprintf(stderr, "error: --stream-chunk-ms must be > 0\n");
                 return false;
             }
         } else if (a == "--stream-att-right") {
             const char * v = take_value(a.c_str());
-            if (!v) return false;
+            if (!v) {
+                return false;
+            }
             out.stream_att_right = std::atoi(v);
             if (out.stream_att_right < 0) {
-                std::fprintf(stderr,
-                             "error: --stream-att-right must be >= 0\n");
+                std::fprintf(stderr, "error: --stream-att-right must be >= 0\n");
                 return false;
             }
         } else if (a == "--stream-buf-left-ms") {
             const char * v = take_value(a.c_str());
-            if (!v) return false;
+            if (!v) {
+                return false;
+            }
             out.stream_buf_left_ms = std::atoi(v);
         } else if (a == "--stream-buf-chunk-ms") {
             const char * v = take_value(a.c_str());
-            if (!v) return false;
+            if (!v) {
+                return false;
+            }
             out.stream_buf_chunk_ms = std::atoi(v);
         } else if (a == "--stream-buf-right-ms") {
             const char * v = take_value(a.c_str());
-            if (!v) return false;
+            if (!v) {
+                return false;
+            }
             out.stream_buf_right_ms = std::atoi(v);
         } else if (a == "--stream-voxtral-delay") {
             const char * v = take_value(a.c_str());
-            if (!v) return false;
+            if (!v) {
+                return false;
+            }
             out.stream_voxtral_delay = std::atoi(v);
         } else if (a == "--spec-k-drafts") {
             const char * v = take_value(a.c_str());
-            if (!v) return false;
+            if (!v) {
+                return false;
+            }
             out.spec_k_drafts = std::atoi(v);
             if (out.spec_k_drafts < -1) {
-                std::fprintf(stderr,
-                             "error: --spec-k-drafts must be -1 (family default), 0 (off), or > 0\n");
+                std::fprintf(stderr, "error: --spec-k-drafts must be -1 (family default), 0 (off), or > 0\n");
                 return false;
             }
         } else if (!a.empty() && a[0] == '-') {
@@ -494,29 +562,38 @@ bool parse_args(int argc, char ** argv, cli_args & out) {
         return false;
     }
     if (out.stream_chunk_ms > 0 && out.repeat > 1) {
-        std::fprintf(stderr,
-                     "error: --stream-chunk-ms cannot be combined with --repeat\n");
+        std::fprintf(stderr, "error: --stream-chunk-ms cannot be combined with --repeat\n");
         return false;
     }
     return true;
 }
 
 void log_cb(transcribe_log_level level, const char * msg, void * userdata) {
-    (void)userdata;
+    (void) userdata;
     const char * prefix = "[?]";
     switch (level) {
-        case TRANSCRIBE_LOG_LEVEL_NONE:  return;
-        case TRANSCRIBE_LOG_LEVEL_INFO:  prefix = "[info]";  break;
-        case TRANSCRIBE_LOG_LEVEL_WARN:  prefix = "[warn]";  break;
-        case TRANSCRIBE_LOG_LEVEL_ERROR: prefix = "[error]"; break;
-        case TRANSCRIBE_LOG_LEVEL_DEBUG: prefix = "[debug]"; break;
-        case TRANSCRIBE_LOG_LEVEL_CONT:  prefix = "";        break;
+        case TRANSCRIBE_LOG_LEVEL_NONE:
+            return;
+        case TRANSCRIBE_LOG_LEVEL_INFO:
+            prefix = "[info]";
+            break;
+        case TRANSCRIBE_LOG_LEVEL_WARN:
+            prefix = "[warn]";
+            break;
+        case TRANSCRIBE_LOG_LEVEL_ERROR:
+            prefix = "[error]";
+            break;
+        case TRANSCRIBE_LOG_LEVEL_DEBUG:
+            prefix = "[debug]";
+            break;
+        case TRANSCRIBE_LOG_LEVEL_CONT:
+            prefix = "";
+            break;
     }
-    std::fprintf(stderr, "%s %s%s", prefix, msg,
-                 (msg && *msg && msg[std::strlen(msg) - 1] == '\n') ? "" : "\n");
+    std::fprintf(stderr, "%s %s%s", prefix, msg, (msg && *msg && msg[std::strlen(msg) - 1] == '\n') ? "" : "\n");
 }
 
-} // namespace
+}  // namespace
 
 int main(int argc, char ** argv) {
     cli_args args;
@@ -555,16 +632,13 @@ int main(int argc, char ** argv) {
         {
             std::ifstream fin(args.batch_file);
             if (!fin) {
-                std::fprintf(stderr, "error: cannot open batch file %s\n",
-                             args.batch_file.c_str());
+                std::fprintf(stderr, "error: cannot open batch file %s\n", args.batch_file.c_str());
                 return EXIT_FAILURE;
             }
             std::string line;
             while (std::getline(fin, line)) {
                 while (!line.empty() &&
-                       (line.back() == '\n' || line.back() == '\r' ||
-                        line.back() == ' '  || line.back() == '\t'))
-                {
+                       (line.back() == '\n' || line.back() == '\r' || line.back() == ' ' || line.back() == '\t')) {
                     line.pop_back();
                 }
                 if (!line.empty()) {
@@ -580,65 +654,67 @@ int main(int argc, char ** argv) {
             std::fprintf(stderr, "batch: %zu files\n", wav_paths.size());
         }
 
-        struct transcribe_model_load_params mp; transcribe_model_load_params_init(&mp);
-        mp.backend = args.backend;
-        mp.gpu_device = args.gpu_device;
-        struct transcribe_model *      model = nullptr;
-        const transcribe_status        load_st =
-            transcribe_model_load_file(args.model_path.c_str(), &mp, &model);
+        struct transcribe_model_load_params mp;
+        transcribe_model_load_params_init(&mp);
+        mp.backend                        = args.backend;
+        mp.gpu_device                     = args.gpu_device;
+        struct transcribe_model * model   = nullptr;
+        const transcribe_status   load_st = transcribe_model_load_file(args.model_path.c_str(), &mp, &model);
         if (load_st != TRANSCRIBE_OK) {
-            std::fprintf(stderr, "model load: %s\n",
-                         transcribe_status_string(load_st));
+            std::fprintf(stderr, "model load: %s\n", transcribe_status_string(load_st));
             return EXIT_FAILURE;
         }
 
-        struct transcribe_session_params cp; transcribe_session_params_init(&cp);
-        cp.n_threads = args.n_threads;
-        cp.n_ctx     = args.n_ctx;
-        cp.kv_type   = args.kv_type;
-        struct transcribe_session *      ctx = nullptr;
-        const transcribe_status          init_st =
-            transcribe_session_init(model, &cp, &ctx);
+        struct transcribe_session_params cp;
+        transcribe_session_params_init(&cp);
+        cp.n_threads                        = args.n_threads;
+        cp.n_ctx                            = args.n_ctx;
+        cp.kv_type                          = args.kv_type;
+        struct transcribe_session * ctx     = nullptr;
+        const transcribe_status     init_st = transcribe_session_init(model, &cp, &ctx);
         if (init_st != TRANSCRIBE_OK) {
-            std::fprintf(stderr, "context init: %s\n",
-                         transcribe_status_string(init_st));
+            std::fprintf(stderr, "context init: %s\n", transcribe_status_string(init_st));
             transcribe_model_free(model);
             return EXIT_FAILURE;
         }
 
-        struct transcribe_run_params rp; transcribe_run_params_init(&rp);
-        if (args.translate)         rp.task     = TRANSCRIBE_TASK_TRANSLATE;
-        if (!args.language.empty()) rp.language = args.language.c_str();
-        if (!args.target_language.empty()) rp.target_language = args.target_language.c_str();
-        rp.timestamps   = args.timestamps;
+        struct transcribe_run_params rp;
+        transcribe_run_params_init(&rp);
+        if (args.translate) {
+            rp.task = TRANSCRIBE_TASK_TRANSLATE;
+        }
+        if (!args.language.empty()) {
+            rp.language = args.language.c_str();
+        }
+        if (!args.target_language.empty()) {
+            rp.target_language = args.target_language.c_str();
+        }
+        rp.timestamps    = args.timestamps;
         rp.spec_k_drafts = args.spec_k_drafts;
 
         if (args.itn_set) {
-            rp.itn = args.use_itn ? TRANSCRIBE_ITN_MODE_ON
-                                  : TRANSCRIBE_ITN_MODE_OFF;
+            rp.itn = args.use_itn ? TRANSCRIBE_ITN_MODE_ON : TRANSCRIBE_ITN_MODE_OFF;
         }
         if (args.canary_pnc_set) {
-            rp.pnc = args.canary_pnc ? TRANSCRIBE_PNC_MODE_ON
-                                     : TRANSCRIBE_PNC_MODE_OFF;
+            rp.pnc = args.canary_pnc ? TRANSCRIBE_PNC_MODE_ON : TRANSCRIBE_PNC_MODE_OFF;
         }
 
         // Whisper run extension. Allocated outside rp's scope so its
         // bytes outlive the per-file loop below; the library copies
         // initial_prompt/prompt_tokens before transcribe_run returns,
         // but rp aliases &wx.ext for the run call itself.
-        struct transcribe_whisper_run_ext wx; transcribe_whisper_run_ext_init(&wx);
+        struct transcribe_whisper_run_ext wx;
+        transcribe_whisper_run_ext_init(&wx);
         if (args.whisper_set) {
             if (!args.initial_prompt.empty()) {
                 wx.initial_prompt = args.initial_prompt.c_str();
             }
             wx.condition_on_prev_tokens = args.condition_on_prev_tokens;
-            if (args.temperature_set) wx.temperature = args.temperature;
-            wx.prompt_condition         = args.prompt_condition;
-            if (transcribe_model_accepts_ext_kind(
-                    model,
-                    TRANSCRIBE_EXT_SLOT_RUN,
-                    TRANSCRIBE_EXT_KIND_WHISPER_RUN))
-            {
+            if (args.temperature_set) {
+                wx.temperature = args.temperature;
+            }
+            wx.prompt_condition = args.prompt_condition;
+            if (transcribe_model_accepts_ext_kind(model, TRANSCRIBE_EXT_SLOT_RUN, TRANSCRIBE_EXT_KIND_WHISPER_RUN)) {
                 rp.family = &wx.ext;
             }
         }
@@ -651,14 +727,14 @@ int main(int argc, char ** argv) {
         // the one-shot load time so downstream WER tooling can record it
         // without parsing stderr. Per-file lines follow on subsequent lines.
         if (args.batch_jsonl) {
-            struct transcribe_timings load_tm; transcribe_timings_init(&load_tm);
-            (void)transcribe_get_timings(ctx, &load_tm);
-            std::printf("{\"type\":\"batch_header\",\"load_ms\":%.1f}\n",
-                        (double)load_tm.load_ms);
+            struct transcribe_timings load_tm;
+            transcribe_timings_init(&load_tm);
+            (void) transcribe_get_timings(ctx, &load_tm);
+            std::printf("{\"type\":\"batch_header\",\"load_ms\":%.1f}\n", (double) load_tm.load_ms);
             std::fflush(stdout);
         }
 
-        int n_ok = 0;
+        int n_ok   = 0;
         int n_fail = 0;
 
         // Offline batched path: group up to batch_size utterances into one
@@ -666,8 +742,7 @@ int main(int argc, char ** argv) {
         // path (--stream-chunk-ms), which is per-utterance by construction.
         // Per-file JSONL output is byte-identical in shape to the serial
         // path so the WER harness (scripts/wer/run.py) consumes either.
-        const bool use_batched =
-            args.batch_size > 1 && args.stream_chunk_ms <= 0;
+        const bool use_batched = args.batch_size > 1 && args.stream_chunk_ms <= 0;
         if (use_batched) {
             const size_t total = wav_paths.size();
             const size_t group = static_cast<size_t>(args.batch_size);
@@ -680,18 +755,18 @@ int main(int argc, char ** argv) {
                 std::vector<std::vector<float>> pcms;
                 std::vector<const float *>      pcm_ptrs;
                 std::vector<int>                n_samps;
-                std::vector<size_t>             src_index;   // -> wav_paths
+                std::vector<size_t>             src_index;  // -> wav_paths
                 for (size_t i = base; i < end; ++i) {
                     std::vector<float> pcm;
                     std::string        wav_err;
                     if (!transcribe_cli::load_wav_mono_16k(wav_paths[i], pcm, wav_err)) {
                         if (args.batch_jsonl) {
-                            std::printf("{\"file\":\"%s\",\"text\":\"\","
-                                        "\"error\":\"wav: %s\"}\n",
-                                        wav_paths[i].c_str(), wav_err.c_str());
+                            std::printf(
+                                "{\"file\":\"%s\",\"text\":\"\","
+                                "\"error\":\"wav: %s\"}\n",
+                                wav_paths[i].c_str(), wav_err.c_str());
                         } else {
-                            std::fprintf(stderr, "SKIP %s: %s\n",
-                                         wav_paths[i].c_str(), wav_err.c_str());
+                            std::fprintf(stderr, "SKIP %s: %s\n", wav_paths[i].c_str(), wav_err.c_str());
                         }
                         ++n_fail;
                         std::fflush(stdout);
@@ -708,18 +783,17 @@ int main(int argc, char ** argv) {
                     continue;
                 }
 
-                const transcribe_status bst = transcribe_run_batch(
-                    ctx, pcm_ptrs.data(), n_samps.data(),
-                    static_cast<int>(pcm_ptrs.size()), &rp);
+                const transcribe_status bst =
+                    transcribe_run_batch(ctx, pcm_ptrs.data(), n_samps.data(), static_cast<int>(pcm_ptrs.size()), &rp);
                 if (bst != TRANSCRIBE_OK && transcribe_batch_n_results(ctx) == 0) {
                     // Whole-batch failure (no per-utterance results): emit an
                     // error line per file in the group and continue.
                     for (size_t k = 0; k < src_index.size(); ++k) {
                         if (args.batch_jsonl) {
-                            std::printf("{\"file\":\"%s\",\"text\":\"\","
-                                        "\"error\":\"%s\"}\n",
-                                        wav_paths[src_index[k]].c_str(),
-                                        json_escape(transcribe_status_string(bst)).c_str());
+                            std::printf(
+                                "{\"file\":\"%s\",\"text\":\"\","
+                                "\"error\":\"%s\"}\n",
+                                wav_paths[src_index[k]].c_str(), json_escape(transcribe_status_string(bst)).c_str());
                         }
                         ++n_fail;
                     }
@@ -728,23 +802,22 @@ int main(int argc, char ** argv) {
                 }
 
                 for (size_t k = 0; k < src_index.size(); ++k) {
-                    const std::string & wav = wav_paths[src_index[k]];
-                    const transcribe_status ust =
-                        transcribe_batch_status(ctx, static_cast<int>(k));
-                    const char * text = "";
+                    const std::string &     wav  = wav_paths[src_index[k]];
+                    const transcribe_status ust  = transcribe_batch_status(ctx, static_cast<int>(k));
+                    const char *            text = "";
                     if (ust == TRANSCRIBE_OK) {
-                        const char * t = transcribe_batch_full_text(
-                            ctx, static_cast<int>(k));
-                        if (t && *t) text = t;
+                        const char * t = transcribe_batch_full_text(ctx, static_cast<int>(k));
+                        if (t && *t) {
+                            text = t;
+                        }
                         ++n_ok;
                     } else {
                         ++n_fail;
                     }
                     if (args.batch_jsonl) {
                         const std::string escaped  = json_escape(text);
-                        const std::string segments =
-                            batch_segments_json(ctx, static_cast<int>(k));
-                        std::string err_field;
+                        const std::string segments = batch_segments_json(ctx, static_cast<int>(k));
+                        std::string       err_field;
                         if (ust != TRANSCRIBE_OK) {
                             err_field = ",\"error\":\"";
                             err_field += json_escape(transcribe_status_string(ust));
@@ -754,23 +827,19 @@ int main(int argc, char ** argv) {
                         // amortized across the batch, decode is real per-utt,
                         // so summing across utterances gives the true encode vs
                         // decode split for the whole batched run.
-                        struct transcribe_timings tm; transcribe_timings_init(&tm);
-                        (void)transcribe_batch_get_timings(
-                            ctx, static_cast<int>(k), &tm);
-                        std::printf("{\"file\":\"%s\",\"text\":\"%s\"%s,"
-                                    "\"mel_ms\":%.1f,\"encode_ms\":%.1f,"
-                                    "\"decode_ms\":%.1f%s}\n",
-                                    wav.c_str(), escaped.c_str(),
-                                    segments.c_str(),
-                                    (double)tm.mel_ms, (double)tm.encode_ms,
-                                    (double)tm.decode_ms,
-                                    err_field.c_str());
+                        struct transcribe_timings tm;
+                        transcribe_timings_init(&tm);
+                        (void) transcribe_batch_get_timings(ctx, static_cast<int>(k), &tm);
+                        std::printf(
+                            "{\"file\":\"%s\",\"text\":\"%s\"%s,"
+                            "\"mel_ms\":%.1f,\"encode_ms\":%.1f,"
+                            "\"decode_ms\":%.1f%s}\n",
+                            wav.c_str(), escaped.c_str(), segments.c_str(), (double) tm.mel_ms, (double) tm.encode_ms,
+                            (double) tm.decode_ms, err_field.c_str());
                     } else {
-                        std::printf("[%zu/%zu] %s",
-                                    src_index[k] + 1, total, wav.c_str());
+                        std::printf("[%zu/%zu] %s", src_index[k] + 1, total, wav.c_str());
                         if (ust != TRANSCRIBE_OK) {
-                            std::printf("  ERROR: %s\n",
-                                        transcribe_status_string(ust));
+                            std::printf("  ERROR: %s\n", transcribe_status_string(ust));
                         } else {
                             std::printf("\n  text: %s\n", text);
                         }
@@ -779,143 +848,132 @@ int main(int argc, char ** argv) {
                 }
             }
         } else {
-        for (size_t i = 0; i < wav_paths.size(); ++i) {
-            const std::string & wav = wav_paths[i];
+            for (size_t i = 0; i < wav_paths.size(); ++i) {
+                const std::string & wav = wav_paths[i];
 
-            std::vector<float> pcm;
-            std::string        wav_err;
-            if (!transcribe_cli::load_wav_mono_16k(wav, pcm, wav_err)) {
-                if (args.batch_jsonl) {
-                    std::printf("{\"file\":\"%s\",\"text\":\"\","
-                                "\"error\":\"wav: %s\"}\n",
-                                wav.c_str(), wav_err.c_str());
-                } else {
-                    std::fprintf(stderr, "SKIP %s: %s\n",
-                                 wav.c_str(), wav_err.c_str());
+                std::vector<float> pcm;
+                std::string        wav_err;
+                if (!transcribe_cli::load_wav_mono_16k(wav, pcm, wav_err)) {
+                    if (args.batch_jsonl) {
+                        std::printf(
+                            "{\"file\":\"%s\",\"text\":\"\","
+                            "\"error\":\"wav: %s\"}\n",
+                            wav.c_str(), wav_err.c_str());
+                    } else {
+                        std::fprintf(stderr, "SKIP %s: %s\n", wav.c_str(), wav_err.c_str());
+                    }
+                    ++n_fail;
+                    std::fflush(stdout);
+                    continue;
                 }
-                ++n_fail;
-                std::fflush(stdout);
-                continue;
-            }
 
-            // Run. When --stream-chunk-ms > 0, drive the streaming API
-            // for this utterance (begin/feed/finalize) so the WER
-            // harness can measure cache-aware streaming output.
-            transcribe_status run_st = TRANSCRIBE_OK;
-            if (args.stream_chunk_ms > 0) {
-                struct transcribe_stream_params sp; transcribe_stream_params_init(&sp);
-                struct transcribe_parakeet_stream_ext pkt_sp;
-                transcribe_parakeet_stream_ext_init(&pkt_sp);
-                struct transcribe_parakeet_buffered_stream_ext pkt_buf_sp;
-                transcribe_parakeet_buffered_stream_ext_init(&pkt_buf_sp);
-                struct transcribe_voxtral_realtime_stream_ext vx_sp;
-                transcribe_voxtral_realtime_stream_ext_init(&vx_sp);
-                const bool want_cache_aware = (args.stream_att_right >= 0);
-                const bool want_buffered =
-                    args.stream_buf_left_ms  >= 0 ||
-                    args.stream_buf_chunk_ms >= 0 ||
-                    args.stream_buf_right_ms >= 0;
-                if (want_cache_aware && transcribe_model_accepts_ext_kind(
-                        model,
-                        TRANSCRIBE_EXT_SLOT_STREAM,
-                        TRANSCRIBE_EXT_KIND_PARAKEET_STREAM))
-                {
-                    pkt_sp.att_context_right = args.stream_att_right;
-                    sp.family = &pkt_sp.ext;
-                } else if (want_buffered && transcribe_model_accepts_ext_kind(
-                        model,
-                        TRANSCRIBE_EXT_SLOT_STREAM,
-                        TRANSCRIBE_EXT_KIND_PARAKEET_BUFFERED_STREAM))
-                {
-                    pkt_buf_sp.left_ms  = args.stream_buf_left_ms;
-                    pkt_buf_sp.chunk_ms = args.stream_buf_chunk_ms;
-                    pkt_buf_sp.right_ms = args.stream_buf_right_ms;
-                    sp.family = &pkt_buf_sp.ext;
-                } else if (args.stream_voxtral_delay != -1 &&
-                    transcribe_model_accepts_ext_kind(
-                        model,
-                        TRANSCRIBE_EXT_SLOT_STREAM,
-                        TRANSCRIBE_EXT_KIND_VOXTRAL_REALTIME_STREAM))
-                {
-                    vx_sp.num_delay_tokens = args.stream_voxtral_delay;
-                    sp.family = &vx_sp.ext;
-                }
-                run_st = transcribe_stream_begin(ctx, &rp, &sp);
-                if (run_st == TRANSCRIBE_OK) {
-                    const int chunk_samples =
-                        std::max(1, args.stream_chunk_ms * 16000 / 1000);
-                    size_t pos = 0;
-                    while (pos < pcm.size()) {
-                        const size_t take = std::min<size_t>(
-                            static_cast<size_t>(chunk_samples),
-                            pcm.size() - pos);
-                        struct transcribe_stream_update upd; transcribe_stream_update_init(&upd);
-                        run_st = transcribe_stream_feed(
-                            ctx, pcm.data() + pos,
-                            static_cast<int>(take), &upd);
-                        if (run_st != TRANSCRIBE_OK) break;
-                        pos += take;
+                // Run. When --stream-chunk-ms > 0, drive the streaming API
+                // for this utterance (begin/feed/finalize) so the WER
+                // harness can measure cache-aware streaming output.
+                transcribe_status run_st = TRANSCRIBE_OK;
+                if (args.stream_chunk_ms > 0) {
+                    struct transcribe_stream_params sp;
+                    transcribe_stream_params_init(&sp);
+                    struct transcribe_parakeet_stream_ext pkt_sp;
+                    transcribe_parakeet_stream_ext_init(&pkt_sp);
+                    struct transcribe_parakeet_buffered_stream_ext pkt_buf_sp;
+                    transcribe_parakeet_buffered_stream_ext_init(&pkt_buf_sp);
+                    struct transcribe_voxtral_realtime_stream_ext vx_sp;
+                    transcribe_voxtral_realtime_stream_ext_init(&vx_sp);
+                    const bool want_cache_aware = (args.stream_att_right >= 0);
+                    const bool want_buffered =
+                        args.stream_buf_left_ms >= 0 || args.stream_buf_chunk_ms >= 0 || args.stream_buf_right_ms >= 0;
+                    if (want_cache_aware && transcribe_model_accepts_ext_kind(model, TRANSCRIBE_EXT_SLOT_STREAM,
+                                                                              TRANSCRIBE_EXT_KIND_PARAKEET_STREAM)) {
+                        pkt_sp.att_context_right = args.stream_att_right;
+                        sp.family                = &pkt_sp.ext;
+                    } else if (want_buffered &&
+                               transcribe_model_accepts_ext_kind(model, TRANSCRIBE_EXT_SLOT_STREAM,
+                                                                 TRANSCRIBE_EXT_KIND_PARAKEET_BUFFERED_STREAM)) {
+                        pkt_buf_sp.left_ms  = args.stream_buf_left_ms;
+                        pkt_buf_sp.chunk_ms = args.stream_buf_chunk_ms;
+                        pkt_buf_sp.right_ms = args.stream_buf_right_ms;
+                        sp.family           = &pkt_buf_sp.ext;
+                    } else if (args.stream_voxtral_delay != -1 &&
+                               transcribe_model_accepts_ext_kind(model, TRANSCRIBE_EXT_SLOT_STREAM,
+                                                                 TRANSCRIBE_EXT_KIND_VOXTRAL_REALTIME_STREAM)) {
+                        vx_sp.num_delay_tokens = args.stream_voxtral_delay;
+                        sp.family              = &vx_sp.ext;
                     }
+                    run_st = transcribe_stream_begin(ctx, &rp, &sp);
                     if (run_st == TRANSCRIBE_OK) {
-                        struct transcribe_stream_update fin_upd; transcribe_stream_update_init(&fin_upd);
-                        run_st = transcribe_stream_finalize(ctx, &fin_upd);
+                        const int chunk_samples = std::max(1, args.stream_chunk_ms * 16000 / 1000);
+                        size_t    pos           = 0;
+                        while (pos < pcm.size()) {
+                            const size_t take = std::min<size_t>(static_cast<size_t>(chunk_samples), pcm.size() - pos);
+                            struct transcribe_stream_update upd;
+                            transcribe_stream_update_init(&upd);
+                            run_st = transcribe_stream_feed(ctx, pcm.data() + pos, static_cast<int>(take), &upd);
+                            if (run_st != TRANSCRIBE_OK) {
+                                break;
+                            }
+                            pos += take;
+                        }
+                        if (run_st == TRANSCRIBE_OK) {
+                            struct transcribe_stream_update fin_upd;
+                            transcribe_stream_update_init(&fin_upd);
+                            run_st = transcribe_stream_finalize(ctx, &fin_upd);
+                        }
                     }
+                } else {
+                    run_st = transcribe_run(ctx, pcm.data(), static_cast<int>(pcm.size()), &rp);
                 }
-            } else {
-                run_st = transcribe_run(
-                    ctx, pcm.data(), static_cast<int>(pcm.size()), &rp);
-            }
-
-            const char * text = "";
-            if (run_st == TRANSCRIBE_OK) {
-                const char * t = transcribe_full_text(ctx);
-                if (t && *t) text = t;
-                ++n_ok;
-            } else {
-                ++n_fail;
-            }
 
-            // Output. When run_st != OK we still emit a JSON line so
-            // batch consumers see one record per input wav, but we tag
-            // it with the error string. Without this the wav-load error
-            // path (above) reports errors but transcribe_run failures
-            // (e.g. unsupported language) produce empty hyp_text with no
-            // error tag, so downstream tools count them as silent
-            // successes.
-            if (args.batch_jsonl) {
-                struct transcribe_timings tm; transcribe_timings_init(&tm);
-                (void)transcribe_get_timings(ctx, &tm);
-                const std::string escaped  = json_escape(text);
-                const std::string segments = segments_json(ctx);
-                std::string err_field;
-                if (run_st != TRANSCRIBE_OK) {
-                    err_field = ",\"error\":\"";
-                    err_field += json_escape(transcribe_status_string(run_st));
-                    err_field += "\"";
+                const char * text = "";
+                if (run_st == TRANSCRIBE_OK) {
+                    const char * t = transcribe_full_text(ctx);
+                    if (t && *t) {
+                        text = t;
+                    }
+                    ++n_ok;
+                } else {
+                    ++n_fail;
                 }
-                std::printf("{\"file\":\"%s\",\"text\":\"%s\"%s,"
-                            "\"mel_ms\":%.1f,\"encode_ms\":%.1f,"
-                            "\"decode_ms\":%.1f%s}\n",
-                            wav.c_str(), escaped.c_str(),
-                            segments.c_str(),
-                            (double)tm.mel_ms, (double)tm.encode_ms,
-                            (double)tm.decode_ms,
-                            err_field.c_str());
-            } else {
-                std::printf("[%zu/%zu] %s", i + 1, wav_paths.size(), wav.c_str());
-                if (run_st != TRANSCRIBE_OK) {
-                    std::printf("  ERROR: %s\n", transcribe_status_string(run_st));
+
+                // Output. When run_st != OK we still emit a JSON line so
+                // batch consumers see one record per input wav, but we tag
+                // it with the error string. Without this the wav-load error
+                // path (above) reports errors but transcribe_run failures
+                // (e.g. unsupported language) produce empty hyp_text with no
+                // error tag, so downstream tools count them as silent
+                // successes.
+                if (args.batch_jsonl) {
+                    struct transcribe_timings tm;
+                    transcribe_timings_init(&tm);
+                    (void) transcribe_get_timings(ctx, &tm);
+                    const std::string escaped  = json_escape(text);
+                    const std::string segments = segments_json(ctx);
+                    std::string       err_field;
+                    if (run_st != TRANSCRIBE_OK) {
+                        err_field = ",\"error\":\"";
+                        err_field += json_escape(transcribe_status_string(run_st));
+                        err_field += "\"";
+                    }
+                    std::printf(
+                        "{\"file\":\"%s\",\"text\":\"%s\"%s,"
+                        "\"mel_ms\":%.1f,\"encode_ms\":%.1f,"
+                        "\"decode_ms\":%.1f%s}\n",
+                        wav.c_str(), escaped.c_str(), segments.c_str(), (double) tm.mel_ms, (double) tm.encode_ms,
+                        (double) tm.decode_ms, err_field.c_str());
                 } else {
-                    std::printf("\n  text: %s\n", text);
+                    std::printf("[%zu/%zu] %s", i + 1, wav_paths.size(), wav.c_str());
+                    if (run_st != TRANSCRIBE_OK) {
+                        std::printf("  ERROR: %s\n", transcribe_status_string(run_st));
+                    } else {
+                        std::printf("\n  text: %s\n", text);
+                    }
                 }
+                std::fflush(stdout);
             }
-            std::fflush(stdout);
-        }
         }
 
         if (!args.batch_jsonl) {
-            std::fprintf(stderr, "batch: %d ok, %d failed out of %zu\n",
-                         n_ok, n_fail, wav_paths.size());
+            std::fprintf(stderr, "batch: %d ok, %d failed out of %zu\n", n_ok, n_fail, wav_paths.size());
         }
 
         transcribe_session_free(ctx);
@@ -938,15 +996,13 @@ int main(int argc, char ** argv) {
     std::printf("  sample rate 16000 Hz mono float32\n");
 
     if (!args.model_path.empty()) {
-        struct transcribe_model_load_params mp; transcribe_model_load_params_init(&mp);
-        mp.backend = args.backend;
-        mp.gpu_device = args.gpu_device;
-        struct transcribe_model *      model = nullptr;
-        const transcribe_status        st =
-            transcribe_model_load_file(args.model_path.c_str(), &mp, &model);
-        std::printf("model: %s -> %s\n",
-                    args.model_path.c_str(),
-                    transcribe_status_string(st));
+        struct transcribe_model_load_params mp;
+        transcribe_model_load_params_init(&mp);
+        mp.backend                      = args.backend;
+        mp.gpu_device                   = args.gpu_device;
+        struct transcribe_model * model = nullptr;
+        const transcribe_status   st    = transcribe_model_load_file(args.model_path.c_str(), &mp, &model);
+        std::printf("model: %s -> %s\n", args.model_path.c_str(), transcribe_status_string(st));
         if (st != TRANSCRIBE_OK) {
             return EXIT_FAILURE;
         }
@@ -958,17 +1014,15 @@ int main(int argc, char ** argv) {
             std::printf("  license:    %s\n", lic);
         }
 
-        struct transcribe_session_params cp; transcribe_session_params_init(&cp);
-        cp.n_threads = args.n_threads;
-        cp.n_ctx     = args.n_ctx;
-        cp.kv_type   = args.kv_type;
-        struct transcribe_session *      ctx = nullptr;
-        const transcribe_status          init_st =
-            transcribe_session_init(model, &cp, &ctx);
+        struct transcribe_session_params cp;
+        transcribe_session_params_init(&cp);
+        cp.n_threads                        = args.n_threads;
+        cp.n_ctx                            = args.n_ctx;
+        cp.kv_type                          = args.kv_type;
+        struct transcribe_session * ctx     = nullptr;
+        const transcribe_status     init_st = transcribe_session_init(model, &cp, &ctx);
         if (init_st != TRANSCRIBE_OK) {
-            std::fprintf(stderr,
-                         "context init: %s\n",
-                         transcribe_status_string(init_st));
+            std::fprintf(stderr, "context init: %s\n", transcribe_status_string(init_st));
             transcribe_model_free(model);
             return EXIT_FAILURE;
         }
@@ -978,56 +1032,62 @@ int main(int argc, char ** argv) {
         // limit" — the family chunks internally or is unbounded. See
         // docs/input-limits.md.
         {
-            struct transcribe_session_limits lim; transcribe_session_limits_init(&lim);
+            struct transcribe_session_limits lim;
+            transcribe_session_limits_init(&lim);
             if (transcribe_session_get_limits(ctx, &lim) == TRANSCRIBE_OK) {
                 if (lim.effective_max_audio_ms > 0) {
                     std::printf("  max audio:  %.1f s", (double) lim.effective_max_audio_ms / 1000.0);
                     if (lim.effective_n_ctx > 0) {
-                        std::printf("  (context %d tok, ~%lld MiB KV max)",
-                                    lim.effective_n_ctx,
+                        std::printf("  (context %d tok, ~%lld MiB KV max)", lim.effective_n_ctx,
                                     (long long) (lim.max_kv_bytes >> 20));
                     }
                     std::printf("\n");
                 } else if (lim.effective_n_ctx > 0) {
                     // Capped family whose context is too small to fit any audio
                     // plus a prompt (e.g. an aggressively low --n-ctx).
-                    std::printf("  max audio:  ~0 s (context %d tok too small for "
-                                "audio + prompt)\n", lim.effective_n_ctx);
+                    std::printf(
+                        "  max audio:  ~0 s (context %d tok too small for "
+                        "audio + prompt)\n",
+                        lim.effective_n_ctx);
                 } else {
                     std::printf("  max audio:  unbounded (long audio chunked internally)\n");
                 }
             }
         }
 
-        struct transcribe_run_params rp; transcribe_run_params_init(&rp);
-        if (args.translate)         rp.task     = TRANSCRIBE_TASK_TRANSLATE;
-        if (!args.language.empty()) rp.language = args.language.c_str();
-        if (!args.target_language.empty()) rp.target_language = args.target_language.c_str();
-        rp.timestamps   = args.timestamps;
+        struct transcribe_run_params rp;
+        transcribe_run_params_init(&rp);
+        if (args.translate) {
+            rp.task = TRANSCRIBE_TASK_TRANSLATE;
+        }
+        if (!args.language.empty()) {
+            rp.language = args.language.c_str();
+        }
+        if (!args.target_language.empty()) {
+            rp.target_language = args.target_language.c_str();
+        }
+        rp.timestamps    = args.timestamps;
         rp.spec_k_drafts = args.spec_k_drafts;
 
         if (args.itn_set) {
-            rp.itn = args.use_itn ? TRANSCRIBE_ITN_MODE_ON
-                                  : TRANSCRIBE_ITN_MODE_OFF;
+            rp.itn = args.use_itn ? TRANSCRIBE_ITN_MODE_ON : TRANSCRIBE_ITN_MODE_OFF;
         }
         if (args.canary_pnc_set) {
-            rp.pnc = args.canary_pnc ? TRANSCRIBE_PNC_MODE_ON
-                                     : TRANSCRIBE_PNC_MODE_OFF;
+            rp.pnc = args.canary_pnc ? TRANSCRIBE_PNC_MODE_ON : TRANSCRIBE_PNC_MODE_OFF;
         }
 
-        struct transcribe_whisper_run_ext wx; transcribe_whisper_run_ext_init(&wx);
+        struct transcribe_whisper_run_ext wx;
+        transcribe_whisper_run_ext_init(&wx);
         if (args.whisper_set) {
             if (!args.initial_prompt.empty()) {
                 wx.initial_prompt = args.initial_prompt.c_str();
             }
             wx.condition_on_prev_tokens = args.condition_on_prev_tokens;
-            if (args.temperature_set) wx.temperature = args.temperature;
-            wx.prompt_condition         = args.prompt_condition;
-            if (transcribe_model_accepts_ext_kind(
-                    model,
-                    TRANSCRIBE_EXT_SLOT_RUN,
-                    TRANSCRIBE_EXT_KIND_WHISPER_RUN))
-            {
+            if (args.temperature_set) {
+                wx.temperature = args.temperature;
+            }
+            wx.prompt_condition = args.prompt_condition;
+            if (transcribe_model_accepts_ext_kind(model, TRANSCRIBE_EXT_SLOT_RUN, TRANSCRIBE_EXT_KIND_WHISPER_RUN)) {
                 rp.family = &wx.ext;
             }
         }
@@ -1045,9 +1105,9 @@ int main(int argc, char ** argv) {
         // false until the finalize call.
         transcribe_status run_st = TRANSCRIBE_OK;
         if (args.stream_chunk_ms > 0) {
-            struct transcribe_capabilities caps; transcribe_capabilities_init(&caps);
-            const transcribe_status caps_st =
-                transcribe_model_get_capabilities(model, &caps);
+            struct transcribe_capabilities caps;
+            transcribe_capabilities_init(&caps);
+            const transcribe_status caps_st = transcribe_model_get_capabilities(model, &caps);
             if (caps_st != TRANSCRIBE_OK || !caps.supports_streaming) {
                 std::fprintf(stderr,
                              "stream: model does not advertise "
@@ -1058,12 +1118,11 @@ int main(int argc, char ** argv) {
                 return EXIT_FAILURE;
             }
 
-            const int chunk_samples =
-                std::max(1, args.stream_chunk_ms * 16000 / 1000);
-            std::printf("stream: chunk=%d ms (%d samples)\n",
-                        args.stream_chunk_ms, chunk_samples);
+            const int chunk_samples = std::max(1, args.stream_chunk_ms * 16000 / 1000);
+            std::printf("stream: chunk=%d ms (%d samples)\n", args.stream_chunk_ms, chunk_samples);
 
-            struct transcribe_stream_params sp; transcribe_stream_params_init(&sp);
+            struct transcribe_stream_params sp;
+            transcribe_stream_params_init(&sp);
             struct transcribe_parakeet_stream_ext pkt_sp;
             transcribe_parakeet_stream_ext_init(&pkt_sp);
             struct transcribe_parakeet_buffered_stream_ext pkt_buf_sp;
@@ -1072,96 +1131,72 @@ int main(int argc, char ** argv) {
             transcribe_voxtral_realtime_stream_ext_init(&vx_sp);
             const bool want_cache_aware = (args.stream_att_right >= 0);
             const bool want_buffered =
-                args.stream_buf_left_ms  >= 0 ||
-                args.stream_buf_chunk_ms >= 0 ||
-                args.stream_buf_right_ms >= 0;
-            if (want_cache_aware && transcribe_model_accepts_ext_kind(
-                    model,
-                    TRANSCRIBE_EXT_SLOT_STREAM,
-                    TRANSCRIBE_EXT_KIND_PARAKEET_STREAM))
-            {
+                args.stream_buf_left_ms >= 0 || args.stream_buf_chunk_ms >= 0 || args.stream_buf_right_ms >= 0;
+            if (want_cache_aware && transcribe_model_accepts_ext_kind(model, TRANSCRIBE_EXT_SLOT_STREAM,
+                                                                      TRANSCRIBE_EXT_KIND_PARAKEET_STREAM)) {
                 pkt_sp.att_context_right = args.stream_att_right;
-                sp.family = &pkt_sp.ext;
-                std::printf("stream: att_context_right=%d\n",
-                            args.stream_att_right);
-            } else if (want_buffered && transcribe_model_accepts_ext_kind(
-                    model,
-                    TRANSCRIBE_EXT_SLOT_STREAM,
-                    TRANSCRIBE_EXT_KIND_PARAKEET_BUFFERED_STREAM))
-            {
+                sp.family                = &pkt_sp.ext;
+                std::printf("stream: att_context_right=%d\n", args.stream_att_right);
+            } else if (want_buffered &&
+                       transcribe_model_accepts_ext_kind(model, TRANSCRIBE_EXT_SLOT_STREAM,
+                                                         TRANSCRIBE_EXT_KIND_PARAKEET_BUFFERED_STREAM)) {
                 pkt_buf_sp.left_ms  = args.stream_buf_left_ms;
                 pkt_buf_sp.chunk_ms = args.stream_buf_chunk_ms;
                 pkt_buf_sp.right_ms = args.stream_buf_right_ms;
-                sp.family = &pkt_buf_sp.ext;
-                std::printf("stream: buffered (L,C,R)_ms=(%d,%d,%d)\n",
-                            args.stream_buf_left_ms,
-                            args.stream_buf_chunk_ms,
-                            args.stream_buf_right_ms);
+                sp.family           = &pkt_buf_sp.ext;
+                std::printf("stream: buffered (L,C,R)_ms=(%d,%d,%d)\n", args.stream_buf_left_ms,
+                            args.stream_buf_chunk_ms, args.stream_buf_right_ms);
             } else if (args.stream_voxtral_delay != -1 &&
-                transcribe_model_accepts_ext_kind(
-                    model,
-                    TRANSCRIBE_EXT_SLOT_STREAM,
-                    TRANSCRIBE_EXT_KIND_VOXTRAL_REALTIME_STREAM))
-            {
+                       transcribe_model_accepts_ext_kind(model, TRANSCRIBE_EXT_SLOT_STREAM,
+                                                         TRANSCRIBE_EXT_KIND_VOXTRAL_REALTIME_STREAM)) {
                 vx_sp.num_delay_tokens = args.stream_voxtral_delay;
-                sp.family = &vx_sp.ext;
-                std::printf("stream: voxtral num_delay_tokens=%d\n",
-                            args.stream_voxtral_delay);
+                sp.family              = &vx_sp.ext;
+                std::printf("stream: voxtral num_delay_tokens=%d\n", args.stream_voxtral_delay);
             }
             run_st = transcribe_stream_begin(ctx, &rp, &sp);
             if (run_st != TRANSCRIBE_OK) {
-                std::fprintf(stderr,
-                             "stream_begin: %s\n",
-                             transcribe_status_string(run_st));
+                std::fprintf(stderr, "stream_begin: %s\n", transcribe_status_string(run_st));
             } else {
-                size_t pos = 0;
+                size_t pos    = 0;
                 int    feed_n = 0;
                 while (pos < pcm.size()) {
-                    const size_t take = std::min<size_t>(
-                        static_cast<size_t>(chunk_samples),
-                        pcm.size() - pos);
-                    struct transcribe_stream_update upd; transcribe_stream_update_init(&upd);
-                    run_st = transcribe_stream_feed(
-                        ctx, pcm.data() + pos,
-                        static_cast<int>(take), &upd);
+                    const size_t take = std::min<size_t>(static_cast<size_t>(chunk_samples), pcm.size() - pos);
+                    struct transcribe_stream_update upd;
+                    transcribe_stream_update_init(&upd);
+                    run_st = transcribe_stream_feed(ctx, pcm.data() + pos, static_cast<int>(take), &upd);
                     if (run_st != TRANSCRIBE_OK) {
-                        std::fprintf(stderr,
-                                     "stream_feed[%d]: %s\n",
-                                     feed_n,
-                                     transcribe_status_string(run_st));
+                        std::fprintf(stderr, "stream_feed[%d]: %s\n", feed_n, transcribe_status_string(run_st));
                         break;
                     }
                     pos += take;
-                    std::printf("  feed[%2d]: input=%lld ms buffered=%lld ms",
-                                feed_n,
-                                (long long)upd.input_received_ms,
-                                (long long)upd.buffered_ms);
+                    std::printf("  feed[%2d]: input=%lld ms buffered=%lld ms", feed_n,
+                                (long long) upd.input_received_ms, (long long) upd.buffered_ms);
                     if (upd.result_changed) {
                         const char * partial = transcribe_full_text(ctx);
-                        std::printf("  partial=\"%s\"",
-                                    (partial && *partial) ? partial : "");
+                        std::printf("  partial=\"%s\"", (partial && *partial) ? partial : "");
                     }
                     std::printf("\n");
                     ++feed_n;
                 }
                 if (run_st == TRANSCRIBE_OK) {
-                    struct transcribe_stream_update fin_upd; transcribe_stream_update_init(&fin_upd);
+                    struct transcribe_stream_update fin_upd;
+                    transcribe_stream_update_init(&fin_upd);
                     run_st = transcribe_stream_finalize(ctx, &fin_upd);
-                    std::printf("  finalize: status=%s "
-                                "revision=%d input=%lld ms committed=%lld ms\n",
-                                transcribe_status_string(run_st),
-                                fin_upd.revision,
-                                (long long)fin_upd.input_received_ms,
-                                (long long)fin_upd.audio_committed_ms);
+                    std::printf(
+                        "  finalize: status=%s "
+                        "revision=%d input=%lld ms committed=%lld ms\n",
+                        transcribe_status_string(run_st), fin_upd.revision, (long long) fin_upd.input_received_ms,
+                        (long long) fin_upd.audio_committed_ms);
                 }
             }
         } else {
             // --repeat N runs transcribe_run() N times for steady-state
             // perf measurements.
             for (int r = 0; r < args.repeat; ++r) {
-                run_st = transcribe_run(
-                    ctx, pcm.data(), static_cast<int>(pcm.size()), &rp);
-                if (run_st != TRANSCRIBE_OK) break;
+                run_st = transcribe_run(ctx, pcm.data(), static_cast<int>(pcm.size()), &rp);
+                if (run_st != TRANSCRIBE_OK) {
+                    break;
+                }
             }
         }
         std::printf("run: %s\n", transcribe_status_string(run_st));
@@ -1169,9 +1204,7 @@ int main(int argc, char ** argv) {
         // transcript (see docs/input-limits.md), so show the result for them
         // too — just flagged.
         const bool result_present =
-            run_st == TRANSCRIBE_OK ||
-            run_st == TRANSCRIBE_ERR_OUTPUT_TRUNCATED ||
-            run_st == TRANSCRIBE_ERR_ABORTED;
+            run_st == TRANSCRIBE_OK || run_st == TRANSCRIBE_ERR_OUTPUT_TRUNCATED || run_st == TRANSCRIBE_ERR_ABORTED;
         if (result_present) {
             const char * text = transcribe_full_text(ctx);
             std::printf("text: %s\n", (text && *text) ? text : "(empty)");
@@ -1179,9 +1212,10 @@ int main(int argc, char ** argv) {
             // A truncated decode hit the model's context/output budget before
             // end-of-stream; the text above is incomplete.
             if (transcribe_was_truncated(ctx)) {
-                std::printf("  note:      output truncated (hit the model's "
-                            "context/generation cap before end-of-stream); "
-                            "transcript is incomplete\n");
+                std::printf(
+                    "  note:      output truncated (hit the model's "
+                    "context/generation cap before end-of-stream); "
+                    "transcript is incomplete\n");
             }
 
             const char * dl = transcribe_detected_language(ctx);
@@ -1189,28 +1223,26 @@ int main(int argc, char ** argv) {
                 std::printf("detected-language: %s\n", dl);
             }
 
-            const transcribe_timestamp_kind ret_kind =
-                transcribe_returned_timestamp_kind(ctx);
-            const int n_seg = transcribe_n_segments(ctx);
+            const transcribe_timestamp_kind ret_kind = transcribe_returned_timestamp_kind(ctx);
+            const int                       n_seg    = transcribe_n_segments(ctx);
             if (n_seg > 0 && ret_kind != TRANSCRIBE_TIMESTAMPS_NONE) {
                 std::printf("segments: %d\n", n_seg);
                 for (int i = 0; i < n_seg; ++i) {
-                    struct transcribe_segment seg; transcribe_segment_init(&seg);
-                    (void)transcribe_get_segment(ctx, i, &seg);
-                    std::printf("  [%7.2f -> %7.2f] %s\n",
-                                seg.t0_ms / 1000.0, seg.t1_ms / 1000.0,
+                    struct transcribe_segment seg;
+                    transcribe_segment_init(&seg);
+                    (void) transcribe_get_segment(ctx, i, &seg);
+                    std::printf("  [%7.2f -> %7.2f] %s\n", seg.t0_ms / 1000.0, seg.t1_ms / 1000.0,
                                 (seg.text != nullptr) ? seg.text : "");
                 }
             }
-            if (ret_kind == TRANSCRIBE_TIMESTAMPS_WORD ||
-                ret_kind == TRANSCRIBE_TIMESTAMPS_TOKEN) {
+            if (ret_kind == TRANSCRIBE_TIMESTAMPS_WORD || ret_kind == TRANSCRIBE_TIMESTAMPS_TOKEN) {
                 const int n_wrd = transcribe_n_words(ctx);
                 std::printf("words: %d\n", n_wrd);
                 for (int i = 0; i < n_wrd; ++i) {
-                    struct transcribe_word wrd; transcribe_word_init(&wrd);
-                    (void)transcribe_get_word(ctx, i, &wrd);
-                    std::printf("  [%7.2f -> %7.2f] %s\n",
-                                wrd.t0_ms / 1000.0, wrd.t1_ms / 1000.0,
+                    struct transcribe_word wrd;
+                    transcribe_word_init(&wrd);
+                    (void) transcribe_get_word(ctx, i, &wrd);
+                    std::printf("  [%7.2f -> %7.2f] %s\n", wrd.t0_ms / 1000.0, wrd.t1_ms / 1000.0,
                                 (wrd.text != nullptr) ? wrd.text : "");
                 }
             }
@@ -1218,10 +1250,10 @@ int main(int argc, char ** argv) {
                 const int n_tok = transcribe_n_tokens(ctx);
                 std::printf("tokens: %d\n", n_tok);
                 for (int i = 0; i < n_tok; ++i) {
-                    struct transcribe_token tok; transcribe_token_init(&tok);
-                    (void)transcribe_get_token(ctx, i, &tok);
-                    std::printf("  [%7.2f -> %7.2f] p=%.3f %s\n",
-                                tok.t0_ms / 1000.0, tok.t1_ms / 1000.0, tok.p,
+                    struct transcribe_token tok;
+                    transcribe_token_init(&tok);
+                    (void) transcribe_get_token(ctx, i, &tok);
+                    std::printf("  [%7.2f -> %7.2f] p=%.3f %s\n", tok.t0_ms / 1000.0, tok.t1_ms / 1000.0, tok.p,
                                 (tok.text != nullptr) ? tok.text : "");
                 }
             }
@@ -1230,13 +1262,13 @@ int main(int argc, char ** argv) {
         transcribe_print_timings(ctx);
 
         {
-            struct transcribe_timings tm; transcribe_timings_init(&tm);
-            (void)transcribe_get_timings(ctx, &tm);
+            struct transcribe_timings tm;
+            transcribe_timings_init(&tm);
+            (void) transcribe_get_timings(ctx, &tm);
             const double total_ms = tm.mel_ms + tm.encode_ms + tm.decode_ms;
             if (total_ms > 0.0 && duration_s > 0.0) {
-                std::printf("  realtime:   %.0fx (%.1f ms for %.1f s)\n",
-                            (duration_s * 1000.0) / total_ms,
-                            total_ms, duration_s);
+                std::printf("  realtime:   %.0fx (%.1f ms for %.1f s)\n", (duration_s * 1000.0) / total_ms, total_ms,
+                            duration_s);
             }
         }
 
diff --git a/examples/common/dr_wav.h b/examples/common/dr_wav.h
index 61f813b1..dc8362e8 100644
--- a/examples/common/dr_wav.h
+++ b/examples/common/dr_wav.h
@@ -133,179 +133,171 @@ Notes
 */
 
 #ifndef dr_wav_h
-#define dr_wav_h
+#    define dr_wav_h
 
-#ifdef __cplusplus
+#    ifdef __cplusplus
 extern "C" {
-#endif
+#    endif
 
-#define DRWAV_STRINGIFY(x)      #x
-#define DRWAV_XSTRINGIFY(x)     DRWAV_STRINGIFY(x)
+#    define DRWAV_STRINGIFY(x)  #x
+#    define DRWAV_XSTRINGIFY(x) DRWAV_STRINGIFY(x)
 
-#define DRWAV_VERSION_MAJOR     0
-#define DRWAV_VERSION_MINOR     12
-#define DRWAV_VERSION_REVISION  16
-#define DRWAV_VERSION_STRING    DRWAV_XSTRINGIFY(DRWAV_VERSION_MAJOR) "." DRWAV_XSTRINGIFY(DRWAV_VERSION_MINOR) "." DRWAV_XSTRINGIFY(DRWAV_VERSION_REVISION)
+#    define DRWAV_VERSION_MAJOR    0
+#    define DRWAV_VERSION_MINOR    12
+#    define DRWAV_VERSION_REVISION 16
+#    define DRWAV_VERSION_STRING              \
+        DRWAV_XSTRINGIFY(DRWAV_VERSION_MAJOR) \
+        "." DRWAV_XSTRINGIFY(DRWAV_VERSION_MINOR) "." DRWAV_XSTRINGIFY(DRWAV_VERSION_REVISION)
 
-#include <stddef.h> /* For size_t. */
+#    include <stddef.h> /* For size_t. */
 
 /* Sized types. */
-typedef   signed char           drwav_int8;
-typedef unsigned char           drwav_uint8;
-typedef   signed short          drwav_int16;
-typedef unsigned short          drwav_uint16;
-typedef   signed int            drwav_int32;
-typedef unsigned int            drwav_uint32;
-#if defined(_MSC_VER)
-    typedef   signed __int64    drwav_int64;
-    typedef unsigned __int64    drwav_uint64;
-#else
-    #if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)))
-        #pragma GCC diagnostic push
-        #pragma GCC diagnostic ignored "-Wlong-long"
-        #if defined(__clang__)
-            #pragma GCC diagnostic ignored "-Wc++11-long-long"
-        #endif
-    #endif
-    typedef   signed long long  drwav_int64;
-    typedef unsigned long long  drwav_uint64;
-    #if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)))
-        #pragma GCC diagnostic pop
-    #endif
-#endif
-#if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__)) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
-    typedef drwav_uint64        drwav_uintptr;
-#else
-    typedef drwav_uint32        drwav_uintptr;
-#endif
-typedef drwav_uint8             drwav_bool8;
-typedef drwav_uint32            drwav_bool32;
-#define DRWAV_TRUE              1
-#define DRWAV_FALSE             0
-
-#if !defined(DRWAV_API)
-    #if defined(DRWAV_DLL)
-        #if defined(_WIN32)
-            #define DRWAV_DLL_IMPORT  __declspec(dllimport)
-            #define DRWAV_DLL_EXPORT  __declspec(dllexport)
-            #define DRWAV_DLL_PRIVATE static
-        #else
-            #if defined(__GNUC__) && __GNUC__ >= 4
-                #define DRWAV_DLL_IMPORT  __attribute__((visibility("default")))
-                #define DRWAV_DLL_EXPORT  __attribute__((visibility("default")))
-                #define DRWAV_DLL_PRIVATE __attribute__((visibility("hidden")))
-            #else
-                #define DRWAV_DLL_IMPORT
-                #define DRWAV_DLL_EXPORT
-                #define DRWAV_DLL_PRIVATE static
-            #endif
-        #endif
-
-        #if defined(DR_WAV_IMPLEMENTATION) || defined(DRWAV_IMPLEMENTATION)
-            #define DRWAV_API  DRWAV_DLL_EXPORT
-        #else
-            #define DRWAV_API  DRWAV_DLL_IMPORT
-        #endif
-        #define DRWAV_PRIVATE DRWAV_DLL_PRIVATE
-    #else
-        #define DRWAV_API extern
-        #define DRWAV_PRIVATE static
-    #endif
-#endif
+typedef signed char    drwav_int8;
+typedef unsigned char  drwav_uint8;
+typedef signed short   drwav_int16;
+typedef unsigned short drwav_uint16;
+typedef signed int     drwav_int32;
+typedef unsigned int   drwav_uint32;
+#    if defined(_MSC_VER)
+typedef signed __int64   drwav_int64;
+typedef unsigned __int64 drwav_uint64;
+#    else
+#        if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)))
+#            pragma GCC diagnostic push
+#            pragma GCC diagnostic ignored "-Wlong-long"
+#            if defined(__clang__)
+#                pragma GCC diagnostic ignored "-Wc++11-long-long"
+#            endif
+#        endif
+typedef signed long long   drwav_int64;
+typedef unsigned long long drwav_uint64;
+#        if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)))
+#            pragma GCC diagnostic pop
+#        endif
+#    endif
+#    if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__)) || defined(_M_X64) || \
+        defined(__ia64) || defined(_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
+typedef drwav_uint64 drwav_uintptr;
+#    else
+typedef drwav_uint32 drwav_uintptr;
+#    endif
+typedef drwav_uint8  drwav_bool8;
+typedef drwav_uint32 drwav_bool32;
+#    define DRWAV_TRUE  1
+#    define DRWAV_FALSE 0
+
+#    if !defined(DRWAV_API)
+#        if defined(DRWAV_DLL)
+#            if defined(_WIN32)
+#                define DRWAV_DLL_IMPORT  __declspec(dllimport)
+#                define DRWAV_DLL_EXPORT  __declspec(dllexport)
+#                define DRWAV_DLL_PRIVATE static
+#            else
+#                if defined(__GNUC__) && __GNUC__ >= 4
+#                    define DRWAV_DLL_IMPORT  __attribute__((visibility("default")))
+#                    define DRWAV_DLL_EXPORT  __attribute__((visibility("default")))
+#                    define DRWAV_DLL_PRIVATE __attribute__((visibility("hidden")))
+#                else
+#                    define DRWAV_DLL_IMPORT
+#                    define DRWAV_DLL_EXPORT
+#                    define DRWAV_DLL_PRIVATE static
+#                endif
+#            endif
+
+#            if defined(DR_WAV_IMPLEMENTATION) || defined(DRWAV_IMPLEMENTATION)
+#                define DRWAV_API DRWAV_DLL_EXPORT
+#            else
+#                define DRWAV_API DRWAV_DLL_IMPORT
+#            endif
+#            define DRWAV_PRIVATE DRWAV_DLL_PRIVATE
+#        else
+#            define DRWAV_API     extern
+#            define DRWAV_PRIVATE static
+#        endif
+#    endif
 
 typedef drwav_int32 drwav_result;
-#define DRWAV_SUCCESS                        0
-#define DRWAV_ERROR                         -1   /* A generic error. */
-#define DRWAV_INVALID_ARGS                  -2
-#define DRWAV_INVALID_OPERATION             -3
-#define DRWAV_OUT_OF_MEMORY                 -4
-#define DRWAV_OUT_OF_RANGE                  -5
-#define DRWAV_ACCESS_DENIED                 -6
-#define DRWAV_DOES_NOT_EXIST                -7
-#define DRWAV_ALREADY_EXISTS                -8
-#define DRWAV_TOO_MANY_OPEN_FILES           -9
-#define DRWAV_INVALID_FILE                  -10
-#define DRWAV_TOO_BIG                       -11
-#define DRWAV_PATH_TOO_LONG                 -12
-#define DRWAV_NAME_TOO_LONG                 -13
-#define DRWAV_NOT_DIRECTORY                 -14
-#define DRWAV_IS_DIRECTORY                  -15
-#define DRWAV_DIRECTORY_NOT_EMPTY           -16
-#define DRWAV_END_OF_FILE                   -17
-#define DRWAV_NO_SPACE                      -18
-#define DRWAV_BUSY                          -19
-#define DRWAV_IO_ERROR                      -20
-#define DRWAV_INTERRUPT                     -21
-#define DRWAV_UNAVAILABLE                   -22
-#define DRWAV_ALREADY_IN_USE                -23
-#define DRWAV_BAD_ADDRESS                   -24
-#define DRWAV_BAD_SEEK                      -25
-#define DRWAV_BAD_PIPE                      -26
-#define DRWAV_DEADLOCK                      -27
-#define DRWAV_TOO_MANY_LINKS                -28
-#define DRWAV_NOT_IMPLEMENTED               -29
-#define DRWAV_NO_MESSAGE                    -30
-#define DRWAV_BAD_MESSAGE                   -31
-#define DRWAV_NO_DATA_AVAILABLE             -32
-#define DRWAV_INVALID_DATA                  -33
-#define DRWAV_TIMEOUT                       -34
-#define DRWAV_NO_NETWORK                    -35
-#define DRWAV_NOT_UNIQUE                    -36
-#define DRWAV_NOT_SOCKET                    -37
-#define DRWAV_NO_ADDRESS                    -38
-#define DRWAV_BAD_PROTOCOL                  -39
-#define DRWAV_PROTOCOL_UNAVAILABLE          -40
-#define DRWAV_PROTOCOL_NOT_SUPPORTED        -41
-#define DRWAV_PROTOCOL_FAMILY_NOT_SUPPORTED -42
-#define DRWAV_ADDRESS_FAMILY_NOT_SUPPORTED  -43
-#define DRWAV_SOCKET_NOT_SUPPORTED          -44
-#define DRWAV_CONNECTION_RESET              -45
-#define DRWAV_ALREADY_CONNECTED             -46
-#define DRWAV_NOT_CONNECTED                 -47
-#define DRWAV_CONNECTION_REFUSED            -48
-#define DRWAV_NO_HOST                       -49
-#define DRWAV_IN_PROGRESS                   -50
-#define DRWAV_CANCELLED                     -51
-#define DRWAV_MEMORY_ALREADY_MAPPED         -52
-#define DRWAV_AT_END                        -53
+#    define DRWAV_SUCCESS                       0
+#    define DRWAV_ERROR                         -1 /* A generic error. */
+#    define DRWAV_INVALID_ARGS                  -2
+#    define DRWAV_INVALID_OPERATION             -3
+#    define DRWAV_OUT_OF_MEMORY                 -4
+#    define DRWAV_OUT_OF_RANGE                  -5
+#    define DRWAV_ACCESS_DENIED                 -6
+#    define DRWAV_DOES_NOT_EXIST                -7
+#    define DRWAV_ALREADY_EXISTS                -8
+#    define DRWAV_TOO_MANY_OPEN_FILES           -9
+#    define DRWAV_INVALID_FILE                  -10
+#    define DRWAV_TOO_BIG                       -11
+#    define DRWAV_PATH_TOO_LONG                 -12
+#    define DRWAV_NAME_TOO_LONG                 -13
+#    define DRWAV_NOT_DIRECTORY                 -14
+#    define DRWAV_IS_DIRECTORY                  -15
+#    define DRWAV_DIRECTORY_NOT_EMPTY           -16
+#    define DRWAV_END_OF_FILE                   -17
+#    define DRWAV_NO_SPACE                      -18
+#    define DRWAV_BUSY                          -19
+#    define DRWAV_IO_ERROR                      -20
+#    define DRWAV_INTERRUPT                     -21
+#    define DRWAV_UNAVAILABLE                   -22
+#    define DRWAV_ALREADY_IN_USE                -23
+#    define DRWAV_BAD_ADDRESS                   -24
+#    define DRWAV_BAD_SEEK                      -25
+#    define DRWAV_BAD_PIPE                      -26
+#    define DRWAV_DEADLOCK                      -27
+#    define DRWAV_TOO_MANY_LINKS                -28
+#    define DRWAV_NOT_IMPLEMENTED               -29
+#    define DRWAV_NO_MESSAGE                    -30
+#    define DRWAV_BAD_MESSAGE                   -31
+#    define DRWAV_NO_DATA_AVAILABLE             -32
+#    define DRWAV_INVALID_DATA                  -33
+#    define DRWAV_TIMEOUT                       -34
+#    define DRWAV_NO_NETWORK                    -35
+#    define DRWAV_NOT_UNIQUE                    -36
+#    define DRWAV_NOT_SOCKET                    -37
+#    define DRWAV_NO_ADDRESS                    -38
+#    define DRWAV_BAD_PROTOCOL                  -39
+#    define DRWAV_PROTOCOL_UNAVAILABLE          -40
+#    define DRWAV_PROTOCOL_NOT_SUPPORTED        -41
+#    define DRWAV_PROTOCOL_FAMILY_NOT_SUPPORTED -42
+#    define DRWAV_ADDRESS_FAMILY_NOT_SUPPORTED  -43
+#    define DRWAV_SOCKET_NOT_SUPPORTED          -44
+#    define DRWAV_CONNECTION_RESET              -45
+#    define DRWAV_ALREADY_CONNECTED             -46
+#    define DRWAV_NOT_CONNECTED                 -47
+#    define DRWAV_CONNECTION_REFUSED            -48
+#    define DRWAV_NO_HOST                       -49
+#    define DRWAV_IN_PROGRESS                   -50
+#    define DRWAV_CANCELLED                     -51
+#    define DRWAV_MEMORY_ALREADY_MAPPED         -52
+#    define DRWAV_AT_END                        -53
 
 /* Common data formats. */
-#define DR_WAVE_FORMAT_PCM          0x1
-#define DR_WAVE_FORMAT_ADPCM        0x2
-#define DR_WAVE_FORMAT_IEEE_FLOAT   0x3
-#define DR_WAVE_FORMAT_ALAW         0x6
-#define DR_WAVE_FORMAT_MULAW        0x7
-#define DR_WAVE_FORMAT_DVI_ADPCM    0x11
-#define DR_WAVE_FORMAT_EXTENSIBLE   0xFFFE
+#    define DR_WAVE_FORMAT_PCM        0x1
+#    define DR_WAVE_FORMAT_ADPCM      0x2
+#    define DR_WAVE_FORMAT_IEEE_FLOAT 0x3
+#    define DR_WAVE_FORMAT_ALAW       0x6
+#    define DR_WAVE_FORMAT_MULAW      0x7
+#    define DR_WAVE_FORMAT_DVI_ADPCM  0x11
+#    define DR_WAVE_FORMAT_EXTENSIBLE 0xFFFE
 
 /* Constants. */
-#ifndef DRWAV_MAX_SMPL_LOOPS
-#define DRWAV_MAX_SMPL_LOOPS        1
-#endif
+#    ifndef DRWAV_MAX_SMPL_LOOPS
+#        define DRWAV_MAX_SMPL_LOOPS 1
+#    endif
 
 /* Flags to pass into drwav_init_ex(), etc. */
-#define DRWAV_SEQUENTIAL            0x00000001
+#    define DRWAV_SEQUENTIAL 0x00000001
 
-DRWAV_API void drwav_version(drwav_uint32* pMajor, drwav_uint32* pMinor, drwav_uint32* pRevision);
-DRWAV_API const char* drwav_version_string(void);
+DRWAV_API void         drwav_version(drwav_uint32 * pMajor, drwav_uint32 * pMinor, drwav_uint32 * pRevision);
+DRWAV_API const char * drwav_version_string(void);
 
-typedef enum
-{
-    drwav_seek_origin_start,
-    drwav_seek_origin_current
-} drwav_seek_origin;
+typedef enum { drwav_seek_origin_start, drwav_seek_origin_current } drwav_seek_origin;
 
-typedef enum
-{
-    drwav_container_riff,
-    drwav_container_w64,
-    drwav_container_rf64
-} drwav_container;
+typedef enum { drwav_container_riff, drwav_container_w64, drwav_container_rf64 } drwav_container;
 
-typedef struct
-{
-    union
-    {
+typedef struct {
+    union {
         drwav_uint8 fourcc[4];
         drwav_uint8 guid[16];
     } id;
@@ -320,8 +312,7 @@ typedef struct
     unsigned int paddingSize;
 } drwav_chunk_header;
 
-typedef struct
-{
+typedef struct {
     /*
     The format tag exactly as specified in the wave file's "fmt" chunk. This can be used by applications
     that require support for data formats not natively supported by dr_wav.
@@ -360,8 +351,7 @@ typedef struct
     drwav_uint8 subFormat[16];
 } drwav_fmt;
 
-DRWAV_API drwav_uint16 drwav_fmt_get_format(const drwav_fmt* pFMT);
-
+DRWAV_API drwav_uint16 drwav_fmt_get_format(const drwav_fmt * pFMT);
 
 /*
 Callback for when data is read. Return value is the number of bytes actually read.
@@ -375,7 +365,7 @@ Returns the number of bytes actually read.
 A return value of less than bytesToRead indicates the end of the stream. Do _not_ return from this callback until
 either the entire bytesToRead is filled or you have reached the end of the stream.
 */
-typedef size_t (* drwav_read_proc)(void* pUserData, void* pBufferOut, size_t bytesToRead);
+typedef size_t (*drwav_read_proc)(void * pUserData, void * pBufferOut, size_t bytesToRead);
 
 /*
 Callback for when data is written. Returns value is the number of bytes actually written.
@@ -388,7 +378,7 @@ Returns the number of bytes actually written.
 
 If the return value differs from bytesToWrite, it indicates an error.
 */
-typedef size_t (* drwav_write_proc)(void* pUserData, const void* pData, size_t bytesToWrite);
+typedef size_t (*drwav_write_proc)(void * pUserData, const void * pData, size_t bytesToWrite);
 
 /*
 Callback for when data needs to be seeked.
@@ -402,7 +392,7 @@ Returns whether or not the seek was successful.
 Whether or not it is relative to the beginning or current position is determined by the "origin" parameter which will be either drwav_seek_origin_start or
 drwav_seek_origin_current.
 */
-typedef drwav_bool32 (* drwav_seek_proc)(void* pUserData, int offset, drwav_seek_origin origin);
+typedef drwav_bool32 (*drwav_seek_proc)(void * pUserData, int offset, drwav_seek_origin origin);
 
 /*
 Callback for when drwav_init_ex() finds a chunk.
@@ -428,47 +418,47 @@ The `pFMT` parameter can be used to determine the data format of the wave file.
 
 The read pointer will be sitting on the first byte after the chunk's header. You must not attempt to read beyond the boundary of the chunk.
 */
-typedef drwav_uint64 (* drwav_chunk_proc)(void* pChunkUserData, drwav_read_proc onRead, drwav_seek_proc onSeek, void* pReadSeekUserData, const drwav_chunk_header* pChunkHeader, drwav_container container, const drwav_fmt* pFMT);
-
-typedef struct
-{
-    void* pUserData;
-    void* (* onMalloc)(size_t sz, void* pUserData);
-    void* (* onRealloc)(void* p, size_t sz, void* pUserData);
-    void  (* onFree)(void* p, void* pUserData);
+typedef drwav_uint64 (*drwav_chunk_proc)(void *                     pChunkUserData,
+                                         drwav_read_proc            onRead,
+                                         drwav_seek_proc            onSeek,
+                                         void *                     pReadSeekUserData,
+                                         const drwav_chunk_header * pChunkHeader,
+                                         drwav_container            container,
+                                         const drwav_fmt *          pFMT);
+
+typedef struct {
+    void * pUserData;
+    void * (*onMalloc)(size_t sz, void * pUserData);
+    void * (*onRealloc)(void * p, size_t sz, void * pUserData);
+    void (*onFree)(void * p, void * pUserData);
 } drwav_allocation_callbacks;
 
 /* Structure for internal use. Only used for loaders opened with drwav_init_memory(). */
-typedef struct
-{
-    const drwav_uint8* data;
-    size_t dataSize;
-    size_t currentReadPos;
+typedef struct {
+    const drwav_uint8 * data;
+    size_t              dataSize;
+    size_t              currentReadPos;
 } drwav__memory_stream;
 
 /* Structure for internal use. Only used for writers opened with drwav_init_memory_write(). */
-typedef struct
-{
-    void** ppData;
-    size_t* pDataSize;
-    size_t dataSize;
-    size_t dataCapacity;
-    size_t currentWritePos;
+typedef struct {
+    void **  ppData;
+    size_t * pDataSize;
+    size_t   dataSize;
+    size_t   dataCapacity;
+    size_t   currentWritePos;
 } drwav__memory_stream_write;
 
-typedef struct
-{
-    drwav_container container;  /* RIFF, W64. */
-    drwav_uint32 format;        /* DR_WAVE_FORMAT_* */
-    drwav_uint32 channels;
-    drwav_uint32 sampleRate;
-    drwav_uint32 bitsPerSample;
+typedef struct {
+    drwav_container container; /* RIFF, W64. */
+    drwav_uint32    format;    /* DR_WAVE_FORMAT_* */
+    drwav_uint32    channels;
+    drwav_uint32    sampleRate;
+    drwav_uint32    bitsPerSample;
 } drwav_data_format;
 
-
 /* See the following for details on the 'smpl' chunk: https://sites.google.com/site/musicgapi/technical-documents/wav-file-format#smpl */
-typedef struct
-{
+typedef struct {
     drwav_uint32 cuePointId;
     drwav_uint32 type;
     drwav_uint32 start;
@@ -477,22 +467,20 @@ typedef struct
     drwav_uint32 playCount;
 } drwav_smpl_loop;
 
- typedef struct
-{
-    drwav_uint32 manufacturer;
-    drwav_uint32 product;
-    drwav_uint32 samplePeriod;
-    drwav_uint32 midiUnityNotes;
-    drwav_uint32 midiPitchFraction;
-    drwav_uint32 smpteFormat;
-    drwav_uint32 smpteOffset;
-    drwav_uint32 numSampleLoops;
-    drwav_uint32 samplerData;
+typedef struct {
+    drwav_uint32    manufacturer;
+    drwav_uint32    product;
+    drwav_uint32    samplePeriod;
+    drwav_uint32    midiUnityNotes;
+    drwav_uint32    midiPitchFraction;
+    drwav_uint32    smpteFormat;
+    drwav_uint32    smpteOffset;
+    drwav_uint32    numSampleLoops;
+    drwav_uint32    samplerData;
     drwav_smpl_loop loops[DRWAV_MAX_SMPL_LOOPS];
 } drwav_smpl;
 
-typedef struct
-{
+typedef struct {
     /* A pointer to the function to call when more data is needed. */
     drwav_read_proc onRead;
 
@@ -503,16 +491,14 @@ typedef struct
     drwav_seek_proc onSeek;
 
     /* The user data to pass to callbacks. */
-    void* pUserData;
+    void * pUserData;
 
     /* Allocation callbacks. */
     drwav_allocation_callbacks allocationCallbacks;
 
-
     /* Whether or not the WAV file is formatted as a standard RIFF file or W64. */
     drwav_container container;
 
-
     /* Structure containing format information exactly as specified by the wav file. */
     drwav_fmt fmt;
 
@@ -531,17 +517,15 @@ typedef struct
     /* The total number of PCM frames making up the audio data. */
     drwav_uint64 totalPCMFrameCount;
 
-
     /* The size in bytes of the data chunk. */
     drwav_uint64 dataChunkDataSize;
-    
+
     /* The position in the stream of the first byte of the data chunk. This is used for seeking. */
     drwav_uint64 dataChunkDataPos;
 
     /* The number of bytes remaining in the data chunk. */
     drwav_uint64 bytesRemaining;
 
-
     /*
     Only used in sequential write mode. Keeps track of the desired size of the "data" chunk at the point of initialization time. Always
     set to 0 for non-sequential writes and when the drwav object is opened in read mode. Used for validation.
@@ -551,24 +535,21 @@ typedef struct
     /* Keeps track of whether or not the wav writer was initialized in sequential mode. */
     drwav_bool32 isSequentialWrite;
 
-
     /* smpl chunk. */
     drwav_smpl smpl;
 
-
     /* A hack to avoid a DRWAV_MALLOC() when opening a decoder with drwav_init_memory(). */
-    drwav__memory_stream memoryStream;
+    drwav__memory_stream       memoryStream;
     drwav__memory_stream_write memoryStreamWrite;
 
     /* Generic data for compressed formats. This data is shared across all block-compressed formats. */
-    struct
-    {
-        drwav_uint64 iCurrentPCMFrame;  /* The index of the next PCM frame that will be read by drwav_read_*(). This is used with "totalPCMFrameCount" to ensure we don't read excess samples at the end of the last block. */
+    struct {
+        drwav_uint64
+            iCurrentPCMFrame; /* The index of the next PCM frame that will be read by drwav_read_*(). This is used with "totalPCMFrameCount" to ensure we don't read excess samples at the end of the last block. */
     } compressed;
-    
+
     /* Microsoft ADPCM specific data. */
-    struct
-    {
+    struct {
         drwav_uint32 bytesRemainingInBlock;
         drwav_uint16 predictor[2];
         drwav_int32  delta[2];
@@ -578,8 +559,7 @@ typedef struct
     } msadpcm;
 
     /* IMA ADPCM specific data. */
-    struct
-    {
+    struct {
         drwav_uint32 bytesRemainingInBlock;
         drwav_int32  predictor[2];
         drwav_int32  stepIndex[2];
@@ -588,7 +568,6 @@ typedef struct
     } ima;
 } drwav;
 
-
 /*
 Initializes a pre-allocated drwav object for reading.
 
@@ -618,8 +597,19 @@ after the function returns.
 
 See also: drwav_init_file(), drwav_init_memory(), drwav_uninit()
 */
-DRWAV_API drwav_bool32 drwav_init(drwav* pWav, drwav_read_proc onRead, drwav_seek_proc onSeek, void* pUserData, const drwav_allocation_callbacks* pAllocationCallbacks);
-DRWAV_API drwav_bool32 drwav_init_ex(drwav* pWav, drwav_read_proc onRead, drwav_seek_proc onSeek, drwav_chunk_proc onChunk, void* pReadSeekUserData, void* pChunkUserData, drwav_uint32 flags, const drwav_allocation_callbacks* pAllocationCallbacks);
+DRWAV_API drwav_bool32 drwav_init(drwav *                            pWav,
+                                  drwav_read_proc                    onRead,
+                                  drwav_seek_proc                    onSeek,
+                                  void *                             pUserData,
+                                  const drwav_allocation_callbacks * pAllocationCallbacks);
+DRWAV_API drwav_bool32 drwav_init_ex(drwav *                            pWav,
+                                     drwav_read_proc                    onRead,
+                                     drwav_seek_proc                    onSeek,
+                                     drwav_chunk_proc                   onChunk,
+                                     void *                             pReadSeekUserData,
+                                     void *                             pChunkUserData,
+                                     drwav_uint32                       flags,
+                                     const drwav_allocation_callbacks * pAllocationCallbacks);
 
 /*
 Initializes a pre-allocated drwav object for writing.
@@ -640,9 +630,24 @@ a post-processing step for storing the total sample count and the size of the da
 
 See also: drwav_init_file_write(), drwav_init_memory_write(), drwav_uninit()
 */
-DRWAV_API drwav_bool32 drwav_init_write(drwav* pWav, const drwav_data_format* pFormat, drwav_write_proc onWrite, drwav_seek_proc onSeek, void* pUserData, const drwav_allocation_callbacks* pAllocationCallbacks);
-DRWAV_API drwav_bool32 drwav_init_write_sequential(drwav* pWav, const drwav_data_format* pFormat, drwav_uint64 totalSampleCount, drwav_write_proc onWrite, void* pUserData, const drwav_allocation_callbacks* pAllocationCallbacks);
-DRWAV_API drwav_bool32 drwav_init_write_sequential_pcm_frames(drwav* pWav, const drwav_data_format* pFormat, drwav_uint64 totalPCMFrameCount, drwav_write_proc onWrite, void* pUserData, const drwav_allocation_callbacks* pAllocationCallbacks);
+DRWAV_API drwav_bool32 drwav_init_write(drwav *                            pWav,
+                                        const drwav_data_format *          pFormat,
+                                        drwav_write_proc                   onWrite,
+                                        drwav_seek_proc                    onSeek,
+                                        void *                             pUserData,
+                                        const drwav_allocation_callbacks * pAllocationCallbacks);
+DRWAV_API drwav_bool32 drwav_init_write_sequential(drwav *                            pWav,
+                                                   const drwav_data_format *          pFormat,
+                                                   drwav_uint64                       totalSampleCount,
+                                                   drwav_write_proc                   onWrite,
+                                                   void *                             pUserData,
+                                                   const drwav_allocation_callbacks * pAllocationCallbacks);
+DRWAV_API drwav_bool32 drwav_init_write_sequential_pcm_frames(drwav *                            pWav,
+                                                              const drwav_data_format *          pFormat,
+                                                              drwav_uint64                       totalPCMFrameCount,
+                                                              drwav_write_proc                   onWrite,
+                                                              void *                             pUserData,
+                                                              const drwav_allocation_callbacks * pAllocationCallbacks);
 
 /*
 Utility function to determine the target size of the entire data to be written (including all headers and chunks).
@@ -655,15 +660,14 @@ Only writing to the RIFF chunk and one data chunk is currently supported.
 
 See also: drwav_init_write(), drwav_init_file_write(), drwav_init_memory_write()
 */
-DRWAV_API drwav_uint64 drwav_target_write_size_bytes(const drwav_data_format* pFormat, drwav_uint64 totalSampleCount);
+DRWAV_API drwav_uint64 drwav_target_write_size_bytes(const drwav_data_format * pFormat, drwav_uint64 totalSampleCount);
 
 /*
 Uninitializes the given drwav object.
 
 Use this only for objects initialized with drwav_init*() functions (drwav_init(), drwav_init_ex(), drwav_init_write(), drwav_init_write_sequential()).
 */
-DRWAV_API drwav_result drwav_uninit(drwav* pWav);
-
+DRWAV_API drwav_result drwav_uninit(drwav * pWav);
 
 /*
 Reads raw audio data.
@@ -678,7 +682,7 @@ pBufferOut can be NULL in which case a seek will be performed.
 
 Returns the number of bytes actually read.
 */
-DRWAV_API size_t drwav_read_raw(drwav* pWav, size_t bytesToRead, void* pBufferOut);
+DRWAV_API size_t drwav_read_raw(drwav * pWav, size_t bytesToRead, void * pBufferOut);
 
 /*
 Reads up to the specified number of PCM frames from the WAV file.
@@ -694,24 +698,23 @@ using a compressed format consider using drwav_read_raw() or drwav_read_pcm_fram
 
 pBufferOut can be NULL in which case a seek will be performed.
 */
-DRWAV_API drwav_uint64 drwav_read_pcm_frames(drwav* pWav, drwav_uint64 framesToRead, void* pBufferOut);
-DRWAV_API drwav_uint64 drwav_read_pcm_frames_le(drwav* pWav, drwav_uint64 framesToRead, void* pBufferOut);
-DRWAV_API drwav_uint64 drwav_read_pcm_frames_be(drwav* pWav, drwav_uint64 framesToRead, void* pBufferOut);
+DRWAV_API drwav_uint64 drwav_read_pcm_frames(drwav * pWav, drwav_uint64 framesToRead, void * pBufferOut);
+DRWAV_API drwav_uint64 drwav_read_pcm_frames_le(drwav * pWav, drwav_uint64 framesToRead, void * pBufferOut);
+DRWAV_API drwav_uint64 drwav_read_pcm_frames_be(drwav * pWav, drwav_uint64 framesToRead, void * pBufferOut);
 
 /*
 Seeks to the given PCM frame.
 
 Returns true if successful; false otherwise.
 */
-DRWAV_API drwav_bool32 drwav_seek_to_pcm_frame(drwav* pWav, drwav_uint64 targetFrameIndex);
-
+DRWAV_API drwav_bool32 drwav_seek_to_pcm_frame(drwav * pWav, drwav_uint64 targetFrameIndex);
 
 /*
 Writes raw audio data.
 
 Returns the number of bytes actually written. If this differs from bytesToWrite, it indicates an error.
 */
-DRWAV_API size_t drwav_write_raw(drwav* pWav, size_t bytesToWrite, const void* pData);
+DRWAV_API size_t drwav_write_raw(drwav * pWav, size_t bytesToWrite, const void * pData);
 
 /*
 Writes PCM frames.
@@ -721,13 +724,12 @@ Returns the number of PCM frames written.
 Input samples need to be in native-endian byte order. On big-endian architectures the input data will be converted to
 little-endian. Use drwav_write_raw() to write raw audio data without performing any conversion.
 */
-DRWAV_API drwav_uint64 drwav_write_pcm_frames(drwav* pWav, drwav_uint64 framesToWrite, const void* pData);
-DRWAV_API drwav_uint64 drwav_write_pcm_frames_le(drwav* pWav, drwav_uint64 framesToWrite, const void* pData);
-DRWAV_API drwav_uint64 drwav_write_pcm_frames_be(drwav* pWav, drwav_uint64 framesToWrite, const void* pData);
-
+DRWAV_API drwav_uint64 drwav_write_pcm_frames(drwav * pWav, drwav_uint64 framesToWrite, const void * pData);
+DRWAV_API drwav_uint64 drwav_write_pcm_frames_le(drwav * pWav, drwav_uint64 framesToWrite, const void * pData);
+DRWAV_API drwav_uint64 drwav_write_pcm_frames_be(drwav * pWav, drwav_uint64 framesToWrite, const void * pData);
 
 /* Conversion Utilities */
-#ifndef DR_WAV_NO_CONVERSION_API
+#    ifndef DR_WAV_NO_CONVERSION_API
 
 /*
 Reads a chunk of audio data and converts it to signed 16-bit PCM samples.
@@ -738,31 +740,30 @@ Returns the number of PCM frames actually read.
 
 If the return value is less than <framesToRead> it means the end of the file has been reached.
 */
-DRWAV_API drwav_uint64 drwav_read_pcm_frames_s16(drwav* pWav, drwav_uint64 framesToRead, drwav_int16* pBufferOut);
-DRWAV_API drwav_uint64 drwav_read_pcm_frames_s16le(drwav* pWav, drwav_uint64 framesToRead, drwav_int16* pBufferOut);
-DRWAV_API drwav_uint64 drwav_read_pcm_frames_s16be(drwav* pWav, drwav_uint64 framesToRead, drwav_int16* pBufferOut);
+DRWAV_API drwav_uint64 drwav_read_pcm_frames_s16(drwav * pWav, drwav_uint64 framesToRead, drwav_int16 * pBufferOut);
+DRWAV_API drwav_uint64 drwav_read_pcm_frames_s16le(drwav * pWav, drwav_uint64 framesToRead, drwav_int16 * pBufferOut);
+DRWAV_API drwav_uint64 drwav_read_pcm_frames_s16be(drwav * pWav, drwav_uint64 framesToRead, drwav_int16 * pBufferOut);
 
 /* Low-level function for converting unsigned 8-bit PCM samples to signed 16-bit PCM samples. */
-DRWAV_API void drwav_u8_to_s16(drwav_int16* pOut, const drwav_uint8* pIn, size_t sampleCount);
+DRWAV_API void drwav_u8_to_s16(drwav_int16 * pOut, const drwav_uint8 * pIn, size_t sampleCount);
 
 /* Low-level function for converting signed 24-bit PCM samples to signed 16-bit PCM samples. */
-DRWAV_API void drwav_s24_to_s16(drwav_int16* pOut, const drwav_uint8* pIn, size_t sampleCount);
+DRWAV_API void drwav_s24_to_s16(drwav_int16 * pOut, const drwav_uint8 * pIn, size_t sampleCount);
 
 /* Low-level function for converting signed 32-bit PCM samples to signed 16-bit PCM samples. */
-DRWAV_API void drwav_s32_to_s16(drwav_int16* pOut, const drwav_int32* pIn, size_t sampleCount);
+DRWAV_API void drwav_s32_to_s16(drwav_int16 * pOut, const drwav_int32 * pIn, size_t sampleCount);
 
 /* Low-level function for converting IEEE 32-bit floating point samples to signed 16-bit PCM samples. */
-DRWAV_API void drwav_f32_to_s16(drwav_int16* pOut, const float* pIn, size_t sampleCount);
+DRWAV_API void drwav_f32_to_s16(drwav_int16 * pOut, const float * pIn, size_t sampleCount);
 
 /* Low-level function for converting IEEE 64-bit floating point samples to signed 16-bit PCM samples. */
-DRWAV_API void drwav_f64_to_s16(drwav_int16* pOut, const double* pIn, size_t sampleCount);
+DRWAV_API void drwav_f64_to_s16(drwav_int16 * pOut, const double * pIn, size_t sampleCount);
 
 /* Low-level function for converting A-law samples to signed 16-bit PCM samples. */
-DRWAV_API void drwav_alaw_to_s16(drwav_int16* pOut, const drwav_uint8* pIn, size_t sampleCount);
+DRWAV_API void drwav_alaw_to_s16(drwav_int16 * pOut, const drwav_uint8 * pIn, size_t sampleCount);
 
 /* Low-level function for converting u-law samples to signed 16-bit PCM samples. */
-DRWAV_API void drwav_mulaw_to_s16(drwav_int16* pOut, const drwav_uint8* pIn, size_t sampleCount);
-
+DRWAV_API void drwav_mulaw_to_s16(drwav_int16 * pOut, const drwav_uint8 * pIn, size_t sampleCount);
 
 /*
 Reads a chunk of audio data and converts it to IEEE 32-bit floating point samples.
@@ -773,31 +774,30 @@ Returns the number of PCM frames actually read.
 
 If the return value is less than <framesToRead> it means the end of the file has been reached.
 */
-DRWAV_API drwav_uint64 drwav_read_pcm_frames_f32(drwav* pWav, drwav_uint64 framesToRead, float* pBufferOut);
-DRWAV_API drwav_uint64 drwav_read_pcm_frames_f32le(drwav* pWav, drwav_uint64 framesToRead, float* pBufferOut);
-DRWAV_API drwav_uint64 drwav_read_pcm_frames_f32be(drwav* pWav, drwav_uint64 framesToRead, float* pBufferOut);
+DRWAV_API drwav_uint64 drwav_read_pcm_frames_f32(drwav * pWav, drwav_uint64 framesToRead, float * pBufferOut);
+DRWAV_API drwav_uint64 drwav_read_pcm_frames_f32le(drwav * pWav, drwav_uint64 framesToRead, float * pBufferOut);
+DRWAV_API drwav_uint64 drwav_read_pcm_frames_f32be(drwav * pWav, drwav_uint64 framesToRead, float * pBufferOut);
 
 /* Low-level function for converting unsigned 8-bit PCM samples to IEEE 32-bit floating point samples. */
-DRWAV_API void drwav_u8_to_f32(float* pOut, const drwav_uint8* pIn, size_t sampleCount);
+DRWAV_API void drwav_u8_to_f32(float * pOut, const drwav_uint8 * pIn, size_t sampleCount);
 
 /* Low-level function for converting signed 16-bit PCM samples to IEEE 32-bit floating point samples. */
-DRWAV_API void drwav_s16_to_f32(float* pOut, const drwav_int16* pIn, size_t sampleCount);
+DRWAV_API void drwav_s16_to_f32(float * pOut, const drwav_int16 * pIn, size_t sampleCount);
 
 /* Low-level function for converting signed 24-bit PCM samples to IEEE 32-bit floating point samples. */
-DRWAV_API void drwav_s24_to_f32(float* pOut, const drwav_uint8* pIn, size_t sampleCount);
+DRWAV_API void drwav_s24_to_f32(float * pOut, const drwav_uint8 * pIn, size_t sampleCount);
 
 /* Low-level function for converting signed 32-bit PCM samples to IEEE 32-bit floating point samples. */
-DRWAV_API void drwav_s32_to_f32(float* pOut, const drwav_int32* pIn, size_t sampleCount);
+DRWAV_API void drwav_s32_to_f32(float * pOut, const drwav_int32 * pIn, size_t sampleCount);
 
 /* Low-level function for converting IEEE 64-bit floating point samples to IEEE 32-bit floating point samples. */
-DRWAV_API void drwav_f64_to_f32(float* pOut, const double* pIn, size_t sampleCount);
+DRWAV_API void drwav_f64_to_f32(float * pOut, const double * pIn, size_t sampleCount);
 
 /* Low-level function for converting A-law samples to IEEE 32-bit floating point samples. */
-DRWAV_API void drwav_alaw_to_f32(float* pOut, const drwav_uint8* pIn, size_t sampleCount);
+DRWAV_API void drwav_alaw_to_f32(float * pOut, const drwav_uint8 * pIn, size_t sampleCount);
 
 /* Low-level function for converting u-law samples to IEEE 32-bit floating point samples. */
-DRWAV_API void drwav_mulaw_to_f32(float* pOut, const drwav_uint8* pIn, size_t sampleCount);
-
+DRWAV_API void drwav_mulaw_to_f32(float * pOut, const drwav_uint8 * pIn, size_t sampleCount);
 
 /*
 Reads a chunk of audio data and converts it to signed 32-bit PCM samples.
@@ -808,37 +808,36 @@ Returns the number of PCM frames actually read.
 
 If the return value is less than <framesToRead> it means the end of the file has been reached.
 */
-DRWAV_API drwav_uint64 drwav_read_pcm_frames_s32(drwav* pWav, drwav_uint64 framesToRead, drwav_int32* pBufferOut);
-DRWAV_API drwav_uint64 drwav_read_pcm_frames_s32le(drwav* pWav, drwav_uint64 framesToRead, drwav_int32* pBufferOut);
-DRWAV_API drwav_uint64 drwav_read_pcm_frames_s32be(drwav* pWav, drwav_uint64 framesToRead, drwav_int32* pBufferOut);
+DRWAV_API drwav_uint64 drwav_read_pcm_frames_s32(drwav * pWav, drwav_uint64 framesToRead, drwav_int32 * pBufferOut);
+DRWAV_API drwav_uint64 drwav_read_pcm_frames_s32le(drwav * pWav, drwav_uint64 framesToRead, drwav_int32 * pBufferOut);
+DRWAV_API drwav_uint64 drwav_read_pcm_frames_s32be(drwav * pWav, drwav_uint64 framesToRead, drwav_int32 * pBufferOut);
 
 /* Low-level function for converting unsigned 8-bit PCM samples to signed 32-bit PCM samples. */
-DRWAV_API void drwav_u8_to_s32(drwav_int32* pOut, const drwav_uint8* pIn, size_t sampleCount);
+DRWAV_API void drwav_u8_to_s32(drwav_int32 * pOut, const drwav_uint8 * pIn, size_t sampleCount);
 
 /* Low-level function for converting signed 16-bit PCM samples to signed 32-bit PCM samples. */
-DRWAV_API void drwav_s16_to_s32(drwav_int32* pOut, const drwav_int16* pIn, size_t sampleCount);
+DRWAV_API void drwav_s16_to_s32(drwav_int32 * pOut, const drwav_int16 * pIn, size_t sampleCount);
 
 /* Low-level function for converting signed 24-bit PCM samples to signed 32-bit PCM samples. */
-DRWAV_API void drwav_s24_to_s32(drwav_int32* pOut, const drwav_uint8* pIn, size_t sampleCount);
+DRWAV_API void drwav_s24_to_s32(drwav_int32 * pOut, const drwav_uint8 * pIn, size_t sampleCount);
 
 /* Low-level function for converting IEEE 32-bit floating point samples to signed 32-bit PCM samples. */
-DRWAV_API void drwav_f32_to_s32(drwav_int32* pOut, const float* pIn, size_t sampleCount);
+DRWAV_API void drwav_f32_to_s32(drwav_int32 * pOut, const float * pIn, size_t sampleCount);
 
 /* Low-level function for converting IEEE 64-bit floating point samples to signed 32-bit PCM samples. */
-DRWAV_API void drwav_f64_to_s32(drwav_int32* pOut, const double* pIn, size_t sampleCount);
+DRWAV_API void drwav_f64_to_s32(drwav_int32 * pOut, const double * pIn, size_t sampleCount);
 
 /* Low-level function for converting A-law samples to signed 32-bit PCM samples. */
-DRWAV_API void drwav_alaw_to_s32(drwav_int32* pOut, const drwav_uint8* pIn, size_t sampleCount);
+DRWAV_API void drwav_alaw_to_s32(drwav_int32 * pOut, const drwav_uint8 * pIn, size_t sampleCount);
 
 /* Low-level function for converting u-law samples to signed 32-bit PCM samples. */
-DRWAV_API void drwav_mulaw_to_s32(drwav_int32* pOut, const drwav_uint8* pIn, size_t sampleCount);
-
-#endif  /* DR_WAV_NO_CONVERSION_API */
+DRWAV_API void drwav_mulaw_to_s32(drwav_int32 * pOut, const drwav_uint8 * pIn, size_t sampleCount);
 
+#    endif /* DR_WAV_NO_CONVERSION_API */
 
 /* High-Level Convenience Helpers */
 
-#ifndef DR_WAV_NO_STDIO
+#    ifndef DR_WAV_NO_STDIO
 /*
 Helper for initializing a wave file for reading using stdio.
 
@@ -846,10 +845,24 @@ This holds the internal FILE object until drwav_uninit() is called. Keep this in
 objects because the operating system may restrict the number of file handles an application can have open at
 any given time.
 */
-DRWAV_API drwav_bool32 drwav_init_file(drwav* pWav, const char* filename, const drwav_allocation_callbacks* pAllocationCallbacks);
-DRWAV_API drwav_bool32 drwav_init_file_ex(drwav* pWav, const char* filename, drwav_chunk_proc onChunk, void* pChunkUserData, drwav_uint32 flags, const drwav_allocation_callbacks* pAllocationCallbacks);
-DRWAV_API drwav_bool32 drwav_init_file_w(drwav* pWav, const wchar_t* filename, const drwav_allocation_callbacks* pAllocationCallbacks);
-DRWAV_API drwav_bool32 drwav_init_file_ex_w(drwav* pWav, const wchar_t* filename, drwav_chunk_proc onChunk, void* pChunkUserData, drwav_uint32 flags, const drwav_allocation_callbacks* pAllocationCallbacks);
+DRWAV_API drwav_bool32 drwav_init_file(drwav *                            pWav,
+                                       const char *                       filename,
+                                       const drwav_allocation_callbacks * pAllocationCallbacks);
+DRWAV_API drwav_bool32 drwav_init_file_ex(drwav *                            pWav,
+                                          const char *                       filename,
+                                          drwav_chunk_proc                   onChunk,
+                                          void *                             pChunkUserData,
+                                          drwav_uint32                       flags,
+                                          const drwav_allocation_callbacks * pAllocationCallbacks);
+DRWAV_API drwav_bool32 drwav_init_file_w(drwav *                            pWav,
+                                         const wchar_t *                    filename,
+                                         const drwav_allocation_callbacks * pAllocationCallbacks);
+DRWAV_API drwav_bool32 drwav_init_file_ex_w(drwav *                            pWav,
+                                            const wchar_t *                    filename,
+                                            drwav_chunk_proc                   onChunk,
+                                            void *                             pChunkUserData,
+                                            drwav_uint32                       flags,
+                                            const drwav_allocation_callbacks * pAllocationCallbacks);
 
 /*
 Helper for initializing a wave file for writing using stdio.
@@ -858,13 +871,37 @@ This holds the internal FILE object until drwav_uninit() is called. Keep this in
 objects because the operating system may restrict the number of file handles an application can have open at
 any given time.
 */
-DRWAV_API drwav_bool32 drwav_init_file_write(drwav* pWav, const char* filename, const drwav_data_format* pFormat, const drwav_allocation_callbacks* pAllocationCallbacks);
-DRWAV_API drwav_bool32 drwav_init_file_write_sequential(drwav* pWav, const char* filename, const drwav_data_format* pFormat, drwav_uint64 totalSampleCount, const drwav_allocation_callbacks* pAllocationCallbacks);
-DRWAV_API drwav_bool32 drwav_init_file_write_sequential_pcm_frames(drwav* pWav, const char* filename, const drwav_data_format* pFormat, drwav_uint64 totalPCMFrameCount, const drwav_allocation_callbacks* pAllocationCallbacks);
-DRWAV_API drwav_bool32 drwav_init_file_write_w(drwav* pWav, const wchar_t* filename, const drwav_data_format* pFormat, const drwav_allocation_callbacks* pAllocationCallbacks);
-DRWAV_API drwav_bool32 drwav_init_file_write_sequential_w(drwav* pWav, const wchar_t* filename, const drwav_data_format* pFormat, drwav_uint64 totalSampleCount, const drwav_allocation_callbacks* pAllocationCallbacks);
-DRWAV_API drwav_bool32 drwav_init_file_write_sequential_pcm_frames_w(drwav* pWav, const wchar_t* filename, const drwav_data_format* pFormat, drwav_uint64 totalPCMFrameCount, const drwav_allocation_callbacks* pAllocationCallbacks);
-#endif  /* DR_WAV_NO_STDIO */
+DRWAV_API drwav_bool32 drwav_init_file_write(drwav *                            pWav,
+                                             const char *                       filename,
+                                             const drwav_data_format *          pFormat,
+                                             const drwav_allocation_callbacks * pAllocationCallbacks);
+DRWAV_API drwav_bool32 drwav_init_file_write_sequential(drwav *                            pWav,
+                                                        const char *                       filename,
+                                                        const drwav_data_format *          pFormat,
+                                                        drwav_uint64                       totalSampleCount,
+                                                        const drwav_allocation_callbacks * pAllocationCallbacks);
+DRWAV_API drwav_bool32
+drwav_init_file_write_sequential_pcm_frames(drwav *                            pWav,
+                                            const char *                       filename,
+                                            const drwav_data_format *          pFormat,
+                                            drwav_uint64                       totalPCMFrameCount,
+                                            const drwav_allocation_callbacks * pAllocationCallbacks);
+DRWAV_API drwav_bool32 drwav_init_file_write_w(drwav *                            pWav,
+                                               const wchar_t *                    filename,
+                                               const drwav_data_format *          pFormat,
+                                               const drwav_allocation_callbacks * pAllocationCallbacks);
+DRWAV_API drwav_bool32 drwav_init_file_write_sequential_w(drwav *                            pWav,
+                                                          const wchar_t *                    filename,
+                                                          const drwav_data_format *          pFormat,
+                                                          drwav_uint64                       totalSampleCount,
+                                                          const drwav_allocation_callbacks * pAllocationCallbacks);
+DRWAV_API drwav_bool32
+drwav_init_file_write_sequential_pcm_frames_w(drwav *                            pWav,
+                                              const wchar_t *                    filename,
+                                              const drwav_data_format *          pFormat,
+                                              drwav_uint64                       totalPCMFrameCount,
+                                              const drwav_allocation_callbacks * pAllocationCallbacks);
+#    endif /* DR_WAV_NO_STDIO */
 
 /*
 Helper for initializing a loader from a pre-allocated memory buffer.
@@ -874,8 +911,17 @@ the lifetime of the drwav object.
 
 The buffer should contain the contents of the entire wave file, not just the sample data.
 */
-DRWAV_API drwav_bool32 drwav_init_memory(drwav* pWav, const void* data, size_t dataSize, const drwav_allocation_callbacks* pAllocationCallbacks);
-DRWAV_API drwav_bool32 drwav_init_memory_ex(drwav* pWav, const void* data, size_t dataSize, drwav_chunk_proc onChunk, void* pChunkUserData, drwav_uint32 flags, const drwav_allocation_callbacks* pAllocationCallbacks);
+DRWAV_API drwav_bool32 drwav_init_memory(drwav *                            pWav,
+                                         const void *                       data,
+                                         size_t                             dataSize,
+                                         const drwav_allocation_callbacks * pAllocationCallbacks);
+DRWAV_API drwav_bool32 drwav_init_memory_ex(drwav *                            pWav,
+                                            const void *                       data,
+                                            size_t                             dataSize,
+                                            drwav_chunk_proc                   onChunk,
+                                            void *                             pChunkUserData,
+                                            drwav_uint32                       flags,
+                                            const drwav_allocation_callbacks * pAllocationCallbacks);
 
 /*
 Helper for initializing a writer which outputs data to a memory buffer.
@@ -885,65 +931,141 @@ dr_wav will manage the memory allocations, however it is up to the caller to fre
 The buffer will remain allocated even after drwav_uninit() is called. The buffer should not be considered valid
 until after drwav_uninit() has been called.
 */
-DRWAV_API drwav_bool32 drwav_init_memory_write(drwav* pWav, void** ppData, size_t* pDataSize, const drwav_data_format* pFormat, const drwav_allocation_callbacks* pAllocationCallbacks);
-DRWAV_API drwav_bool32 drwav_init_memory_write_sequential(drwav* pWav, void** ppData, size_t* pDataSize, const drwav_data_format* pFormat, drwav_uint64 totalSampleCount, const drwav_allocation_callbacks* pAllocationCallbacks);
-DRWAV_API drwav_bool32 drwav_init_memory_write_sequential_pcm_frames(drwav* pWav, void** ppData, size_t* pDataSize, const drwav_data_format* pFormat, drwav_uint64 totalPCMFrameCount, const drwav_allocation_callbacks* pAllocationCallbacks);
-
-
-#ifndef DR_WAV_NO_CONVERSION_API
+DRWAV_API drwav_bool32 drwav_init_memory_write(drwav *                            pWav,
+                                               void **                            ppData,
+                                               size_t *                           pDataSize,
+                                               const drwav_data_format *          pFormat,
+                                               const drwav_allocation_callbacks * pAllocationCallbacks);
+DRWAV_API drwav_bool32 drwav_init_memory_write_sequential(drwav *                            pWav,
+                                                          void **                            ppData,
+                                                          size_t *                           pDataSize,
+                                                          const drwav_data_format *          pFormat,
+                                                          drwav_uint64                       totalSampleCount,
+                                                          const drwav_allocation_callbacks * pAllocationCallbacks);
+DRWAV_API drwav_bool32
+drwav_init_memory_write_sequential_pcm_frames(drwav *                            pWav,
+                                              void **                            ppData,
+                                              size_t *                           pDataSize,
+                                              const drwav_data_format *          pFormat,
+                                              drwav_uint64                       totalPCMFrameCount,
+                                              const drwav_allocation_callbacks * pAllocationCallbacks);
+
+#    ifndef DR_WAV_NO_CONVERSION_API
 /*
 Opens and reads an entire wav file in a single operation.
 
 The return value is a heap-allocated buffer containing the audio data. Use drwav_free() to free the buffer.
 */
-DRWAV_API drwav_int16* drwav_open_and_read_pcm_frames_s16(drwav_read_proc onRead, drwav_seek_proc onSeek, void* pUserData, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks);
-DRWAV_API float* drwav_open_and_read_pcm_frames_f32(drwav_read_proc onRead, drwav_seek_proc onSeek, void* pUserData, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks);
-DRWAV_API drwav_int32* drwav_open_and_read_pcm_frames_s32(drwav_read_proc onRead, drwav_seek_proc onSeek, void* pUserData, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks);
-#ifndef DR_WAV_NO_STDIO
+DRWAV_API drwav_int16 * drwav_open_and_read_pcm_frames_s16(drwav_read_proc                    onRead,
+                                                           drwav_seek_proc                    onSeek,
+                                                           void *                             pUserData,
+                                                           unsigned int *                     channelsOut,
+                                                           unsigned int *                     sampleRateOut,
+                                                           drwav_uint64 *                     totalFrameCountOut,
+                                                           const drwav_allocation_callbacks * pAllocationCallbacks);
+DRWAV_API float *       drwav_open_and_read_pcm_frames_f32(drwav_read_proc                    onRead,
+                                                           drwav_seek_proc                    onSeek,
+                                                           void *                             pUserData,
+                                                           unsigned int *                     channelsOut,
+                                                           unsigned int *                     sampleRateOut,
+                                                           drwav_uint64 *                     totalFrameCountOut,
+                                                           const drwav_allocation_callbacks * pAllocationCallbacks);
+DRWAV_API drwav_int32 * drwav_open_and_read_pcm_frames_s32(drwav_read_proc                    onRead,
+                                                           drwav_seek_proc                    onSeek,
+                                                           void *                             pUserData,
+                                                           unsigned int *                     channelsOut,
+                                                           unsigned int *                     sampleRateOut,
+                                                           drwav_uint64 *                     totalFrameCountOut,
+                                                           const drwav_allocation_callbacks * pAllocationCallbacks);
+#        ifndef DR_WAV_NO_STDIO
 /*
 Opens and decodes an entire wav file in a single operation.
 
 The return value is a heap-allocated buffer containing the audio data. Use drwav_free() to free the buffer.
 */
-DRWAV_API drwav_int16* drwav_open_file_and_read_pcm_frames_s16(const char* filename, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks);
-DRWAV_API float* drwav_open_file_and_read_pcm_frames_f32(const char* filename, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks);
-DRWAV_API drwav_int32* drwav_open_file_and_read_pcm_frames_s32(const char* filename, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks);
-DRWAV_API drwav_int16* drwav_open_file_and_read_pcm_frames_s16_w(const wchar_t* filename, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks);
-DRWAV_API float* drwav_open_file_and_read_pcm_frames_f32_w(const wchar_t* filename, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks);
-DRWAV_API drwav_int32* drwav_open_file_and_read_pcm_frames_s32_w(const wchar_t* filename, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks);
-#endif
+DRWAV_API drwav_int16 * drwav_open_file_and_read_pcm_frames_s16(
+    const char *                       filename,
+    unsigned int *                     channelsOut,
+    unsigned int *                     sampleRateOut,
+    drwav_uint64 *                     totalFrameCountOut,
+    const drwav_allocation_callbacks * pAllocationCallbacks);
+DRWAV_API float * drwav_open_file_and_read_pcm_frames_f32(const char *                       filename,
+                                                          unsigned int *                     channelsOut,
+                                                          unsigned int *                     sampleRateOut,
+                                                          drwav_uint64 *                     totalFrameCountOut,
+                                                          const drwav_allocation_callbacks * pAllocationCallbacks);
+DRWAV_API drwav_int32 * drwav_open_file_and_read_pcm_frames_s32(
+    const char *                       filename,
+    unsigned int *                     channelsOut,
+    unsigned int *                     sampleRateOut,
+    drwav_uint64 *                     totalFrameCountOut,
+    const drwav_allocation_callbacks * pAllocationCallbacks);
+DRWAV_API drwav_int16 * drwav_open_file_and_read_pcm_frames_s16_w(
+    const wchar_t *                    filename,
+    unsigned int *                     channelsOut,
+    unsigned int *                     sampleRateOut,
+    drwav_uint64 *                     totalFrameCountOut,
+    const drwav_allocation_callbacks * pAllocationCallbacks);
+DRWAV_API float * drwav_open_file_and_read_pcm_frames_f32_w(const wchar_t *                    filename,
+                                                            unsigned int *                     channelsOut,
+                                                            unsigned int *                     sampleRateOut,
+                                                            drwav_uint64 *                     totalFrameCountOut,
+                                                            const drwav_allocation_callbacks * pAllocationCallbacks);
+DRWAV_API drwav_int32 * drwav_open_file_and_read_pcm_frames_s32_w(
+    const wchar_t *                    filename,
+    unsigned int *                     channelsOut,
+    unsigned int *                     sampleRateOut,
+    drwav_uint64 *                     totalFrameCountOut,
+    const drwav_allocation_callbacks * pAllocationCallbacks);
+#        endif
 /*
 Opens and decodes an entire wav file from a block of memory in a single operation.
 
 The return value is a heap-allocated buffer containing the audio data. Use drwav_free() to free the buffer.
 */
-DRWAV_API drwav_int16* drwav_open_memory_and_read_pcm_frames_s16(const void* data, size_t dataSize, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks);
-DRWAV_API float* drwav_open_memory_and_read_pcm_frames_f32(const void* data, size_t dataSize, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks);
-DRWAV_API drwav_int32* drwav_open_memory_and_read_pcm_frames_s32(const void* data, size_t dataSize, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks);
-#endif
+DRWAV_API drwav_int16 * drwav_open_memory_and_read_pcm_frames_s16(
+    const void *                       data,
+    size_t                             dataSize,
+    unsigned int *                     channelsOut,
+    unsigned int *                     sampleRateOut,
+    drwav_uint64 *                     totalFrameCountOut,
+    const drwav_allocation_callbacks * pAllocationCallbacks);
+DRWAV_API float * drwav_open_memory_and_read_pcm_frames_f32(const void *                       data,
+                                                            size_t                             dataSize,
+                                                            unsigned int *                     channelsOut,
+                                                            unsigned int *                     sampleRateOut,
+                                                            drwav_uint64 *                     totalFrameCountOut,
+                                                            const drwav_allocation_callbacks * pAllocationCallbacks);
+DRWAV_API drwav_int32 * drwav_open_memory_and_read_pcm_frames_s32(
+    const void *                       data,
+    size_t                             dataSize,
+    unsigned int *                     channelsOut,
+    unsigned int *                     sampleRateOut,
+    drwav_uint64 *                     totalFrameCountOut,
+    const drwav_allocation_callbacks * pAllocationCallbacks);
+#    endif
 
 /* Frees data that was allocated internally by dr_wav. */
-DRWAV_API void drwav_free(void* p, const drwav_allocation_callbacks* pAllocationCallbacks);
+DRWAV_API void drwav_free(void * p, const drwav_allocation_callbacks * pAllocationCallbacks);
 
 /* Converts bytes from a wav stream to a sized type of native endian. */
-DRWAV_API drwav_uint16 drwav_bytes_to_u16(const drwav_uint8* data);
-DRWAV_API drwav_int16 drwav_bytes_to_s16(const drwav_uint8* data);
-DRWAV_API drwav_uint32 drwav_bytes_to_u32(const drwav_uint8* data);
-DRWAV_API drwav_int32 drwav_bytes_to_s32(const drwav_uint8* data);
-DRWAV_API drwav_uint64 drwav_bytes_to_u64(const drwav_uint8* data);
-DRWAV_API drwav_int64 drwav_bytes_to_s64(const drwav_uint8* data);
+DRWAV_API drwav_uint16 drwav_bytes_to_u16(const drwav_uint8 * data);
+DRWAV_API drwav_int16  drwav_bytes_to_s16(const drwav_uint8 * data);
+DRWAV_API drwav_uint32 drwav_bytes_to_u32(const drwav_uint8 * data);
+DRWAV_API drwav_int32  drwav_bytes_to_s32(const drwav_uint8 * data);
+DRWAV_API drwav_uint64 drwav_bytes_to_u64(const drwav_uint8 * data);
+DRWAV_API drwav_int64  drwav_bytes_to_s64(const drwav_uint8 * data);
 
 /* Compares a GUID for the purpose of checking the type of a Wave64 chunk. */
 DRWAV_API drwav_bool32 drwav_guid_equal(const drwav_uint8 a[16], const drwav_uint8 b[16]);
 
 /* Compares a four-character-code for the purpose of checking the type of a RIFF chunk. */
-DRWAV_API drwav_bool32 drwav_fourcc_equal(const drwav_uint8* a, const char* b);
+DRWAV_API drwav_bool32 drwav_fourcc_equal(const drwav_uint8 * a, const char * b);
 
-#ifdef __cplusplus
+#    ifdef __cplusplus
 }
-#endif
-#endif  /* dr_wav_h */
-
+#    endif
+#endif /* dr_wav_h */
 
 /************************************************************************************************************************************************************
  ************************************************************************************************************************************************************
@@ -953,118 +1075,117 @@ DRWAV_API drwav_bool32 drwav_fourcc_equal(const drwav_uint8* a, const char* b);
  ************************************************************************************************************************************************************
  ************************************************************************************************************************************************************/
 #if defined(DR_WAV_IMPLEMENTATION) || defined(DRWAV_IMPLEMENTATION)
-#ifndef dr_wav_c
-#define dr_wav_c
+#    ifndef dr_wav_c
+#        define dr_wav_c
 
-#include <stdlib.h>
-#include <string.h> /* For memcpy(), memset() */
-#include <limits.h> /* For INT_MAX */
+#        include <limits.h> /* For INT_MAX */
+#        include <stdlib.h>
+#        include <string.h> /* For memcpy(), memset() */
 
-#ifndef DR_WAV_NO_STDIO
-#include <stdio.h>
-#include <wchar.h>
-#endif
+#        ifndef DR_WAV_NO_STDIO
+#            include <stdio.h>
+#            include <wchar.h>
+#        endif
 
 /* Standard library stuff. */
-#ifndef DRWAV_ASSERT
-#include <assert.h>
-#define DRWAV_ASSERT(expression)           assert(expression)
-#endif
-#ifndef DRWAV_MALLOC
-#define DRWAV_MALLOC(sz)                   malloc((sz))
-#endif
-#ifndef DRWAV_REALLOC
-#define DRWAV_REALLOC(p, sz)               realloc((p), (sz))
-#endif
-#ifndef DRWAV_FREE
-#define DRWAV_FREE(p)                      free((p))
-#endif
-#ifndef DRWAV_COPY_MEMORY
-#define DRWAV_COPY_MEMORY(dst, src, sz)    memcpy((dst), (src), (sz))
-#endif
-#ifndef DRWAV_ZERO_MEMORY
-#define DRWAV_ZERO_MEMORY(p, sz)           memset((p), 0, (sz))
-#endif
-#ifndef DRWAV_ZERO_OBJECT
-#define DRWAV_ZERO_OBJECT(p)               DRWAV_ZERO_MEMORY((p), sizeof(*p))
-#endif
-
-#define drwav_countof(x)                   (sizeof(x) / sizeof(x[0]))
-#define drwav_align(x, a)                  ((((x) + (a) - 1) / (a)) * (a))
-#define drwav_min(a, b)                    (((a) < (b)) ? (a) : (b))
-#define drwav_max(a, b)                    (((a) > (b)) ? (a) : (b))
-#define drwav_clamp(x, lo, hi)             (drwav_max((lo), drwav_min((hi), (x))))
-
-#define DRWAV_MAX_SIMD_VECTOR_SIZE         64  /* 64 for AVX-512 in the future. */
+#        ifndef DRWAV_ASSERT
+#            include <assert.h>
+#            define DRWAV_ASSERT(expression) assert(expression)
+#        endif
+#        ifndef DRWAV_MALLOC
+#            define DRWAV_MALLOC(sz) malloc((sz))
+#        endif
+#        ifndef DRWAV_REALLOC
+#            define DRWAV_REALLOC(p, sz) realloc((p), (sz))
+#        endif
+#        ifndef DRWAV_FREE
+#            define DRWAV_FREE(p) free((p))
+#        endif
+#        ifndef DRWAV_COPY_MEMORY
+#            define DRWAV_COPY_MEMORY(dst, src, sz) memcpy((dst), (src), (sz))
+#        endif
+#        ifndef DRWAV_ZERO_MEMORY
+#            define DRWAV_ZERO_MEMORY(p, sz) memset((p), 0, (sz))
+#        endif
+#        ifndef DRWAV_ZERO_OBJECT
+#            define DRWAV_ZERO_OBJECT(p) DRWAV_ZERO_MEMORY((p), sizeof(*p))
+#        endif
+
+#        define drwav_countof(x)       (sizeof(x) / sizeof(x[0]))
+#        define drwav_align(x, a)      ((((x) + (a) - 1) / (a)) * (a))
+#        define drwav_min(a, b)        (((a) < (b)) ? (a) : (b))
+#        define drwav_max(a, b)        (((a) > (b)) ? (a) : (b))
+#        define drwav_clamp(x, lo, hi) (drwav_max((lo), drwav_min((hi), (x))))
+
+#        define DRWAV_MAX_SIMD_VECTOR_SIZE 64 /* 64 for AVX-512 in the future. */
 
 /* CPU architecture. */
-#if defined(__x86_64__) || defined(_M_X64)
-    #define DRWAV_X64
-#elif defined(__i386) || defined(_M_IX86)
-    #define DRWAV_X86
-#elif defined(__arm__) || defined(_M_ARM)
-    #define DRWAV_ARM
-#endif
-
-#ifdef _MSC_VER
-    #define DRWAV_INLINE __forceinline
-#elif defined(__GNUC__)
-    /*
+#        if defined(__x86_64__) || defined(_M_X64)
+#            define DRWAV_X64
+#        elif defined(__i386) || defined(_M_IX86)
+#            define DRWAV_X86
+#        elif defined(__arm__) || defined(_M_ARM)
+#            define DRWAV_ARM
+#        endif
+
+#        ifdef _MSC_VER
+#            define DRWAV_INLINE __forceinline
+#        elif defined(__GNUC__)
+/*
     I've had a bug report where GCC is emitting warnings about functions possibly not being inlineable. This warning happens when
     the __attribute__((always_inline)) attribute is defined without an "inline" statement. I think therefore there must be some
     case where "__inline__" is not always defined, thus the compiler emitting these warnings. When using -std=c89 or -ansi on the
     command line, we cannot use the "inline" keyword and instead need to use "__inline__". In an attempt to work around this issue
     I am using "__inline__" only when we're compiling in strict ANSI mode.
     */
-    #if defined(__STRICT_ANSI__)
-        #define DRWAV_INLINE __inline__ __attribute__((always_inline))
-    #else
-        #define DRWAV_INLINE inline __attribute__((always_inline))
-    #endif
-#elif defined(__WATCOMC__)
-    #define DRWAV_INLINE __inline
-#else
-    #define DRWAV_INLINE
-#endif
-
-#if defined(SIZE_MAX)
-    #define DRWAV_SIZE_MAX  SIZE_MAX
-#else
-    #if defined(_WIN64) || defined(_LP64) || defined(__LP64__)
-        #define DRWAV_SIZE_MAX  ((drwav_uint64)0xFFFFFFFFFFFFFFFF)
-    #else
-        #define DRWAV_SIZE_MAX  0xFFFFFFFF
-    #endif
-#endif
-
-#if defined(_MSC_VER) && _MSC_VER >= 1400
-    #define DRWAV_HAS_BYTESWAP16_INTRINSIC
-    #define DRWAV_HAS_BYTESWAP32_INTRINSIC
-    #define DRWAV_HAS_BYTESWAP64_INTRINSIC
-#elif defined(__clang__)
-    #if defined(__has_builtin)
-        #if __has_builtin(__builtin_bswap16)
-            #define DRWAV_HAS_BYTESWAP16_INTRINSIC
-        #endif
-        #if __has_builtin(__builtin_bswap32)
-            #define DRWAV_HAS_BYTESWAP32_INTRINSIC
-        #endif
-        #if __has_builtin(__builtin_bswap64)
-            #define DRWAV_HAS_BYTESWAP64_INTRINSIC
-        #endif
-    #endif
-#elif defined(__GNUC__)
-    #if ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))
-        #define DRWAV_HAS_BYTESWAP32_INTRINSIC
-        #define DRWAV_HAS_BYTESWAP64_INTRINSIC
-    #endif
-    #if ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8))
-        #define DRWAV_HAS_BYTESWAP16_INTRINSIC
-    #endif
-#endif
-
-DRWAV_API void drwav_version(drwav_uint32* pMajor, drwav_uint32* pMinor, drwav_uint32* pRevision)
-{
+#            if defined(__STRICT_ANSI__)
+#                define DRWAV_INLINE __inline__ __attribute__((always_inline))
+#            else
+#                define DRWAV_INLINE inline __attribute__((always_inline))
+#            endif
+#        elif defined(__WATCOMC__)
+#            define DRWAV_INLINE __inline
+#        else
+#            define DRWAV_INLINE
+#        endif
+
+#        if defined(SIZE_MAX)
+#            define DRWAV_SIZE_MAX SIZE_MAX
+#        else
+#            if defined(_WIN64) || defined(_LP64) || defined(__LP64__)
+#                define DRWAV_SIZE_MAX ((drwav_uint64) 0xFFFFFFFFFFFFFFFF)
+#            else
+#                define DRWAV_SIZE_MAX 0xFFFFFFFF
+#            endif
+#        endif
+
+#        if defined(_MSC_VER) && _MSC_VER >= 1400
+#            define DRWAV_HAS_BYTESWAP16_INTRINSIC
+#            define DRWAV_HAS_BYTESWAP32_INTRINSIC
+#            define DRWAV_HAS_BYTESWAP64_INTRINSIC
+#        elif defined(__clang__)
+#            if defined(__has_builtin)
+#                if __has_builtin(__builtin_bswap16)
+#                    define DRWAV_HAS_BYTESWAP16_INTRINSIC
+#                endif
+#                if __has_builtin(__builtin_bswap32)
+#                    define DRWAV_HAS_BYTESWAP32_INTRINSIC
+#                endif
+#                if __has_builtin(__builtin_bswap64)
+#                    define DRWAV_HAS_BYTESWAP64_INTRINSIC
+#                endif
+#            endif
+#        elif defined(__GNUC__)
+#            if ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))
+#                define DRWAV_HAS_BYTESWAP32_INTRINSIC
+#                define DRWAV_HAS_BYTESWAP64_INTRINSIC
+#            endif
+#            if ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8))
+#                define DRWAV_HAS_BYTESWAP16_INTRINSIC
+#            endif
+#        endif
+
+DRWAV_API void drwav_version(drwav_uint32 * pMajor, drwav_uint32 * pMinor, drwav_uint32 * pRevision) {
     if (pMajor) {
         *pMajor = DRWAV_VERSION_MAJOR;
     }
@@ -1078,8 +1199,7 @@ DRWAV_API void drwav_version(drwav_uint32* pMajor, drwav_uint32* pMinor, drwav_u
     }
 }
 
-DRWAV_API const char* drwav_version_string(void)
-{
+DRWAV_API const char * drwav_version_string(void) {
     return DRWAV_VERSION_STRING;
 }
 
@@ -1087,26 +1207,37 @@ DRWAV_API const char* drwav_version_string(void)
 These limits are used for basic validation when initializing the decoder. If you exceed these limits, first of all: what on Earth are
 you doing?! (Let me know, I'd be curious!) Second, you can adjust these by #define-ing them before the dr_wav implementation.
 */
-#ifndef DRWAV_MAX_SAMPLE_RATE
-#define DRWAV_MAX_SAMPLE_RATE       384000
-#endif
-#ifndef DRWAV_MAX_CHANNELS
-#define DRWAV_MAX_CHANNELS          256
-#endif
-#ifndef DRWAV_MAX_BITS_PER_SAMPLE
-#define DRWAV_MAX_BITS_PER_SAMPLE   64
-#endif
-
-static const drwav_uint8 drwavGUID_W64_RIFF[16] = {0x72,0x69,0x66,0x66, 0x2E,0x91, 0xCF,0x11, 0xA5,0xD6, 0x28,0xDB,0x04,0xC1,0x00,0x00};    /* 66666972-912E-11CF-A5D6-28DB04C10000 */
-static const drwav_uint8 drwavGUID_W64_WAVE[16] = {0x77,0x61,0x76,0x65, 0xF3,0xAC, 0xD3,0x11, 0x8C,0xD1, 0x00,0xC0,0x4F,0x8E,0xDB,0x8A};    /* 65766177-ACF3-11D3-8CD1-00C04F8EDB8A */
-/*static const drwav_uint8 drwavGUID_W64_JUNK[16] = {0x6A,0x75,0x6E,0x6B, 0xF3,0xAC, 0xD3,0x11, 0x8C,0xD1, 0x00,0xC0,0x4F,0x8E,0xDB,0x8A};*/    /* 6B6E756A-ACF3-11D3-8CD1-00C04F8EDB8A */
-static const drwav_uint8 drwavGUID_W64_FMT [16] = {0x66,0x6D,0x74,0x20, 0xF3,0xAC, 0xD3,0x11, 0x8C,0xD1, 0x00,0xC0,0x4F,0x8E,0xDB,0x8A};    /* 20746D66-ACF3-11D3-8CD1-00C04F8EDB8A */
-static const drwav_uint8 drwavGUID_W64_FACT[16] = {0x66,0x61,0x63,0x74, 0xF3,0xAC, 0xD3,0x11, 0x8C,0xD1, 0x00,0xC0,0x4F,0x8E,0xDB,0x8A};    /* 74636166-ACF3-11D3-8CD1-00C04F8EDB8A */
-static const drwav_uint8 drwavGUID_W64_DATA[16] = {0x64,0x61,0x74,0x61, 0xF3,0xAC, 0xD3,0x11, 0x8C,0xD1, 0x00,0xC0,0x4F,0x8E,0xDB,0x8A};    /* 61746164-ACF3-11D3-8CD1-00C04F8EDB8A */
-static const drwav_uint8 drwavGUID_W64_SMPL[16] = {0x73,0x6D,0x70,0x6C, 0xF3,0xAC, 0xD3,0x11, 0x8C,0xD1, 0x00,0xC0,0x4F,0x8E,0xDB,0x8A};    /* 6C706D73-ACF3-11D3-8CD1-00C04F8EDB8A */
-
-static DRWAV_INLINE drwav_bool32 drwav__guid_equal(const drwav_uint8 a[16], const drwav_uint8 b[16])
-{
+#        ifndef DRWAV_MAX_SAMPLE_RATE
+#            define DRWAV_MAX_SAMPLE_RATE 384000
+#        endif
+#        ifndef DRWAV_MAX_CHANNELS
+#            define DRWAV_MAX_CHANNELS 256
+#        endif
+#        ifndef DRWAV_MAX_BITS_PER_SAMPLE
+#            define DRWAV_MAX_BITS_PER_SAMPLE 64
+#        endif
+
+static const drwav_uint8 drwavGUID_W64_RIFF[16] = {
+    0x72, 0x69, 0x66, 0x66, 0x2E, 0x91, 0xCF, 0x11, 0xA5, 0xD6, 0x28, 0xDB, 0x04, 0xC1, 0x00, 0x00
+}; /* 66666972-912E-11CF-A5D6-28DB04C10000 */
+static const drwav_uint8 drwavGUID_W64_WAVE[16] = {
+    0x77, 0x61, 0x76, 0x65, 0xF3, 0xAC, 0xD3, 0x11, 0x8C, 0xD1, 0x00, 0xC0, 0x4F, 0x8E, 0xDB, 0x8A
+}; /* 65766177-ACF3-11D3-8CD1-00C04F8EDB8A */
+/*static const drwav_uint8 drwavGUID_W64_JUNK[16] = {0x6A,0x75,0x6E,0x6B, 0xF3,0xAC, 0xD3,0x11, 0x8C,0xD1, 0x00,0xC0,0x4F,0x8E,0xDB,0x8A};*/ /* 6B6E756A-ACF3-11D3-8CD1-00C04F8EDB8A */
+static const drwav_uint8 drwavGUID_W64_FMT[16] = {
+    0x66, 0x6D, 0x74, 0x20, 0xF3, 0xAC, 0xD3, 0x11, 0x8C, 0xD1, 0x00, 0xC0, 0x4F, 0x8E, 0xDB, 0x8A
+}; /* 20746D66-ACF3-11D3-8CD1-00C04F8EDB8A */
+static const drwav_uint8 drwavGUID_W64_FACT[16] = {
+    0x66, 0x61, 0x63, 0x74, 0xF3, 0xAC, 0xD3, 0x11, 0x8C, 0xD1, 0x00, 0xC0, 0x4F, 0x8E, 0xDB, 0x8A
+}; /* 74636166-ACF3-11D3-8CD1-00C04F8EDB8A */
+static const drwav_uint8 drwavGUID_W64_DATA[16] = {
+    0x64, 0x61, 0x74, 0x61, 0xF3, 0xAC, 0xD3, 0x11, 0x8C, 0xD1, 0x00, 0xC0, 0x4F, 0x8E, 0xDB, 0x8A
+}; /* 61746164-ACF3-11D3-8CD1-00C04F8EDB8A */
+static const drwav_uint8 drwavGUID_W64_SMPL[16] = {
+    0x73, 0x6D, 0x70, 0x6C, 0xF3, 0xAC, 0xD3, 0x11, 0x8C, 0xD1, 0x00, 0xC0, 0x4F, 0x8E, 0xDB, 0x8A
+}; /* 6C706D73-ACF3-11D3-8CD1-00C04F8EDB8A */
+
+static DRWAV_INLINE drwav_bool32 drwav__guid_equal(const drwav_uint8 a[16], const drwav_uint8 b[16]) {
     int i;
     for (i = 0; i < 16; i += 1) {
         if (a[i] != b[i]) {
@@ -1117,332 +1248,303 @@ static DRWAV_INLINE drwav_bool32 drwav__guid_equal(const drwav_uint8 a[16], cons
     return DRWAV_TRUE;
 }
 
-static DRWAV_INLINE drwav_bool32 drwav__fourcc_equal(const drwav_uint8* a, const char* b)
-{
-    return
-        a[0] == b[0] &&
-        a[1] == b[1] &&
-        a[2] == b[2] &&
-        a[3] == b[3];
+static DRWAV_INLINE drwav_bool32 drwav__fourcc_equal(const drwav_uint8 * a, const char * b) {
+    return a[0] == b[0] && a[1] == b[1] && a[2] == b[2] && a[3] == b[3];
 }
 
-
-
-static DRWAV_INLINE int drwav__is_little_endian(void)
-{
-#if defined(DRWAV_X86) || defined(DRWAV_X64)
+static DRWAV_INLINE int drwav__is_little_endian(void) {
+#        if defined(DRWAV_X86) || defined(DRWAV_X64)
     return DRWAV_TRUE;
-#elif defined(__BYTE_ORDER) && defined(__LITTLE_ENDIAN) && __BYTE_ORDER == __LITTLE_ENDIAN
+#        elif defined(__BYTE_ORDER) && defined(__LITTLE_ENDIAN) && __BYTE_ORDER == __LITTLE_ENDIAN
     return DRWAV_TRUE;
-#else
+#        else
     int n = 1;
-    return (*(char*)&n) == 1;
-#endif
+    return (*(char *) &n) == 1;
+#        endif
 }
 
-static DRWAV_INLINE drwav_uint16 drwav__bytes_to_u16(const drwav_uint8* data)
-{
+static DRWAV_INLINE drwav_uint16 drwav__bytes_to_u16(const drwav_uint8 * data) {
     return (data[0] << 0) | (data[1] << 8);
 }
 
-static DRWAV_INLINE drwav_int16 drwav__bytes_to_s16(const drwav_uint8* data)
-{
-    return (short)drwav__bytes_to_u16(data);
+static DRWAV_INLINE drwav_int16 drwav__bytes_to_s16(const drwav_uint8 * data) {
+    return (short) drwav__bytes_to_u16(data);
 }
 
-static DRWAV_INLINE drwav_uint32 drwav__bytes_to_u32(const drwav_uint8* data)
-{
+static DRWAV_INLINE drwav_uint32 drwav__bytes_to_u32(const drwav_uint8 * data) {
     return (data[0] << 0) | (data[1] << 8) | (data[2] << 16) | (data[3] << 24);
 }
 
-static DRWAV_INLINE drwav_int32 drwav__bytes_to_s32(const drwav_uint8* data)
-{
-    return (drwav_int32)drwav__bytes_to_u32(data);
+static DRWAV_INLINE drwav_int32 drwav__bytes_to_s32(const drwav_uint8 * data) {
+    return (drwav_int32) drwav__bytes_to_u32(data);
 }
 
-static DRWAV_INLINE drwav_uint64 drwav__bytes_to_u64(const drwav_uint8* data)
-{
-    return
-        ((drwav_uint64)data[0] <<  0) | ((drwav_uint64)data[1] <<  8) | ((drwav_uint64)data[2] << 16) | ((drwav_uint64)data[3] << 24) |
-        ((drwav_uint64)data[4] << 32) | ((drwav_uint64)data[5] << 40) | ((drwav_uint64)data[6] << 48) | ((drwav_uint64)data[7] << 56);
+static DRWAV_INLINE drwav_uint64 drwav__bytes_to_u64(const drwav_uint8 * data) {
+    return ((drwav_uint64) data[0] << 0) | ((drwav_uint64) data[1] << 8) | ((drwav_uint64) data[2] << 16) |
+           ((drwav_uint64) data[3] << 24) | ((drwav_uint64) data[4] << 32) | ((drwav_uint64) data[5] << 40) |
+           ((drwav_uint64) data[6] << 48) | ((drwav_uint64) data[7] << 56);
 }
 
-static DRWAV_INLINE drwav_int64 drwav__bytes_to_s64(const drwav_uint8* data)
-{
-    return (drwav_int64)drwav__bytes_to_u64(data);
+static DRWAV_INLINE drwav_int64 drwav__bytes_to_s64(const drwav_uint8 * data) {
+    return (drwav_int64) drwav__bytes_to_u64(data);
 }
 
-static DRWAV_INLINE void drwav__bytes_to_guid(const drwav_uint8* data, drwav_uint8* guid)
-{
+static DRWAV_INLINE void drwav__bytes_to_guid(const drwav_uint8 * data, drwav_uint8 * guid) {
     int i;
     for (i = 0; i < 16; ++i) {
         guid[i] = data[i];
     }
 }
 
-
-static DRWAV_INLINE drwav_uint16 drwav__bswap16(drwav_uint16 n)
-{
-#ifdef DRWAV_HAS_BYTESWAP16_INTRINSIC
-    #if defined(_MSC_VER)
-        return _byteswap_ushort(n);
-    #elif defined(__GNUC__) || defined(__clang__)
-        return __builtin_bswap16(n);
-    #else
-        #error "This compiler does not support the byte swap intrinsic."
-    #endif
-#else
-    return ((n & 0xFF00) >> 8) |
-           ((n & 0x00FF) << 8);
-#endif
-}
-
-static DRWAV_INLINE drwav_uint32 drwav__bswap32(drwav_uint32 n)
-{
-#ifdef DRWAV_HAS_BYTESWAP32_INTRINSIC
-    #if defined(_MSC_VER)
-        return _byteswap_ulong(n);
-    #elif defined(__GNUC__) || defined(__clang__)
-        #if defined(DRWAV_ARM) && (defined(__ARM_ARCH) && __ARM_ARCH >= 6) && !defined(DRWAV_64BIT)   /* <-- 64-bit inline assembly has not been tested, so disabling for now. */
-            /* Inline assembly optimized implementation for ARM. In my testing, GCC does not generate optimized code with __builtin_bswap32(). */
-            drwav_uint32 r;
-            __asm__ __volatile__ (
-            #if defined(DRWAV_64BIT)
-                "rev %w[out], %w[in]" : [out]"=r"(r) : [in]"r"(n)   /* <-- This is untested. If someone in the community could test this, that would be appreciated! */
-            #else
-                "rev %[out], %[in]" : [out]"=r"(r) : [in]"r"(n)
-            #endif
-            );
-            return r;
-        #else
-            return __builtin_bswap32(n);
-        #endif
-    #else
-        #error "This compiler does not support the byte swap intrinsic."
-    #endif
-#else
-    return ((n & 0xFF000000) >> 24) |
-           ((n & 0x00FF0000) >>  8) |
-           ((n & 0x0000FF00) <<  8) |
-           ((n & 0x000000FF) << 24);
-#endif
-}
-
-static DRWAV_INLINE drwav_uint64 drwav__bswap64(drwav_uint64 n)
-{
-#ifdef DRWAV_HAS_BYTESWAP64_INTRINSIC
-    #if defined(_MSC_VER)
-        return _byteswap_uint64(n);
-    #elif defined(__GNUC__) || defined(__clang__)
-        return __builtin_bswap64(n);
-    #else
-        #error "This compiler does not support the byte swap intrinsic."
-    #endif
-#else
+static DRWAV_INLINE drwav_uint16 drwav__bswap16(drwav_uint16 n) {
+#        ifdef DRWAV_HAS_BYTESWAP16_INTRINSIC
+#            if defined(_MSC_VER)
+    return _byteswap_ushort(n);
+#            elif defined(__GNUC__) || defined(__clang__)
+    return __builtin_bswap16(n);
+#            else
+#                error "This compiler does not support the byte swap intrinsic."
+#            endif
+#        else
+    return ((n & 0xFF00) >> 8) | ((n & 0x00FF) << 8);
+#        endif
+}
+
+static DRWAV_INLINE drwav_uint32 drwav__bswap32(drwav_uint32 n) {
+#        ifdef DRWAV_HAS_BYTESWAP32_INTRINSIC
+#            if defined(_MSC_VER)
+    return _byteswap_ulong(n);
+#            elif defined(__GNUC__) || defined(__clang__)
+#                if defined(DRWAV_ARM) && (defined(__ARM_ARCH) && __ARM_ARCH >= 6) && \
+                    !defined(DRWAV_64BIT) /* <-- 64-bit inline assembly has not been tested, so disabling for now. */
+    /* Inline assembly optimized implementation for ARM. In my testing, GCC does not generate optimized code with __builtin_bswap32(). */
+    drwav_uint32 r;
+    __asm__ __volatile__(
+#                    if defined(DRWAV_64BIT)
+        "rev %w[out], %w[in]"
+        : [out] "=r"(r)
+        : [in] "r"(
+            n) /* <-- This is untested. If someone in the community could test this, that would be appreciated! */
+#                    else
+        "rev %[out], %[in]"
+        : [out] "=r"(r)
+        : [in] "r"(n)
+#                    endif
+    );
+    return r;
+#                else
+    return __builtin_bswap32(n);
+#                endif
+#            else
+#                error "This compiler does not support the byte swap intrinsic."
+#            endif
+#        else
+    return ((n & 0xFF000000) >> 24) | ((n & 0x00FF0000) >> 8) | ((n & 0x0000FF00) << 8) | ((n & 0x000000FF) << 24);
+#        endif
+}
+
+static DRWAV_INLINE drwav_uint64 drwav__bswap64(drwav_uint64 n) {
+#        ifdef DRWAV_HAS_BYTESWAP64_INTRINSIC
+#            if defined(_MSC_VER)
+    return _byteswap_uint64(n);
+#            elif defined(__GNUC__) || defined(__clang__)
+    return __builtin_bswap64(n);
+#            else
+#                error "This compiler does not support the byte swap intrinsic."
+#            endif
+#        else
     /* Weird "<< 32" bitshift is required for C89 because it doesn't support 64-bit constants. Should be optimized out by a good compiler. */
-    return ((n & ((drwav_uint64)0xFF000000 << 32)) >> 56) |
-           ((n & ((drwav_uint64)0x00FF0000 << 32)) >> 40) |
-           ((n & ((drwav_uint64)0x0000FF00 << 32)) >> 24) |
-           ((n & ((drwav_uint64)0x000000FF << 32)) >>  8) |
-           ((n & ((drwav_uint64)0xFF000000      )) <<  8) |
-           ((n & ((drwav_uint64)0x00FF0000      )) << 24) |
-           ((n & ((drwav_uint64)0x0000FF00      )) << 40) |
-           ((n & ((drwav_uint64)0x000000FF      )) << 56);
-#endif
+    return ((n & ((drwav_uint64) 0xFF000000 << 32)) >> 56) | ((n & ((drwav_uint64) 0x00FF0000 << 32)) >> 40) |
+           ((n & ((drwav_uint64) 0x0000FF00 << 32)) >> 24) | ((n & ((drwav_uint64) 0x000000FF << 32)) >> 8) |
+           ((n & ((drwav_uint64) 0xFF000000)) << 8) | ((n & ((drwav_uint64) 0x00FF0000)) << 24) |
+           ((n & ((drwav_uint64) 0x0000FF00)) << 40) | ((n & ((drwav_uint64) 0x000000FF)) << 56);
+#        endif
 }
 
-
-static DRWAV_INLINE drwav_int16 drwav__bswap_s16(drwav_int16 n)
-{
-    return (drwav_int16)drwav__bswap16((drwav_uint16)n);
+static DRWAV_INLINE drwav_int16 drwav__bswap_s16(drwav_int16 n) {
+    return (drwav_int16) drwav__bswap16((drwav_uint16) n);
 }
 
-static DRWAV_INLINE void drwav__bswap_samples_s16(drwav_int16* pSamples, drwav_uint64 sampleCount)
-{
+static DRWAV_INLINE void drwav__bswap_samples_s16(drwav_int16 * pSamples, drwav_uint64 sampleCount) {
     drwav_uint64 iSample;
     for (iSample = 0; iSample < sampleCount; iSample += 1) {
         pSamples[iSample] = drwav__bswap_s16(pSamples[iSample]);
     }
 }
 
-
-static DRWAV_INLINE void drwav__bswap_s24(drwav_uint8* p)
-{
+static DRWAV_INLINE void drwav__bswap_s24(drwav_uint8 * p) {
     drwav_uint8 t;
-    t = p[0];
+    t    = p[0];
     p[0] = p[2];
     p[2] = t;
 }
 
-static DRWAV_INLINE void drwav__bswap_samples_s24(drwav_uint8* pSamples, drwav_uint64 sampleCount)
-{
+static DRWAV_INLINE void drwav__bswap_samples_s24(drwav_uint8 * pSamples, drwav_uint64 sampleCount) {
     drwav_uint64 iSample;
     for (iSample = 0; iSample < sampleCount; iSample += 1) {
-        drwav_uint8* pSample = pSamples + (iSample*3);
+        drwav_uint8 * pSample = pSamples + (iSample * 3);
         drwav__bswap_s24(pSample);
     }
 }
 
-
-static DRWAV_INLINE drwav_int32 drwav__bswap_s32(drwav_int32 n)
-{
-    return (drwav_int32)drwav__bswap32((drwav_uint32)n);
+static DRWAV_INLINE drwav_int32 drwav__bswap_s32(drwav_int32 n) {
+    return (drwav_int32) drwav__bswap32((drwav_uint32) n);
 }
 
-static DRWAV_INLINE void drwav__bswap_samples_s32(drwav_int32* pSamples, drwav_uint64 sampleCount)
-{
+static DRWAV_INLINE void drwav__bswap_samples_s32(drwav_int32 * pSamples, drwav_uint64 sampleCount) {
     drwav_uint64 iSample;
     for (iSample = 0; iSample < sampleCount; iSample += 1) {
         pSamples[iSample] = drwav__bswap_s32(pSamples[iSample]);
     }
 }
 
-
-static DRWAV_INLINE float drwav__bswap_f32(float n)
-{
+static DRWAV_INLINE float drwav__bswap_f32(float n) {
     union {
         drwav_uint32 i;
-        float f;
+        float        f;
     } x;
+
     x.f = n;
     x.i = drwav__bswap32(x.i);
 
     return x.f;
 }
 
-static DRWAV_INLINE void drwav__bswap_samples_f32(float* pSamples, drwav_uint64 sampleCount)
-{
+static DRWAV_INLINE void drwav__bswap_samples_f32(float * pSamples, drwav_uint64 sampleCount) {
     drwav_uint64 iSample;
     for (iSample = 0; iSample < sampleCount; iSample += 1) {
         pSamples[iSample] = drwav__bswap_f32(pSamples[iSample]);
     }
 }
 
-
-static DRWAV_INLINE double drwav__bswap_f64(double n)
-{
+static DRWAV_INLINE double drwav__bswap_f64(double n) {
     union {
         drwav_uint64 i;
-        double f;
+        double       f;
     } x;
+
     x.f = n;
     x.i = drwav__bswap64(x.i);
 
     return x.f;
 }
 
-static DRWAV_INLINE void drwav__bswap_samples_f64(double* pSamples, drwav_uint64 sampleCount)
-{
+static DRWAV_INLINE void drwav__bswap_samples_f64(double * pSamples, drwav_uint64 sampleCount) {
     drwav_uint64 iSample;
     for (iSample = 0; iSample < sampleCount; iSample += 1) {
         pSamples[iSample] = drwav__bswap_f64(pSamples[iSample]);
     }
 }
 
-
-static DRWAV_INLINE void drwav__bswap_samples_pcm(void* pSamples, drwav_uint64 sampleCount, drwav_uint32 bytesPerSample)
-{
+static DRWAV_INLINE void drwav__bswap_samples_pcm(void *       pSamples,
+                                                  drwav_uint64 sampleCount,
+                                                  drwav_uint32 bytesPerSample) {
     /* Assumes integer PCM. Floating point PCM is done in drwav__bswap_samples_ieee(). */
-    switch (bytesPerSample)
-    {
+    switch (bytesPerSample) {
         case 2: /* s16, s12 (loosely packed) */
-        {
-            drwav__bswap_samples_s16((drwav_int16*)pSamples, sampleCount);
-        } break;
+            {
+                drwav__bswap_samples_s16((drwav_int16 *) pSamples, sampleCount);
+            }
+            break;
         case 3: /* s24 */
-        {
-            drwav__bswap_samples_s24((drwav_uint8*)pSamples, sampleCount);
-        } break;
+            {
+                drwav__bswap_samples_s24((drwav_uint8 *) pSamples, sampleCount);
+            }
+            break;
         case 4: /* s32 */
-        {
-            drwav__bswap_samples_s32((drwav_int32*)pSamples, sampleCount);
-        } break;
+            {
+                drwav__bswap_samples_s32((drwav_int32 *) pSamples, sampleCount);
+            }
+            break;
         default:
-        {
-            /* Unsupported format. */
-            DRWAV_ASSERT(DRWAV_FALSE);
-        } break;
+            {
+                /* Unsupported format. */
+                DRWAV_ASSERT(DRWAV_FALSE);
+            }
+            break;
     }
 }
 
-static DRWAV_INLINE void drwav__bswap_samples_ieee(void* pSamples, drwav_uint64 sampleCount, drwav_uint32 bytesPerSample)
-{
-    switch (bytesPerSample)
-    {
-    #if 0   /* Contributions welcome for f16 support. */
+static DRWAV_INLINE void drwav__bswap_samples_ieee(void *       pSamples,
+                                                   drwav_uint64 sampleCount,
+                                                   drwav_uint32 bytesPerSample) {
+    switch (bytesPerSample) {
+#        if 0   /* Contributions welcome for f16 support. */
         case 2: /* f16 */
         {
             drwav__bswap_samples_f16((drwav_float16*)pSamples, sampleCount);
         } break;
-    #endif
+#        endif
         case 4: /* f32 */
-        {
-            drwav__bswap_samples_f32((float*)pSamples, sampleCount);
-        } break;
+            {
+                drwav__bswap_samples_f32((float *) pSamples, sampleCount);
+            }
+            break;
         case 8: /* f64 */
-        {
-            drwav__bswap_samples_f64((double*)pSamples, sampleCount);
-        } break;
+            {
+                drwav__bswap_samples_f64((double *) pSamples, sampleCount);
+            }
+            break;
         default:
-        {
-            /* Unsupported format. */
-            DRWAV_ASSERT(DRWAV_FALSE);
-        } break;
+            {
+                /* Unsupported format. */
+                DRWAV_ASSERT(DRWAV_FALSE);
+            }
+            break;
     }
 }
 
-static DRWAV_INLINE void drwav__bswap_samples(void* pSamples, drwav_uint64 sampleCount, drwav_uint32 bytesPerSample, drwav_uint16 format)
-{
-    switch (format)
-    {
+static DRWAV_INLINE void drwav__bswap_samples(void *       pSamples,
+                                              drwav_uint64 sampleCount,
+                                              drwav_uint32 bytesPerSample,
+                                              drwav_uint16 format) {
+    switch (format) {
         case DR_WAVE_FORMAT_PCM:
-        {
-            drwav__bswap_samples_pcm(pSamples, sampleCount, bytesPerSample);
-        } break;
+            {
+                drwav__bswap_samples_pcm(pSamples, sampleCount, bytesPerSample);
+            }
+            break;
 
         case DR_WAVE_FORMAT_IEEE_FLOAT:
-        {
-            drwav__bswap_samples_ieee(pSamples, sampleCount, bytesPerSample);
-        } break;
+            {
+                drwav__bswap_samples_ieee(pSamples, sampleCount, bytesPerSample);
+            }
+            break;
 
         case DR_WAVE_FORMAT_ALAW:
         case DR_WAVE_FORMAT_MULAW:
-        {
-            drwav__bswap_samples_s16((drwav_int16*)pSamples, sampleCount);
-        } break;
+            {
+                drwav__bswap_samples_s16((drwav_int16 *) pSamples, sampleCount);
+            }
+            break;
 
         case DR_WAVE_FORMAT_ADPCM:
         case DR_WAVE_FORMAT_DVI_ADPCM:
         default:
-        {
-            /* Unsupported format. */
-            DRWAV_ASSERT(DRWAV_FALSE);
-        } break;
+            {
+                /* Unsupported format. */
+                DRWAV_ASSERT(DRWAV_FALSE);
+            }
+            break;
     }
 }
 
-
-static void* drwav__malloc_default(size_t sz, void* pUserData)
-{
-    (void)pUserData;
+static void * drwav__malloc_default(size_t sz, void * pUserData) {
+    (void) pUserData;
     return DRWAV_MALLOC(sz);
 }
 
-static void* drwav__realloc_default(void* p, size_t sz, void* pUserData)
-{
-    (void)pUserData;
+static void * drwav__realloc_default(void * p, size_t sz, void * pUserData) {
+    (void) pUserData;
     return DRWAV_REALLOC(p, sz);
 }
 
-static void drwav__free_default(void* p, void* pUserData)
-{
-    (void)pUserData;
+static void drwav__free_default(void * p, void * pUserData) {
+    (void) pUserData;
     DRWAV_FREE(p);
 }
 
-
-static void* drwav__malloc_from_callbacks(size_t sz, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
+static void * drwav__malloc_from_callbacks(size_t sz, const drwav_allocation_callbacks * pAllocationCallbacks) {
     if (pAllocationCallbacks == NULL) {
         return NULL;
     }
@@ -1459,8 +1561,10 @@ static void* drwav__malloc_from_callbacks(size_t sz, const drwav_allocation_call
     return NULL;
 }
 
-static void* drwav__realloc_from_callbacks(void* p, size_t szNew, size_t szOld, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
+static void * drwav__realloc_from_callbacks(void *                             p,
+                                            size_t                             szNew,
+                                            size_t                             szOld,
+                                            const drwav_allocation_callbacks * pAllocationCallbacks) {
     if (pAllocationCallbacks == NULL) {
         return NULL;
     }
@@ -1471,7 +1575,7 @@ static void* drwav__realloc_from_callbacks(void* p, size_t szNew, size_t szOld,
 
     /* Try emulating realloc() in terms of malloc()/free(). */
     if (pAllocationCallbacks->onMalloc != NULL && pAllocationCallbacks->onFree != NULL) {
-        void* p2;
+        void * p2;
 
         p2 = pAllocationCallbacks->onMalloc(szNew, pAllocationCallbacks->pUserData);
         if (p2 == NULL) {
@@ -1489,8 +1593,7 @@ static void* drwav__realloc_from_callbacks(void* p, size_t szNew, size_t szOld,
     return NULL;
 }
 
-static void drwav__free_from_callbacks(void* p, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
+static void drwav__free_from_callbacks(void * p, const drwav_allocation_callbacks * pAllocationCallbacks) {
     if (p == NULL || pAllocationCallbacks == NULL) {
         return;
     }
@@ -1500,9 +1603,8 @@ static void drwav__free_from_callbacks(void* p, const drwav_allocation_callbacks
     }
 }
 
-
-static drwav_allocation_callbacks drwav_copy_allocation_callbacks_or_defaults(const drwav_allocation_callbacks* pAllocationCallbacks)
-{
+static drwav_allocation_callbacks drwav_copy_allocation_callbacks_or_defaults(
+    const drwav_allocation_callbacks * pAllocationCallbacks) {
     if (pAllocationCallbacks != NULL) {
         /* Copy. */
         return *pAllocationCallbacks;
@@ -1517,30 +1619,31 @@ static drwav_allocation_callbacks drwav_copy_allocation_callbacks_or_defaults(co
     }
 }
 
-
-static DRWAV_INLINE drwav_bool32 drwav__is_compressed_format_tag(drwav_uint16 formatTag)
-{
-    return
-        formatTag == DR_WAVE_FORMAT_ADPCM ||
-        formatTag == DR_WAVE_FORMAT_DVI_ADPCM;
+static DRWAV_INLINE drwav_bool32 drwav__is_compressed_format_tag(drwav_uint16 formatTag) {
+    return formatTag == DR_WAVE_FORMAT_ADPCM || formatTag == DR_WAVE_FORMAT_DVI_ADPCM;
 }
 
-static unsigned int drwav__chunk_padding_size_riff(drwav_uint64 chunkSize)
-{
-    return (unsigned int)(chunkSize % 2);
+static unsigned int drwav__chunk_padding_size_riff(drwav_uint64 chunkSize) {
+    return (unsigned int) (chunkSize % 2);
 }
 
-static unsigned int drwav__chunk_padding_size_w64(drwav_uint64 chunkSize)
-{
-    return (unsigned int)(chunkSize % 8);
+static unsigned int drwav__chunk_padding_size_w64(drwav_uint64 chunkSize) {
+    return (unsigned int) (chunkSize % 8);
 }
 
-static drwav_uint64 drwav_read_pcm_frames_s16__msadpcm(drwav* pWav, drwav_uint64 samplesToRead, drwav_int16* pBufferOut);
-static drwav_uint64 drwav_read_pcm_frames_s16__ima(drwav* pWav, drwav_uint64 samplesToRead, drwav_int16* pBufferOut);
-static drwav_bool32 drwav_init_write__internal(drwav* pWav, const drwav_data_format* pFormat, drwav_uint64 totalSampleCount);
+static drwav_uint64 drwav_read_pcm_frames_s16__msadpcm(drwav *       pWav,
+                                                       drwav_uint64  samplesToRead,
+                                                       drwav_int16 * pBufferOut);
+static drwav_uint64 drwav_read_pcm_frames_s16__ima(drwav * pWav, drwav_uint64 samplesToRead, drwav_int16 * pBufferOut);
+static drwav_bool32 drwav_init_write__internal(drwav *                   pWav,
+                                               const drwav_data_format * pFormat,
+                                               drwav_uint64              totalSampleCount);
 
-static drwav_result drwav__read_chunk_header(drwav_read_proc onRead, void* pUserData, drwav_container container, drwav_uint64* pRunningBytesReadOut, drwav_chunk_header* pHeaderOut)
-{
+static drwav_result drwav__read_chunk_header(drwav_read_proc      onRead,
+                                             void *               pUserData,
+                                             drwav_container      container,
+                                             drwav_uint64 *       pRunningBytesReadOut,
+                                             drwav_chunk_header * pHeaderOut) {
     if (container == drwav_container_riff || container == drwav_container_rf64) {
         drwav_uint8 sizeInBytes[4];
 
@@ -1566,7 +1669,8 @@ static drwav_result drwav__read_chunk_header(drwav_read_proc onRead, void* pUser
             return DRWAV_INVALID_FILE;
         }
 
-        pHeaderOut->sizeInBytes = drwav__bytes_to_u64(sizeInBytes) - 24;    /* <-- Subtract 24 because w64 includes the size of the header. */
+        pHeaderOut->sizeInBytes =
+            drwav__bytes_to_u64(sizeInBytes) - 24; /* <-- Subtract 24 because w64 includes the size of the header. */
         pHeaderOut->paddingSize = drwav__chunk_padding_size_w64(pHeaderOut->sizeInBytes);
         *pRunningBytesReadOut += 24;
     }
@@ -1574,8 +1678,7 @@ static drwav_result drwav__read_chunk_header(drwav_read_proc onRead, void* pUser
     return DRWAV_SUCCESS;
 }
 
-static drwav_bool32 drwav__seek_forward(drwav_seek_proc onSeek, drwav_uint64 offset, void* pUserData)
-{
+static drwav_bool32 drwav__seek_forward(drwav_seek_proc onSeek, drwav_uint64 offset, void * pUserData) {
     drwav_uint64 bytesRemainingToSeek = offset;
     while (bytesRemainingToSeek > 0) {
         if (bytesRemainingToSeek > 0x7FFFFFFF) {
@@ -1584,7 +1687,7 @@ static drwav_bool32 drwav__seek_forward(drwav_seek_proc onSeek, drwav_uint64 off
             }
             bytesRemainingToSeek -= 0x7FFFFFFF;
         } else {
-            if (!onSeek(pUserData, (int)bytesRemainingToSeek, drwav_seek_origin_current)) {
+            if (!onSeek(pUserData, (int) bytesRemainingToSeek, drwav_seek_origin_current)) {
                 return DRWAV_FALSE;
             }
             bytesRemainingToSeek = 0;
@@ -1594,10 +1697,9 @@ static drwav_bool32 drwav__seek_forward(drwav_seek_proc onSeek, drwav_uint64 off
     return DRWAV_TRUE;
 }
 
-static drwav_bool32 drwav__seek_from_start(drwav_seek_proc onSeek, drwav_uint64 offset, void* pUserData)
-{
+static drwav_bool32 drwav__seek_from_start(drwav_seek_proc onSeek, drwav_uint64 offset, void * pUserData) {
     if (offset <= 0x7FFFFFFF) {
-        return onSeek(pUserData, (int)offset, drwav_seek_origin_start);
+        return onSeek(pUserData, (int) offset, drwav_seek_origin_start);
     }
 
     /* Larger than 32-bit seek. */
@@ -1608,7 +1710,7 @@ static drwav_bool32 drwav__seek_from_start(drwav_seek_proc onSeek, drwav_uint64
 
     for (;;) {
         if (offset <= 0x7FFFFFFF) {
-            return onSeek(pUserData, (int)offset, drwav_seek_origin_current);
+            return onSeek(pUserData, (int) offset, drwav_seek_origin_current);
         }
 
         if (!onSeek(pUserData, 0x7FFFFFFF, drwav_seek_origin_current)) {
@@ -1621,19 +1723,23 @@ static drwav_bool32 drwav__seek_from_start(drwav_seek_proc onSeek, drwav_uint64
     /*return DRWAV_TRUE; */
 }
 
-
-static drwav_bool32 drwav__read_fmt(drwav_read_proc onRead, drwav_seek_proc onSeek, void* pUserData, drwav_container container, drwav_uint64* pRunningBytesReadOut, drwav_fmt* fmtOut)
-{
+static drwav_bool32 drwav__read_fmt(drwav_read_proc onRead,
+                                    drwav_seek_proc onSeek,
+                                    void *          pUserData,
+                                    drwav_container container,
+                                    drwav_uint64 *  pRunningBytesReadOut,
+                                    drwav_fmt *     fmtOut) {
     drwav_chunk_header header;
-    drwav_uint8 fmt[16];
+    drwav_uint8        fmt[16];
 
     if (drwav__read_chunk_header(onRead, pUserData, container, pRunningBytesReadOut, &header) != DRWAV_SUCCESS) {
         return DRWAV_FALSE;
     }
 
-
     /* Skip non-fmt chunks. */
-    while (((container == drwav_container_riff || container == drwav_container_rf64) && !drwav__fourcc_equal(header.id.fourcc, "fmt ")) || (container == drwav_container_w64 && !drwav__guid_equal(header.id.guid, drwavGUID_W64_FMT))) {
+    while (((container == drwav_container_riff || container == drwav_container_rf64) &&
+            !drwav__fourcc_equal(header.id.fourcc, "fmt ")) ||
+           (container == drwav_container_w64 && !drwav__guid_equal(header.id.guid, drwavGUID_W64_FMT))) {
         if (!drwav__seek_forward(onSeek, header.sizeInBytes + header.paddingSize, pUserData)) {
             return DRWAV_FALSE;
         }
@@ -1645,7 +1751,6 @@ static drwav_bool32 drwav__read_fmt(drwav_read_proc onRead, drwav_seek_proc onSe
         }
     }
 
-
     /* Validation. */
     if (container == drwav_container_riff || container == drwav_container_rf64) {
         if (!drwav__fourcc_equal(header.id.fourcc, "fmt ")) {
@@ -1657,7 +1762,6 @@ static drwav_bool32 drwav__read_fmt(drwav_read_proc onRead, drwav_seek_proc onSe
         }
     }
 
-
     if (onRead(pUserData, fmt, sizeof(fmt)) != sizeof(fmt)) {
         return DRWAV_FALSE;
     }
@@ -1677,10 +1781,10 @@ static drwav_bool32 drwav__read_fmt(drwav_read_proc onRead, drwav_seek_proc onSe
 
     if (header.sizeInBytes > 16) {
         drwav_uint8 fmt_cbSize[2];
-        int bytesReadSoFar = 0;
+        int         bytesReadSoFar = 0;
 
         if (onRead(pUserData, fmt_cbSize, sizeof(fmt_cbSize)) != sizeof(fmt_cbSize)) {
-            return DRWAV_FALSE;    /* Expecting more data. */
+            return DRWAV_FALSE; /* Expecting more data. */
         }
         *pRunningBytesReadOut += sizeof(fmt_cbSize);
 
@@ -1698,7 +1802,7 @@ static drwav_bool32 drwav__read_fmt(drwav_read_proc onRead, drwav_seek_proc onSe
             if (fmtOut->formatTag == DR_WAVE_FORMAT_EXTENSIBLE) {
                 drwav_uint8 fmtext[22];
                 if (onRead(pUserData, fmtext, fmtOut->extendedSize) != fmtOut->extendedSize) {
-                    return DRWAV_FALSE;    /* Expecting more data. */
+                    return DRWAV_FALSE; /* Expecting more data. */
                 }
 
                 fmtOut->validBitsPerSample = drwav__bytes_to_u16(fmtext + 0);
@@ -1715,7 +1819,7 @@ static drwav_bool32 drwav__read_fmt(drwav_read_proc onRead, drwav_seek_proc onSe
         }
 
         /* Seek past any leftover bytes. For w64 the leftover will be defined based on the chunk size. */
-        if (!onSeek(pUserData, (int)(header.sizeInBytes - bytesReadSoFar), drwav_seek_origin_current)) {
+        if (!onSeek(pUserData, (int) (header.sizeInBytes - bytesReadSoFar), drwav_seek_origin_current)) {
             return DRWAV_FALSE;
         }
         *pRunningBytesReadOut += (header.sizeInBytes - bytesReadSoFar);
@@ -1731,9 +1835,11 @@ static drwav_bool32 drwav__read_fmt(drwav_read_proc onRead, drwav_seek_proc onSe
     return DRWAV_TRUE;
 }
 
-
-static size_t drwav__on_read(drwav_read_proc onRead, void* pUserData, void* pBufferOut, size_t bytesToRead, drwav_uint64* pCursor)
-{
+static size_t drwav__on_read(drwav_read_proc onRead,
+                             void *          pUserData,
+                             void *          pBufferOut,
+                             size_t          bytesToRead,
+                             drwav_uint64 *  pCursor) {
     size_t bytesRead;
 
     DRWAV_ASSERT(onRead != NULL);
@@ -1744,7 +1850,7 @@ static size_t drwav__on_read(drwav_read_proc onRead, void* pUserData, void* pBuf
     return bytesRead;
 }
 
-#if 0
+#        if 0
 static drwav_bool32 drwav__on_seek(drwav_seek_proc onSeek, void* pUserData, int offset, drwav_seek_origin origin, drwav_uint64* pCursor)
 {
     DRWAV_ASSERT(onSeek != NULL);
@@ -1762,12 +1868,9 @@ static drwav_bool32 drwav__on_seek(drwav_seek_proc onSeek, void* pUserData, int
 
     return DRWAV_TRUE;
 }
-#endif
-
+#        endif
 
-
-static drwav_uint32 drwav_get_bytes_per_pcm_frame(drwav* pWav)
-{
+static drwav_uint32 drwav_get_bytes_per_pcm_frame(drwav * pWav) {
     /*
     The bytes per frame is a bit ambiguous. It can be either be based on the bits per sample, or the block align. The way I'm doing it here
     is that if the bits per sample is a multiple of 8, use floor(bitsPerSample*channels/8), otherwise fall back to the block align.
@@ -1780,8 +1883,7 @@ static drwav_uint32 drwav_get_bytes_per_pcm_frame(drwav* pWav)
     }
 }
 
-DRWAV_API drwav_uint16 drwav_fmt_get_format(const drwav_fmt* pFMT)
-{
+DRWAV_API drwav_uint16 drwav_fmt_get_format(const drwav_fmt * pFMT) {
     if (pFMT == NULL) {
         return 0;
     }
@@ -1789,44 +1891,52 @@ DRWAV_API drwav_uint16 drwav_fmt_get_format(const drwav_fmt* pFMT)
     if (pFMT->formatTag != DR_WAVE_FORMAT_EXTENSIBLE) {
         return pFMT->formatTag;
     } else {
-        return drwav__bytes_to_u16(pFMT->subFormat);    /* Only the first two bytes are required. */
+        return drwav__bytes_to_u16(pFMT->subFormat); /* Only the first two bytes are required. */
     }
 }
 
-static drwav_bool32 drwav_preinit(drwav* pWav, drwav_read_proc onRead, drwav_seek_proc onSeek, void* pReadSeekUserData, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
+static drwav_bool32 drwav_preinit(drwav *                            pWav,
+                                  drwav_read_proc                    onRead,
+                                  drwav_seek_proc                    onSeek,
+                                  void *                             pReadSeekUserData,
+                                  const drwav_allocation_callbacks * pAllocationCallbacks) {
     if (pWav == NULL || onRead == NULL || onSeek == NULL) {
         return DRWAV_FALSE;
     }
 
     DRWAV_ZERO_MEMORY(pWav, sizeof(*pWav));
-    pWav->onRead    = onRead;
-    pWav->onSeek    = onSeek;
-    pWav->pUserData = pReadSeekUserData;
+    pWav->onRead              = onRead;
+    pWav->onSeek              = onSeek;
+    pWav->pUserData           = pReadSeekUserData;
     pWav->allocationCallbacks = drwav_copy_allocation_callbacks_or_defaults(pAllocationCallbacks);
 
-    if (pWav->allocationCallbacks.onFree == NULL || (pWav->allocationCallbacks.onMalloc == NULL && pWav->allocationCallbacks.onRealloc == NULL)) {
-        return DRWAV_FALSE;    /* Invalid allocation callbacks. */
+    if (pWav->allocationCallbacks.onFree == NULL ||
+        (pWav->allocationCallbacks.onMalloc == NULL && pWav->allocationCallbacks.onRealloc == NULL)) {
+        return DRWAV_FALSE; /* Invalid allocation callbacks. */
     }
 
     return DRWAV_TRUE;
 }
 
-static drwav_bool32 drwav_init__internal(drwav* pWav, drwav_chunk_proc onChunk, void* pChunkUserData, drwav_uint32 flags)
-{
+static drwav_bool32 drwav_init__internal(drwav *          pWav,
+                                         drwav_chunk_proc onChunk,
+                                         void *           pChunkUserData,
+                                         drwav_uint32     flags) {
     /* This function assumes drwav_preinit() has been called beforehand. */
 
-    drwav_uint64 cursor;    /* <-- Keeps track of the byte position so we can seek to specific locations. */
-    drwav_bool32 sequential;
-    drwav_uint8 riff[4];
-    drwav_fmt fmt;
+    drwav_uint64   cursor; /* <-- Keeps track of the byte position so we can seek to specific locations. */
+    drwav_bool32   sequential;
+    drwav_uint8    riff[4];
+    drwav_fmt      fmt;
     unsigned short translatedFormatTag;
-    drwav_bool32 foundDataChunk;
-    drwav_uint64 dataChunkSize = 0; /* <-- Important! Don't explicitly set this to 0 anywhere else. Calculation of the size of the data chunk is performed in different paths depending on the container. */
-    drwav_uint64 sampleCountFromFactChunk = 0;  /* Same as dataChunkSize - make sure this is the only place this is initialized to 0. */
+    drwav_bool32   foundDataChunk;
+    drwav_uint64   dataChunkSize =
+        0; /* <-- Important! Don't explicitly set this to 0 anywhere else. Calculation of the size of the data chunk is performed in different paths depending on the container. */
+    drwav_uint64 sampleCountFromFactChunk =
+        0; /* Same as dataChunkSize - make sure this is the only place this is initialized to 0. */
     drwav_uint64 chunkSize;
 
-    cursor = 0;
+    cursor     = 0;
     sequential = (flags & DRWAV_SEQUENTIAL) != 0;
 
     /* The first 4 bytes should be the RIFF identifier. */
@@ -1841,7 +1951,7 @@ static drwav_bool32 drwav_init__internal(drwav* pWav, drwav_chunk_proc onChunk,
     if (drwav__fourcc_equal(riff, "RIFF")) {
         pWav->container = drwav_container_riff;
     } else if (drwav__fourcc_equal(riff, "riff")) {
-        int i;
+        int         i;
         drwav_uint8 riff2[12];
 
         pWav->container = drwav_container_w64;
@@ -1852,33 +1962,33 @@ static drwav_bool32 drwav_init__internal(drwav* pWav, drwav_chunk_proc onChunk,
         }
 
         for (i = 0; i < 12; ++i) {
-            if (riff2[i] != drwavGUID_W64_RIFF[i+4]) {
+            if (riff2[i] != drwavGUID_W64_RIFF[i + 4]) {
                 return DRWAV_FALSE;
             }
         }
     } else if (drwav__fourcc_equal(riff, "RF64")) {
         pWav->container = drwav_container_rf64;
     } else {
-        return DRWAV_FALSE;   /* Unknown or unsupported container. */
+        return DRWAV_FALSE; /* Unknown or unsupported container. */
     }
 
-
     if (pWav->container == drwav_container_riff || pWav->container == drwav_container_rf64) {
         drwav_uint8 chunkSizeBytes[4];
         drwav_uint8 wave[4];
 
         /* RIFF/WAVE */
-        if (drwav__on_read(pWav->onRead, pWav->pUserData, chunkSizeBytes, sizeof(chunkSizeBytes), &cursor) != sizeof(chunkSizeBytes)) {
+        if (drwav__on_read(pWav->onRead, pWav->pUserData, chunkSizeBytes, sizeof(chunkSizeBytes), &cursor) !=
+            sizeof(chunkSizeBytes)) {
             return DRWAV_FALSE;
         }
 
         if (pWav->container == drwav_container_riff) {
             if (drwav__bytes_to_u32(chunkSizeBytes) < 36) {
-                return DRWAV_FALSE;    /* Chunk size should always be at least 36 bytes. */
+                return DRWAV_FALSE; /* Chunk size should always be at least 36 bytes. */
             }
         } else {
             if (drwav__bytes_to_u32(chunkSizeBytes) != 0xFFFFFFFF) {
-                return DRWAV_FALSE;    /* Chunk size should always be set to -1/0xFFFFFFFF for RF64. The actual size is retrieved later. */
+                return DRWAV_FALSE; /* Chunk size should always be set to -1/0xFFFFFFFF for RF64. The actual size is retrieved later. */
             }
         }
 
@@ -1887,14 +1997,15 @@ static drwav_bool32 drwav_init__internal(drwav* pWav, drwav_chunk_proc onChunk,
         }
 
         if (!drwav__fourcc_equal(wave, "WAVE")) {
-            return DRWAV_FALSE;    /* Expecting "WAVE". */
+            return DRWAV_FALSE; /* Expecting "WAVE". */
         }
     } else {
         drwav_uint8 chunkSizeBytes[8];
         drwav_uint8 wave[16];
 
         /* W64 */
-        if (drwav__on_read(pWav->onRead, pWav->pUserData, chunkSizeBytes, sizeof(chunkSizeBytes), &cursor) != sizeof(chunkSizeBytes)) {
+        if (drwav__on_read(pWav->onRead, pWav->pUserData, chunkSizeBytes, sizeof(chunkSizeBytes), &cursor) !=
+            sizeof(chunkSizeBytes)) {
             return DRWAV_FALSE;
         }
 
@@ -1911,13 +2022,13 @@ static drwav_bool32 drwav_init__internal(drwav* pWav, drwav_chunk_proc onChunk,
         }
     }
 
-
     /* For RF64, the "ds64" chunk must come next, before the "fmt " chunk. */
     if (pWav->container == drwav_container_rf64) {
-        drwav_uint8 sizeBytes[8];
-        drwav_uint64 bytesRemainingInChunk;
+        drwav_uint8        sizeBytes[8];
+        drwav_uint64       bytesRemainingInChunk;
         drwav_chunk_header header;
-        drwav_result result = drwav__read_chunk_header(pWav->onRead, pWav->pUserData, pWav->container, &cursor, &header);
+        drwav_result       result =
+            drwav__read_chunk_header(pWav->onRead, pWav->pUserData, pWav->container, &cursor, &header);
         if (result != DRWAV_SUCCESS) {
             return DRWAV_FALSE;
         }
@@ -1935,7 +2046,6 @@ static drwav_bool32 drwav_init__internal(drwav* pWav, drwav_chunk_proc onChunk,
         bytesRemainingInChunk -= 8;
         cursor += 8;
 
-
         /* Next 8 bytes is the size of the "data" chunk. */
         if (drwav__on_read(pWav->onRead, pWav->pUserData, sizeBytes, sizeof(sizeBytes), &cursor) != sizeof(sizeBytes)) {
             return DRWAV_FALSE;
@@ -1943,7 +2053,6 @@ static drwav_bool32 drwav_init__internal(drwav* pWav, drwav_chunk_proc onChunk,
         bytesRemainingInChunk -= 8;
         dataChunkSize = drwav__bytes_to_u64(sizeBytes);
 
-
         /* Next 8 bytes is the same count which we would usually derived from the FACT chunk if it was available. */
         if (drwav__on_read(pWav->onRead, pWav->pUserData, sizeBytes, sizeof(sizeBytes), &cursor) != sizeof(sizeBytes)) {
             return DRWAV_FALSE;
@@ -1951,7 +2060,6 @@ static drwav_bool32 drwav_init__internal(drwav* pWav, drwav_chunk_proc onChunk,
         bytesRemainingInChunk -= 8;
         sampleCountFromFactChunk = drwav__bytes_to_u64(sizeBytes);
 
-
         /* Skip over everything else. */
         if (!drwav__seek_forward(pWav->onSeek, bytesRemainingInChunk, pWav->pUserData)) {
             return DRWAV_FALSE;
@@ -1959,28 +2067,24 @@ static drwav_bool32 drwav_init__internal(drwav* pWav, drwav_chunk_proc onChunk,
         cursor += bytesRemainingInChunk;
     }
 
-
     /* The next bytes should be the "fmt " chunk. */
     if (!drwav__read_fmt(pWav->onRead, pWav->onSeek, pWav->pUserData, pWav->container, &cursor, &fmt)) {
-        return DRWAV_FALSE;    /* Failed to read the "fmt " chunk. */
+        return DRWAV_FALSE; /* Failed to read the "fmt " chunk. */
     }
 
     /* Basic validation. */
-    if ((fmt.sampleRate    == 0 || fmt.sampleRate    > DRWAV_MAX_SAMPLE_RATE)     ||
-        (fmt.channels      == 0 || fmt.channels      > DRWAV_MAX_CHANNELS)        ||
-        (fmt.bitsPerSample == 0 || fmt.bitsPerSample > DRWAV_MAX_BITS_PER_SAMPLE) ||
-        fmt.blockAlign == 0) {
+    if ((fmt.sampleRate == 0 || fmt.sampleRate > DRWAV_MAX_SAMPLE_RATE) ||
+        (fmt.channels == 0 || fmt.channels > DRWAV_MAX_CHANNELS) ||
+        (fmt.bitsPerSample == 0 || fmt.bitsPerSample > DRWAV_MAX_BITS_PER_SAMPLE) || fmt.blockAlign == 0) {
         return DRWAV_FALSE; /* Probably an invalid WAV file. */
     }
 
-
     /* Translate the internal format. */
     translatedFormatTag = fmt.formatTag;
     if (translatedFormatTag == DR_WAVE_FORMAT_EXTENSIBLE) {
         translatedFormatTag = drwav__bytes_to_u16(fmt.subFormat + 0);
     }
 
-
     /*
     We need to enumerate over each chunk for two reasons:
       1) The "data" chunk may not be the next one
@@ -1991,21 +2095,22 @@ static drwav_bool32 drwav_init__internal(drwav* pWav, drwav_chunk_proc onChunk,
     foundDataChunk = DRWAV_FALSE;
 
     /* The next chunk we care about is the "data" chunk. This is not necessarily the next chunk so we'll need to loop. */
-    for (;;)
-    {
+    for (;;) {
         drwav_chunk_header header;
-        drwav_result result = drwav__read_chunk_header(pWav->onRead, pWav->pUserData, pWav->container, &cursor, &header);
+        drwav_result       result =
+            drwav__read_chunk_header(pWav->onRead, pWav->pUserData, pWav->container, &cursor, &header);
         if (result != DRWAV_SUCCESS) {
             if (!foundDataChunk) {
                 return DRWAV_FALSE;
             } else {
-                break;  /* Probably at the end of the file. Get out of the loop. */
+                break; /* Probably at the end of the file. Get out of the loop. */
             }
         }
 
         /* Tell the client about this chunk. */
         if (!sequential && onChunk != NULL) {
-            drwav_uint64 callbackBytesRead = onChunk(pChunkUserData, pWav->onRead, pWav->onSeek, pWav->pUserData, &header, pWav->container, &fmt);
+            drwav_uint64 callbackBytesRead =
+                onChunk(pChunkUserData, pWav->onRead, pWav->onSeek, pWav->pUserData, &header, pWav->container, &fmt);
 
             /*
             dr_wav may need to read the contents of the chunk, so we now need to seek back to the position before
@@ -2017,7 +2122,6 @@ static drwav_bool32 drwav_init__internal(drwav* pWav, drwav_chunk_proc onChunk,
                 }
             }
         }
-        
 
         if (!foundDataChunk) {
             pWav->dataChunkDataPos = cursor;
@@ -2027,14 +2131,15 @@ static drwav_bool32 drwav_init__internal(drwav* pWav, drwav_chunk_proc onChunk,
         if (pWav->container == drwav_container_riff || pWav->container == drwav_container_rf64) {
             if (drwav__fourcc_equal(header.id.fourcc, "data")) {
                 foundDataChunk = DRWAV_TRUE;
-                if (pWav->container != drwav_container_rf64) {  /* The data chunk size for RF64 will always be set to 0xFFFFFFFF here. It was set to it's true value earlier. */
+                if (pWav->container !=
+                    drwav_container_rf64) { /* The data chunk size for RF64 will always be set to 0xFFFFFFFF here. It was set to it's true value earlier. */
                     dataChunkSize = chunkSize;
                 }
             }
         } else {
             if (drwav__guid_equal(header.id.guid, drwavGUID_W64_DATA)) {
                 foundDataChunk = DRWAV_TRUE;
-                dataChunkSize = chunkSize;
+                dataChunkSize  = chunkSize;
             }
         }
 
@@ -2087,38 +2192,41 @@ static drwav_bool32 drwav_init__internal(drwav* pWav, drwav_chunk_proc onChunk,
         /* "smpl" chunk. */
         if (pWav->container == drwav_container_riff || pWav->container == drwav_container_rf64) {
             if (drwav__fourcc_equal(header.id.fourcc, "smpl")) {
-                drwav_uint8 smplHeaderData[36];    /* 36 = size of the smpl header section, not including the loop data. */
+                drwav_uint8 smplHeaderData[36]; /* 36 = size of the smpl header section, not including the loop data. */
                 if (chunkSize >= sizeof(smplHeaderData)) {
-                    drwav_uint64 bytesJustRead = drwav__on_read(pWav->onRead, pWav->pUserData, smplHeaderData, sizeof(smplHeaderData), &cursor);
+                    drwav_uint64 bytesJustRead =
+                        drwav__on_read(pWav->onRead, pWav->pUserData, smplHeaderData, sizeof(smplHeaderData), &cursor);
                     chunkSize -= bytesJustRead;
 
                     if (bytesJustRead == sizeof(smplHeaderData)) {
                         drwav_uint32 iLoop;
 
-                        pWav->smpl.manufacturer      = drwav__bytes_to_u32(smplHeaderData+0);
-                        pWav->smpl.product           = drwav__bytes_to_u32(smplHeaderData+4);
-                        pWav->smpl.samplePeriod      = drwav__bytes_to_u32(smplHeaderData+8);
-                        pWav->smpl.midiUnityNotes    = drwav__bytes_to_u32(smplHeaderData+12);
-                        pWav->smpl.midiPitchFraction = drwav__bytes_to_u32(smplHeaderData+16);
-                        pWav->smpl.smpteFormat       = drwav__bytes_to_u32(smplHeaderData+20);
-                        pWav->smpl.smpteOffset       = drwav__bytes_to_u32(smplHeaderData+24);
-                        pWav->smpl.numSampleLoops    = drwav__bytes_to_u32(smplHeaderData+28);
-                        pWav->smpl.samplerData       = drwav__bytes_to_u32(smplHeaderData+32);
-
-                        for (iLoop = 0; iLoop < pWav->smpl.numSampleLoops && iLoop < drwav_countof(pWav->smpl.loops); ++iLoop) {
-                            drwav_uint8 smplLoopData[24];  /* 24 = size of a loop section in the smpl chunk. */
-                            bytesJustRead = drwav__on_read(pWav->onRead, pWav->pUserData, smplLoopData, sizeof(smplLoopData), &cursor);
+                        pWav->smpl.manufacturer      = drwav__bytes_to_u32(smplHeaderData + 0);
+                        pWav->smpl.product           = drwav__bytes_to_u32(smplHeaderData + 4);
+                        pWav->smpl.samplePeriod      = drwav__bytes_to_u32(smplHeaderData + 8);
+                        pWav->smpl.midiUnityNotes    = drwav__bytes_to_u32(smplHeaderData + 12);
+                        pWav->smpl.midiPitchFraction = drwav__bytes_to_u32(smplHeaderData + 16);
+                        pWav->smpl.smpteFormat       = drwav__bytes_to_u32(smplHeaderData + 20);
+                        pWav->smpl.smpteOffset       = drwav__bytes_to_u32(smplHeaderData + 24);
+                        pWav->smpl.numSampleLoops    = drwav__bytes_to_u32(smplHeaderData + 28);
+                        pWav->smpl.samplerData       = drwav__bytes_to_u32(smplHeaderData + 32);
+
+                        for (iLoop = 0; iLoop < pWav->smpl.numSampleLoops && iLoop < drwav_countof(pWav->smpl.loops);
+                             ++iLoop) {
+                            drwav_uint8 smplLoopData[24]; /* 24 = size of a loop section in the smpl chunk. */
+                            bytesJustRead = drwav__on_read(pWav->onRead, pWav->pUserData, smplLoopData,
+                                                           sizeof(smplLoopData), &cursor);
                             chunkSize -= bytesJustRead;
 
                             if (bytesJustRead == sizeof(smplLoopData)) {
-                                pWav->smpl.loops[iLoop].cuePointId = drwav__bytes_to_u32(smplLoopData+0);
-                                pWav->smpl.loops[iLoop].type       = drwav__bytes_to_u32(smplLoopData+4);
-                                pWav->smpl.loops[iLoop].start      = drwav__bytes_to_u32(smplLoopData+8);
-                                pWav->smpl.loops[iLoop].end        = drwav__bytes_to_u32(smplLoopData+12);
-                                pWav->smpl.loops[iLoop].fraction   = drwav__bytes_to_u32(smplLoopData+16);
-                                pWav->smpl.loops[iLoop].playCount  = drwav__bytes_to_u32(smplLoopData+20);
+                                pWav->smpl.loops[iLoop].cuePointId = drwav__bytes_to_u32(smplLoopData + 0);
+                                pWav->smpl.loops[iLoop].type       = drwav__bytes_to_u32(smplLoopData + 4);
+                                pWav->smpl.loops[iLoop].start      = drwav__bytes_to_u32(smplLoopData + 8);
+                                pWav->smpl.loops[iLoop].end        = drwav__bytes_to_u32(smplLoopData + 12);
+                                pWav->smpl.loops[iLoop].fraction   = drwav__bytes_to_u32(smplLoopData + 16);
+                                pWav->smpl.loops[iLoop].playCount  = drwav__bytes_to_u32(smplLoopData + 20);
                             } else {
-                                break;  /* Break from the smpl loop for loop. */
+                                break; /* Break from the smpl loop for loop. */
                             }
                         }
                     }
@@ -2159,7 +2267,6 @@ static drwav_bool32 drwav_init__internal(drwav* pWav, drwav_chunk_proc onChunk,
         }
         cursor = pWav->dataChunkDataPos;
     }
-    
 
     /* At this point we should be sitting on the first byte of the raw audio data. */
 
@@ -2186,8 +2293,8 @@ static drwav_bool32 drwav_init__internal(drwav* pWav, drwav_chunk_proc onChunk,
             }
 
             /* We decode two samples per byte. There will be blockCount headers in the data chunk. This is enough to know how to calculate the total PCM frame count. */
-            totalBlockHeaderSizeInBytes = blockCount * (6*fmt.channels);
-            pWav->totalPCMFrameCount = ((dataChunkSize - totalBlockHeaderSizeInBytes) * 2) / fmt.channels;
+            totalBlockHeaderSizeInBytes = blockCount * (6 * fmt.channels);
+            pWav->totalPCMFrameCount    = ((dataChunkSize - totalBlockHeaderSizeInBytes) * 2) / fmt.channels;
         }
         if (pWav->translatedFormatTag == DR_WAVE_FORMAT_DVI_ADPCM) {
             drwav_uint64 totalBlockHeaderSizeInBytes;
@@ -2199,8 +2306,8 @@ static drwav_bool32 drwav_init__internal(drwav* pWav, drwav_chunk_proc onChunk,
             }
 
             /* We decode two samples per byte. There will be blockCount headers in the data chunk. This is enough to know how to calculate the total PCM frame count. */
-            totalBlockHeaderSizeInBytes = blockCount * (4*fmt.channels);
-            pWav->totalPCMFrameCount = ((dataChunkSize - totalBlockHeaderSizeInBytes) * 2) / fmt.channels;
+            totalBlockHeaderSizeInBytes = blockCount * (4 * fmt.channels);
+            pWav->totalPCMFrameCount    = ((dataChunkSize - totalBlockHeaderSizeInBytes) * 2) / fmt.channels;
 
             /* The header includes a decoded sample for each channel which acts as the initial predictor sample. */
             pWav->totalPCMFrameCount += blockCount;
@@ -2214,7 +2321,7 @@ static drwav_bool32 drwav_init__internal(drwav* pWav, drwav_chunk_proc onChunk,
         }
     }
 
-#ifdef DR_WAV_LIBSNDFILE_COMPAT
+#        ifdef DR_WAV_LIBSNDFILE_COMPAT
     /*
     I use libsndfile as a benchmark for testing, however in the version I'm using (from the Windows installer on the libsndfile website),
     it appears the total sample count libsndfile uses for MS-ADPCM is incorrect. It would seem they are computing the total sample count
@@ -2224,25 +2331,37 @@ static drwav_bool32 drwav_init__internal(drwav* pWav, drwav_chunk_proc onChunk,
     correctness tests against libsndfile, and is disabled by default.
     */
     if (pWav->translatedFormatTag == DR_WAVE_FORMAT_ADPCM) {
-        drwav_uint64 blockCount = dataChunkSize / fmt.blockAlign;
-        pWav->totalPCMFrameCount = (((blockCount * (fmt.blockAlign - (6*pWav->channels))) * 2)) / fmt.channels;  /* x2 because two samples per byte. */
+        drwav_uint64 blockCount  = dataChunkSize / fmt.blockAlign;
+        pWav->totalPCMFrameCount = (((blockCount * (fmt.blockAlign - (6 * pWav->channels))) * 2)) /
+                                   fmt.channels; /* x2 because two samples per byte. */
     }
     if (pWav->translatedFormatTag == DR_WAVE_FORMAT_DVI_ADPCM) {
         drwav_uint64 blockCount = dataChunkSize / fmt.blockAlign;
-        pWav->totalPCMFrameCount = (((blockCount * (fmt.blockAlign - (4*pWav->channels))) * 2) + (blockCount * pWav->channels)) / fmt.channels;
+        pWav->totalPCMFrameCount =
+            (((blockCount * (fmt.blockAlign - (4 * pWav->channels))) * 2) + (blockCount * pWav->channels)) /
+            fmt.channels;
     }
-#endif
+#        endif
 
     return DRWAV_TRUE;
 }
 
-DRWAV_API drwav_bool32 drwav_init(drwav* pWav, drwav_read_proc onRead, drwav_seek_proc onSeek, void* pUserData, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
+DRWAV_API drwav_bool32 drwav_init(drwav *                            pWav,
+                                  drwav_read_proc                    onRead,
+                                  drwav_seek_proc                    onSeek,
+                                  void *                             pUserData,
+                                  const drwav_allocation_callbacks * pAllocationCallbacks) {
     return drwav_init_ex(pWav, onRead, onSeek, NULL, pUserData, NULL, 0, pAllocationCallbacks);
 }
 
-DRWAV_API drwav_bool32 drwav_init_ex(drwav* pWav, drwav_read_proc onRead, drwav_seek_proc onSeek, drwav_chunk_proc onChunk, void* pReadSeekUserData, void* pChunkUserData, drwav_uint32 flags, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
+DRWAV_API drwav_bool32 drwav_init_ex(drwav *                            pWav,
+                                     drwav_read_proc                    onRead,
+                                     drwav_seek_proc                    onSeek,
+                                     drwav_chunk_proc                   onChunk,
+                                     void *                             pReadSeekUserData,
+                                     void *                             pChunkUserData,
+                                     drwav_uint32                       flags,
+                                     const drwav_allocation_callbacks * pAllocationCallbacks) {
     if (!drwav_preinit(pWav, onRead, onSeek, pReadSeekUserData, pAllocationCallbacks)) {
         return DRWAV_FALSE;
     }
@@ -2250,41 +2369,39 @@ DRWAV_API drwav_bool32 drwav_init_ex(drwav* pWav, drwav_read_proc onRead, drwav_
     return drwav_init__internal(pWav, onChunk, pChunkUserData, flags);
 }
 
-
-static drwav_uint32 drwav__riff_chunk_size_riff(drwav_uint64 dataChunkSize)
-{
-    drwav_uint64 chunkSize = 4 + 24 + dataChunkSize + drwav__chunk_padding_size_riff(dataChunkSize); /* 4 = "WAVE". 24 = "fmt " chunk. */
+static drwav_uint32 drwav__riff_chunk_size_riff(drwav_uint64 dataChunkSize) {
+    drwav_uint64 chunkSize =
+        4 + 24 + dataChunkSize + drwav__chunk_padding_size_riff(dataChunkSize); /* 4 = "WAVE". 24 = "fmt " chunk. */
     if (chunkSize > 0xFFFFFFFFUL) {
         chunkSize = 0xFFFFFFFFUL;
     }
 
-    return (drwav_uint32)chunkSize; /* Safe cast due to the clamp above. */
+    return (drwav_uint32) chunkSize; /* Safe cast due to the clamp above. */
 }
 
-static drwav_uint32 drwav__data_chunk_size_riff(drwav_uint64 dataChunkSize)
-{
+static drwav_uint32 drwav__data_chunk_size_riff(drwav_uint64 dataChunkSize) {
     if (dataChunkSize <= 0xFFFFFFFFUL) {
-        return (drwav_uint32)dataChunkSize;
+        return (drwav_uint32) dataChunkSize;
     } else {
         return 0xFFFFFFFFUL;
     }
 }
 
-static drwav_uint64 drwav__riff_chunk_size_w64(drwav_uint64 dataChunkSize)
-{
+static drwav_uint64 drwav__riff_chunk_size_w64(drwav_uint64 dataChunkSize) {
     drwav_uint64 dataSubchunkPaddingSize = drwav__chunk_padding_size_w64(dataChunkSize);
 
-    return 80 + 24 + dataChunkSize + dataSubchunkPaddingSize;   /* +24 because W64 includes the size of the GUID and size fields. */
+    return 80 + 24 + dataChunkSize +
+           dataSubchunkPaddingSize; /* +24 because W64 includes the size of the GUID and size fields. */
 }
 
-static drwav_uint64 drwav__data_chunk_size_w64(drwav_uint64 dataChunkSize)
-{
-    return 24 + dataChunkSize;        /* +24 because W64 includes the size of the GUID and size fields. */
+static drwav_uint64 drwav__data_chunk_size_w64(drwav_uint64 dataChunkSize) {
+    return 24 + dataChunkSize; /* +24 because W64 includes the size of the GUID and size fields. */
 }
 
-static drwav_uint64 drwav__riff_chunk_size_rf64(drwav_uint64 dataChunkSize)
-{
-    drwav_uint64 chunkSize = 4 + 36 + 24 + dataChunkSize + drwav__chunk_padding_size_riff(dataChunkSize); /* 4 = "WAVE". 36 = "ds64" chunk. 24 = "fmt " chunk. */
+static drwav_uint64 drwav__riff_chunk_size_rf64(drwav_uint64 dataChunkSize) {
+    drwav_uint64 chunkSize =
+        4 + 36 + 24 + dataChunkSize +
+        drwav__chunk_padding_size_riff(dataChunkSize); /* 4 = "WAVE". 36 = "ds64" chunk. 24 = "fmt " chunk. */
     if (chunkSize > 0xFFFFFFFFUL) {
         chunkSize = 0xFFFFFFFFUL;
     }
@@ -2292,24 +2409,20 @@ static drwav_uint64 drwav__riff_chunk_size_rf64(drwav_uint64 dataChunkSize)
     return chunkSize;
 }
 
-static drwav_uint64 drwav__data_chunk_size_rf64(drwav_uint64 dataChunkSize)
-{
+static drwav_uint64 drwav__data_chunk_size_rf64(drwav_uint64 dataChunkSize) {
     return dataChunkSize;
 }
 
-
-static size_t drwav__write(drwav* pWav, const void* pData, size_t dataSize)
-{
-    DRWAV_ASSERT(pWav          != NULL);
+static size_t drwav__write(drwav * pWav, const void * pData, size_t dataSize) {
+    DRWAV_ASSERT(pWav != NULL);
     DRWAV_ASSERT(pWav->onWrite != NULL);
 
     /* Generic write. Assumes no byte reordering required. */
     return pWav->onWrite(pWav->pUserData, pData, dataSize);
 }
 
-static size_t drwav__write_u16ne_to_le(drwav* pWav, drwav_uint16 value)
-{
-    DRWAV_ASSERT(pWav          != NULL);
+static size_t drwav__write_u16ne_to_le(drwav * pWav, drwav_uint16 value) {
+    DRWAV_ASSERT(pWav != NULL);
     DRWAV_ASSERT(pWav->onWrite != NULL);
 
     if (!drwav__is_little_endian()) {
@@ -2319,9 +2432,8 @@ static size_t drwav__write_u16ne_to_le(drwav* pWav, drwav_uint16 value)
     return drwav__write(pWav, &value, 2);
 }
 
-static size_t drwav__write_u32ne_to_le(drwav* pWav, drwav_uint32 value)
-{
-    DRWAV_ASSERT(pWav          != NULL);
+static size_t drwav__write_u32ne_to_le(drwav * pWav, drwav_uint32 value) {
+    DRWAV_ASSERT(pWav != NULL);
     DRWAV_ASSERT(pWav->onWrite != NULL);
 
     if (!drwav__is_little_endian()) {
@@ -2331,9 +2443,8 @@ static size_t drwav__write_u32ne_to_le(drwav* pWav, drwav_uint32 value)
     return drwav__write(pWav, &value, 4);
 }
 
-static size_t drwav__write_u64ne_to_le(drwav* pWav, drwav_uint64 value)
-{
-    DRWAV_ASSERT(pWav          != NULL);
+static size_t drwav__write_u64ne_to_le(drwav * pWav, drwav_uint64 value) {
+    DRWAV_ASSERT(pWav != NULL);
     DRWAV_ASSERT(pWav->onWrite != NULL);
 
     if (!drwav__is_little_endian()) {
@@ -2343,9 +2454,13 @@ static size_t drwav__write_u64ne_to_le(drwav* pWav, drwav_uint64 value)
     return drwav__write(pWav, &value, 8);
 }
 
-
-static drwav_bool32 drwav_preinit_write(drwav* pWav, const drwav_data_format* pFormat, drwav_bool32 isSequential, drwav_write_proc onWrite, drwav_seek_proc onSeek, void* pUserData, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
+static drwav_bool32 drwav_preinit_write(drwav *                            pWav,
+                                        const drwav_data_format *          pFormat,
+                                        drwav_bool32                       isSequential,
+                                        drwav_write_proc                   onWrite,
+                                        drwav_seek_proc                    onSeek,
+                                        void *                             pUserData,
+                                        const drwav_allocation_callbacks * pAllocationCallbacks) {
     if (pWav == NULL || onWrite == NULL) {
         return DRWAV_FALSE;
     }
@@ -2363,32 +2478,34 @@ static drwav_bool32 drwav_preinit_write(drwav* pWav, const drwav_data_format* pF
     }
 
     DRWAV_ZERO_MEMORY(pWav, sizeof(*pWav));
-    pWav->onWrite   = onWrite;
-    pWav->onSeek    = onSeek;
-    pWav->pUserData = pUserData;
+    pWav->onWrite             = onWrite;
+    pWav->onSeek              = onSeek;
+    pWav->pUserData           = pUserData;
     pWav->allocationCallbacks = drwav_copy_allocation_callbacks_or_defaults(pAllocationCallbacks);
 
-    if (pWav->allocationCallbacks.onFree == NULL || (pWav->allocationCallbacks.onMalloc == NULL && pWav->allocationCallbacks.onRealloc == NULL)) {
-        return DRWAV_FALSE;    /* Invalid allocation callbacks. */
+    if (pWav->allocationCallbacks.onFree == NULL ||
+        (pWav->allocationCallbacks.onMalloc == NULL && pWav->allocationCallbacks.onRealloc == NULL)) {
+        return DRWAV_FALSE; /* Invalid allocation callbacks. */
     }
 
-    pWav->fmt.formatTag = (drwav_uint16)pFormat->format;
-    pWav->fmt.channels = (drwav_uint16)pFormat->channels;
-    pWav->fmt.sampleRate = pFormat->sampleRate;
-    pWav->fmt.avgBytesPerSec = (drwav_uint32)((pFormat->bitsPerSample * pFormat->sampleRate * pFormat->channels) / 8);
-    pWav->fmt.blockAlign = (drwav_uint16)((pFormat->channels * pFormat->bitsPerSample) / 8);
-    pWav->fmt.bitsPerSample = (drwav_uint16)pFormat->bitsPerSample;
-    pWav->fmt.extendedSize = 0;
-    pWav->isSequentialWrite = isSequential;
+    pWav->fmt.formatTag      = (drwav_uint16) pFormat->format;
+    pWav->fmt.channels       = (drwav_uint16) pFormat->channels;
+    pWav->fmt.sampleRate     = pFormat->sampleRate;
+    pWav->fmt.avgBytesPerSec = (drwav_uint32) ((pFormat->bitsPerSample * pFormat->sampleRate * pFormat->channels) / 8);
+    pWav->fmt.blockAlign     = (drwav_uint16) ((pFormat->channels * pFormat->bitsPerSample) / 8);
+    pWav->fmt.bitsPerSample  = (drwav_uint16) pFormat->bitsPerSample;
+    pWav->fmt.extendedSize   = 0;
+    pWav->isSequentialWrite  = isSequential;
 
     return DRWAV_TRUE;
 }
 
-static drwav_bool32 drwav_init_write__internal(drwav* pWav, const drwav_data_format* pFormat, drwav_uint64 totalSampleCount)
-{
+static drwav_bool32 drwav_init_write__internal(drwav *                   pWav,
+                                               const drwav_data_format * pFormat,
+                                               drwav_uint64              totalSampleCount) {
     /* The function assumes drwav_preinit_write() was called beforehand. */
 
-    size_t runningPos = 0;
+    size_t       runningPos           = 0;
     drwav_uint64 initialDataChunkSize = 0;
     drwav_uint64 chunkSizeFMT;
 
@@ -2413,44 +2530,50 @@ static drwav_bool32 drwav_init_write__internal(drwav* pWav, const drwav_data_for
 
     pWav->dataChunkDataSizeTargetWrite = initialDataChunkSize;
 
-
     /* "RIFF" chunk. */
     if (pFormat->container == drwav_container_riff) {
-        drwav_uint32 chunkSizeRIFF = 28 + (drwav_uint32)initialDataChunkSize;   /* +28 = "WAVE" + [sizeof "fmt " chunk] */
+        drwav_uint32 chunkSizeRIFF =
+            28 + (drwav_uint32) initialDataChunkSize; /* +28 = "WAVE" + [sizeof "fmt " chunk] */
         runningPos += drwav__write(pWav, "RIFF", 4);
         runningPos += drwav__write_u32ne_to_le(pWav, chunkSizeRIFF);
         runningPos += drwav__write(pWav, "WAVE", 4);
     } else if (pFormat->container == drwav_container_w64) {
-        drwav_uint64 chunkSizeRIFF = 80 + 24 + initialDataChunkSize;            /* +24 because W64 includes the size of the GUID and size fields. */
+        drwav_uint64 chunkSizeRIFF =
+            80 + 24 + initialDataChunkSize; /* +24 because W64 includes the size of the GUID and size fields. */
         runningPos += drwav__write(pWav, drwavGUID_W64_RIFF, 16);
         runningPos += drwav__write_u64ne_to_le(pWav, chunkSizeRIFF);
         runningPos += drwav__write(pWav, drwavGUID_W64_WAVE, 16);
     } else if (pFormat->container == drwav_container_rf64) {
         runningPos += drwav__write(pWav, "RF64", 4);
-        runningPos += drwav__write_u32ne_to_le(pWav, 0xFFFFFFFF);               /* Always 0xFFFFFFFF for RF64. Set to a proper value in the "ds64" chunk. */
+        runningPos += drwav__write_u32ne_to_le(
+            pWav, 0xFFFFFFFF); /* Always 0xFFFFFFFF for RF64. Set to a proper value in the "ds64" chunk. */
         runningPos += drwav__write(pWav, "WAVE", 4);
     }
 
-    
     /* "ds64" chunk (RF64 only). */
     if (pFormat->container == drwav_container_rf64) {
-        drwav_uint32 initialds64ChunkSize = 28;                                 /* 28 = [Size of RIFF (8 bytes)] + [Size of DATA (8 bytes)] + [Sample Count (8 bytes)] + [Table Length (4 bytes)]. Table length always set to 0. */
-        drwav_uint64 initialRiffChunkSize = 8 + initialds64ChunkSize + initialDataChunkSize;    /* +8 for the ds64 header. */
+        drwav_uint32 initialds64ChunkSize =
+            28; /* 28 = [Size of RIFF (8 bytes)] + [Size of DATA (8 bytes)] + [Sample Count (8 bytes)] + [Table Length (4 bytes)]. Table length always set to 0. */
+        drwav_uint64 initialRiffChunkSize =
+            8 + initialds64ChunkSize + initialDataChunkSize; /* +8 for the ds64 header. */
 
         runningPos += drwav__write(pWav, "ds64", 4);
-        runningPos += drwav__write_u32ne_to_le(pWav, initialds64ChunkSize);     /* Size of ds64. */
-        runningPos += drwav__write_u64ne_to_le(pWav, initialRiffChunkSize);     /* Size of RIFF. Set to true value at the end. */
-        runningPos += drwav__write_u64ne_to_le(pWav, initialDataChunkSize);     /* Size of DATA. Set to true value at the end. */
-        runningPos += drwav__write_u64ne_to_le(pWav, totalSampleCount);         /* Sample count. */
-        runningPos += drwav__write_u32ne_to_le(pWav, 0);                        /* Table length. Always set to zero in our case since we're not doing any other chunks than "DATA". */
+        runningPos += drwav__write_u32ne_to_le(pWav, initialds64ChunkSize); /* Size of ds64. */
+        runningPos +=
+            drwav__write_u64ne_to_le(pWav, initialRiffChunkSize); /* Size of RIFF. Set to true value at the end. */
+        runningPos +=
+            drwav__write_u64ne_to_le(pWav, initialDataChunkSize); /* Size of DATA. Set to true value at the end. */
+        runningPos += drwav__write_u64ne_to_le(pWav, totalSampleCount); /* Sample count. */
+        runningPos += drwav__write_u32ne_to_le(
+            pWav,
+            0); /* Table length. Always set to zero in our case since we're not doing any other chunks than "DATA". */
     }
 
-
     /* "fmt " chunk. */
     if (pFormat->container == drwav_container_riff || pFormat->container == drwav_container_rf64) {
         chunkSizeFMT = 16;
         runningPos += drwav__write(pWav, "fmt ", 4);
-        runningPos += drwav__write_u32ne_to_le(pWav, (drwav_uint32)chunkSizeFMT);
+        runningPos += drwav__write_u32ne_to_le(pWav, (drwav_uint32) chunkSizeFMT);
     } else if (pFormat->container == drwav_container_w64) {
         chunkSizeFMT = 40;
         runningPos += drwav__write(pWav, drwavGUID_W64_FMT, 16);
@@ -2468,16 +2591,19 @@ static drwav_bool32 drwav_init_write__internal(drwav* pWav, const drwav_data_for
 
     /* "data" chunk. */
     if (pFormat->container == drwav_container_riff) {
-        drwav_uint32 chunkSizeDATA = (drwav_uint32)initialDataChunkSize;
+        drwav_uint32 chunkSizeDATA = (drwav_uint32) initialDataChunkSize;
         runningPos += drwav__write(pWav, "data", 4);
         runningPos += drwav__write_u32ne_to_le(pWav, chunkSizeDATA);
     } else if (pFormat->container == drwav_container_w64) {
-        drwav_uint64 chunkSizeDATA = 24 + initialDataChunkSize;     /* +24 because W64 includes the size of the GUID and size fields. */
+        drwav_uint64 chunkSizeDATA =
+            24 + initialDataChunkSize; /* +24 because W64 includes the size of the GUID and size fields. */
         runningPos += drwav__write(pWav, drwavGUID_W64_DATA, 16);
         runningPos += drwav__write_u64ne_to_le(pWav, chunkSizeDATA);
     } else if (pFormat->container == drwav_container_rf64) {
         runningPos += drwav__write(pWav, "data", 4);
-        runningPos += drwav__write_u32ne_to_le(pWav, 0xFFFFFFFF);   /* Always set to 0xFFFFFFFF for RF64. The true size of the data chunk is specified in the ds64 chunk. */
+        runningPos += drwav__write_u32ne_to_le(
+            pWav,
+            0xFFFFFFFF); /* Always set to 0xFFFFFFFF for RF64. The true size of the data chunk is specified in the ds64 chunk. */
     }
 
     /*
@@ -2485,510 +2611,787 @@ static drwav_bool32 drwav_init_write__internal(drwav* pWav, const drwav_data_for
     as a dead store. I'm leaving this as-is for safety just in case I want to expand this function later to include other tags and want to
     keep track of the running position for whatever reason. The line below should silence the static analysis tools.
     */
-    (void)runningPos;
+    (void) runningPos;
 
     /* Set some properties for the client's convenience. */
-    pWav->container = pFormat->container;
-    pWav->channels = (drwav_uint16)pFormat->channels;
-    pWav->sampleRate = pFormat->sampleRate;
-    pWav->bitsPerSample = (drwav_uint16)pFormat->bitsPerSample;
-    pWav->translatedFormatTag = (drwav_uint16)pFormat->format;
+    pWav->container           = pFormat->container;
+    pWav->channels            = (drwav_uint16) pFormat->channels;
+    pWav->sampleRate          = pFormat->sampleRate;
+    pWav->bitsPerSample       = (drwav_uint16) pFormat->bitsPerSample;
+    pWav->translatedFormatTag = (drwav_uint16) pFormat->format;
 
     return DRWAV_TRUE;
 }
 
-
-DRWAV_API drwav_bool32 drwav_init_write(drwav* pWav, const drwav_data_format* pFormat, drwav_write_proc onWrite, drwav_seek_proc onSeek, void* pUserData, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
+DRWAV_API drwav_bool32 drwav_init_write(drwav *                            pWav,
+                                        const drwav_data_format *          pFormat,
+                                        drwav_write_proc                   onWrite,
+                                        drwav_seek_proc                    onSeek,
+                                        void *                             pUserData,
+                                        const drwav_allocation_callbacks * pAllocationCallbacks) {
     if (!drwav_preinit_write(pWav, pFormat, DRWAV_FALSE, onWrite, onSeek, pUserData, pAllocationCallbacks)) {
         return DRWAV_FALSE;
     }
-
-    return drwav_init_write__internal(pWav, pFormat, 0);               /* DRWAV_FALSE = Not Sequential */
-}
-
-DRWAV_API drwav_bool32 drwav_init_write_sequential(drwav* pWav, const drwav_data_format* pFormat, drwav_uint64 totalSampleCount, drwav_write_proc onWrite, void* pUserData, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
-    if (!drwav_preinit_write(pWav, pFormat, DRWAV_TRUE, onWrite, NULL, pUserData, pAllocationCallbacks)) {
-        return DRWAV_FALSE;
+
+    return drwav_init_write__internal(pWav, pFormat, 0); /* DRWAV_FALSE = Not Sequential */
+}
+
+DRWAV_API drwav_bool32 drwav_init_write_sequential(drwav *                            pWav,
+                                                   const drwav_data_format *          pFormat,
+                                                   drwav_uint64                       totalSampleCount,
+                                                   drwav_write_proc                   onWrite,
+                                                   void *                             pUserData,
+                                                   const drwav_allocation_callbacks * pAllocationCallbacks) {
+    if (!drwav_preinit_write(pWav, pFormat, DRWAV_TRUE, onWrite, NULL, pUserData, pAllocationCallbacks)) {
+        return DRWAV_FALSE;
+    }
+
+    return drwav_init_write__internal(pWav, pFormat, totalSampleCount); /* DRWAV_TRUE = Sequential */
+}
+
+DRWAV_API drwav_bool32 drwav_init_write_sequential_pcm_frames(drwav *                            pWav,
+                                                              const drwav_data_format *          pFormat,
+                                                              drwav_uint64                       totalPCMFrameCount,
+                                                              drwav_write_proc                   onWrite,
+                                                              void *                             pUserData,
+                                                              const drwav_allocation_callbacks * pAllocationCallbacks) {
+    if (pFormat == NULL) {
+        return DRWAV_FALSE;
+    }
+
+    return drwav_init_write_sequential(pWav, pFormat, totalPCMFrameCount * pFormat->channels, onWrite, pUserData,
+                                       pAllocationCallbacks);
+}
+
+DRWAV_API drwav_uint64 drwav_target_write_size_bytes(const drwav_data_format * pFormat, drwav_uint64 totalSampleCount) {
+    /* Casting totalSampleCount to drwav_int64 for VC6 compatibility. No issues in practice because nobody is going to exhaust the whole 63 bits. */
+    drwav_uint64 targetDataSizeBytes =
+        (drwav_uint64) ((drwav_int64) totalSampleCount * pFormat->channels * pFormat->bitsPerSample / 8.0);
+    drwav_uint64 riffChunkSizeBytes;
+    drwav_uint64 fileSizeBytes = 0;
+
+    if (pFormat->container == drwav_container_riff) {
+        riffChunkSizeBytes = drwav__riff_chunk_size_riff(targetDataSizeBytes);
+        fileSizeBytes =
+            (8 + riffChunkSizeBytes); /* +8 because WAV doesn't include the size of the ChunkID and ChunkSize fields. */
+    } else if (pFormat->container == drwav_container_w64) {
+        riffChunkSizeBytes = drwav__riff_chunk_size_w64(targetDataSizeBytes);
+        fileSizeBytes      = riffChunkSizeBytes;
+    } else if (pFormat->container == drwav_container_rf64) {
+        riffChunkSizeBytes = drwav__riff_chunk_size_rf64(targetDataSizeBytes);
+        fileSizeBytes =
+            (8 + riffChunkSizeBytes); /* +8 because WAV doesn't include the size of the ChunkID and ChunkSize fields. */
+    }
+
+    return fileSizeBytes;
+}
+
+#        ifndef DR_WAV_NO_STDIO
+
+/* drwav_result_from_errno() is only used for fopen() and wfopen() so putting it inside DR_WAV_NO_STDIO for now. If something else needs this later we can move it out. */
+#            include <errno.h>
+
+static drwav_result drwav_result_from_errno(int e) {
+    // [jart] errno toil
+    if (e == 0) {
+        return DRWAV_SUCCESS;
+    }
+#            ifdef EPERM
+    if (e == EPERM) {
+        return DRWAV_INVALID_OPERATION;
+    }
+#            endif
+#            ifdef ENOENT
+    if (e == ENOENT) {
+        return DRWAV_DOES_NOT_EXIST;
+    }
+#            endif
+#            ifdef ESRCH
+    if (e == ESRCH) {
+        return DRWAV_DOES_NOT_EXIST;
+    }
+#            endif
+#            ifdef EINTR
+    if (e == EINTR) {
+        return DRWAV_INTERRUPT;
+    }
+#            endif
+#            ifdef EIO
+    if (e == EIO) {
+        return DRWAV_IO_ERROR;
+    }
+#            endif
+#            ifdef ENXIO
+    if (e == ENXIO) {
+        return DRWAV_DOES_NOT_EXIST;
+    }
+#            endif
+#            ifdef E2BIG
+    if (e == E2BIG) {
+        return DRWAV_INVALID_ARGS;
+    }
+#            endif
+#            ifdef ENOEXEC
+    if (e == ENOEXEC) {
+        return DRWAV_INVALID_FILE;
+    }
+#            endif
+#            ifdef EBADF
+    if (e == EBADF) {
+        return DRWAV_INVALID_FILE;
+    }
+#            endif
+#            ifdef ECHILD
+    if (e == ECHILD) {
+        return DRWAV_ERROR;
+    }
+#            endif
+#            ifdef EAGAIN
+    if (e == EAGAIN) {
+        return DRWAV_UNAVAILABLE;
+    }
+#            endif
+#            ifdef ENOMEM
+    if (e == ENOMEM) {
+        return DRWAV_OUT_OF_MEMORY;
+    }
+#            endif
+#            ifdef EACCES
+    if (e == EACCES) {
+        return DRWAV_ACCESS_DENIED;
+    }
+#            endif
+#            ifdef EFAULT
+    if (e == EFAULT) {
+        return DRWAV_BAD_ADDRESS;
+    }
+#            endif
+#            ifdef ENOTBLK
+    if (e == ENOTBLK) {
+        return DRWAV_ERROR;
+    }
+#            endif
+#            ifdef EBUSY
+    if (e == EBUSY) {
+        return DRWAV_BUSY;
+    }
+#            endif
+#            ifdef EEXIST
+    if (e == EEXIST) {
+        return DRWAV_ALREADY_EXISTS;
+    }
+#            endif
+#            ifdef EXDEV
+    if (e == EXDEV) {
+        return DRWAV_ERROR;
+    }
+#            endif
+#            ifdef ENODEV
+    if (e == ENODEV) {
+        return DRWAV_DOES_NOT_EXIST;
+    }
+#            endif
+#            ifdef ENOTDIR
+    if (e == ENOTDIR) {
+        return DRWAV_NOT_DIRECTORY;
+    }
+#            endif
+#            ifdef EISDIR
+    if (e == EISDIR) {
+        return DRWAV_IS_DIRECTORY;
+    }
+#            endif
+#            ifdef EINVAL
+    if (e == EINVAL) {
+        return DRWAV_INVALID_ARGS;
+    }
+#            endif
+#            ifdef ENFILE
+    if (e == ENFILE) {
+        return DRWAV_TOO_MANY_OPEN_FILES;
+    }
+#            endif
+#            ifdef EMFILE
+    if (e == EMFILE) {
+        return DRWAV_TOO_MANY_OPEN_FILES;
+    }
+#            endif
+#            ifdef ENOTTY
+    if (e == ENOTTY) {
+        return DRWAV_INVALID_OPERATION;
+    }
+#            endif
+#            ifdef ETXTBSY
+    if (e == ETXTBSY) {
+        return DRWAV_BUSY;
+    }
+#            endif
+#            ifdef EFBIG
+    if (e == EFBIG) {
+        return DRWAV_TOO_BIG;
+    }
+#            endif
+#            ifdef ENOSPC
+    if (e == ENOSPC) {
+        return DRWAV_NO_SPACE;
+    }
+#            endif
+#            ifdef ESPIPE
+    if (e == ESPIPE) {
+        return DRWAV_BAD_SEEK;
+    }
+#            endif
+#            ifdef EROFS
+    if (e == EROFS) {
+        return DRWAV_ACCESS_DENIED;
+    }
+#            endif
+#            ifdef EMLINK
+    if (e == EMLINK) {
+        return DRWAV_TOO_MANY_LINKS;
+    }
+#            endif
+#            ifdef EPIPE
+    if (e == EPIPE) {
+        return DRWAV_BAD_PIPE;
+    }
+#            endif
+#            ifdef EDOM
+    if (e == EDOM) {
+        return DRWAV_OUT_OF_RANGE;
+    }
+#            endif
+#            ifdef ERANGE
+    if (e == ERANGE) {
+        return DRWAV_OUT_OF_RANGE;
+    }
+#            endif
+#            ifdef EDEADLK
+    if (e == EDEADLK) {
+        return DRWAV_DEADLOCK;
+    }
+#            endif
+#            ifdef ENAMETOOLONG
+    if (e == ENAMETOOLONG) {
+        return DRWAV_PATH_TOO_LONG;
+    }
+#            endif
+#            ifdef ENOLCK
+    if (e == ENOLCK) {
+        return DRWAV_ERROR;
+    }
+#            endif
+#            ifdef ENOSYS
+    if (e == ENOSYS) {
+        return DRWAV_NOT_IMPLEMENTED;
+    }
+#            endif
+#            ifdef ENOTEMPTY
+    if (e == ENOTEMPTY) {
+        return DRWAV_DIRECTORY_NOT_EMPTY;
+    }
+#            endif
+#            ifdef ELOOP
+    if (e == ELOOP) {
+        return DRWAV_TOO_MANY_LINKS;
+    }
+#            endif
+#            ifdef ENOMSG
+    if (e == ENOMSG) {
+        return DRWAV_NO_MESSAGE;
+    }
+#            endif
+#            ifdef EIDRM
+    if (e == EIDRM) {
+        return DRWAV_ERROR;
+    }
+#            endif
+#            ifdef ECHRNG
+    if (e == ECHRNG) {
+        return DRWAV_ERROR;
+    }
+#            endif
+#            ifdef EL2NSYNC
+    if (e == EL2NSYNC) {
+        return DRWAV_ERROR;
+    }
+#            endif
+#            ifdef EL3HLT
+    if (e == EL3HLT) {
+        return DRWAV_ERROR;
+    }
+#            endif
+#            ifdef EL3RST
+    if (e == EL3RST) {
+        return DRWAV_ERROR;
+    }
+#            endif
+#            ifdef ELNRNG
+    if (e == ELNRNG) {
+        return DRWAV_OUT_OF_RANGE;
+    }
+#            endif
+#            ifdef EUNATCH
+    if (e == EUNATCH) {
+        return DRWAV_ERROR;
+    }
+#            endif
+#            ifdef ENOCSI
+    if (e == ENOCSI) {
+        return DRWAV_ERROR;
+    }
+#            endif
+#            ifdef EL2HLT
+    if (e == EL2HLT) {
+        return DRWAV_ERROR;
+    }
+#            endif
+#            ifdef EBADE
+    if (e == EBADE) {
+        return DRWAV_ERROR;
+    }
+#            endif
+#            ifdef EBADR
+    if (e == EBADR) {
+        return DRWAV_ERROR;
+    }
+#            endif
+#            ifdef EXFULL
+    if (e == EXFULL) {
+        return DRWAV_ERROR;
+    }
+#            endif
+#            ifdef ENOANO
+    if (e == ENOANO) {
+        return DRWAV_ERROR;
+    }
+#            endif
+#            ifdef EBADRQC
+    if (e == EBADRQC) {
+        return DRWAV_ERROR;
+    }
+#            endif
+#            ifdef EBADSLT
+    if (e == EBADSLT) {
+        return DRWAV_ERROR;
+    }
+#            endif
+#            ifdef EBFONT
+    if (e == EBFONT) {
+        return DRWAV_INVALID_FILE;
+    }
+#            endif
+#            ifdef ENOSTR
+    if (e == ENOSTR) {
+        return DRWAV_ERROR;
+    }
+#            endif
+#            ifdef ENODATA
+    if (e == ENODATA) {
+        return DRWAV_NO_DATA_AVAILABLE;
+    }
+#            endif
+#            ifdef ETIME
+    if (e == ETIME) {
+        return DRWAV_TIMEOUT;
+    }
+#            endif
+#            ifdef ENOSR
+    if (e == ENOSR) {
+        return DRWAV_NO_DATA_AVAILABLE;
+    }
+#            endif
+#            ifdef ENONET
+    if (e == ENONET) {
+        return DRWAV_NO_NETWORK;
+    }
+#            endif
+#            ifdef ENOPKG
+    if (e == ENOPKG) {
+        return DRWAV_ERROR;
+    }
+#            endif
+#            ifdef EREMOTE
+    if (e == EREMOTE) {
+        return DRWAV_ERROR;
+    }
+#            endif
+#            ifdef ENOLINK
+    if (e == ENOLINK) {
+        return DRWAV_ERROR;
+    }
+#            endif
+#            ifdef EADV
+    if (e == EADV) {
+        return DRWAV_ERROR;
+    }
+#            endif
+#            ifdef ESRMNT
+    if (e == ESRMNT) {
+        return DRWAV_ERROR;
+    }
+#            endif
+#            ifdef ECOMM
+    if (e == ECOMM) {
+        return DRWAV_ERROR;
+    }
+#            endif
+#            ifdef EPROTO
+    if (e == EPROTO) {
+        return DRWAV_ERROR;
+    }
+#            endif
+#            ifdef EMULTIHOP
+    if (e == EMULTIHOP) {
+        return DRWAV_ERROR;
+    }
+#            endif
+#            ifdef EDOTDOT
+    if (e == EDOTDOT) {
+        return DRWAV_ERROR;
+    }
+#            endif
+#            ifdef EBADMSG
+    if (e == EBADMSG) {
+        return DRWAV_BAD_MESSAGE;
+    }
+#            endif
+#            ifdef EOVERFLOW
+    if (e == EOVERFLOW) {
+        return DRWAV_TOO_BIG;
+    }
+#            endif
+#            ifdef ENOTUNIQ
+    if (e == ENOTUNIQ) {
+        return DRWAV_NOT_UNIQUE;
+    }
+#            endif
+#            ifdef EBADFD
+    if (e == EBADFD) {
+        return DRWAV_ERROR;
+    }
+#            endif
+#            ifdef EREMCHG
+    if (e == EREMCHG) {
+        return DRWAV_ERROR;
+    }
+#            endif
+#            ifdef ELIBACC
+    if (e == ELIBACC) {
+        return DRWAV_ACCESS_DENIED;
+    }
+#            endif
+#            ifdef ELIBBAD
+    if (e == ELIBBAD) {
+        return DRWAV_INVALID_FILE;
+    }
+#            endif
+#            ifdef ELIBSCN
+    if (e == ELIBSCN) {
+        return DRWAV_INVALID_FILE;
+    }
+#            endif
+#            ifdef ELIBMAX
+    if (e == ELIBMAX) {
+        return DRWAV_ERROR;
+    }
+#            endif
+#            ifdef ELIBEXEC
+    if (e == ELIBEXEC) {
+        return DRWAV_ERROR;
+    }
+#            endif
+#            ifdef EILSEQ
+    if (e == EILSEQ) {
+        return DRWAV_INVALID_DATA;
+    }
+#            endif
+#            ifdef ERESTART
+    if (e == ERESTART) {
+        return DRWAV_ERROR;
+    }
+#            endif
+#            ifdef ESTRPIPE
+    if (e == ESTRPIPE) {
+        return DRWAV_ERROR;
+    }
+#            endif
+#            ifdef EUSERS
+    if (e == EUSERS) {
+        return DRWAV_ERROR;
+    }
+#            endif
+#            ifdef ENOTSOCK
+    if (e == ENOTSOCK) {
+        return DRWAV_NOT_SOCKET;
+    }
+#            endif
+#            ifdef EDESTADDRREQ
+    if (e == EDESTADDRREQ) {
+        return DRWAV_NO_ADDRESS;
+    }
+#            endif
+#            ifdef EMSGSIZE
+    if (e == EMSGSIZE) {
+        return DRWAV_TOO_BIG;
+    }
+#            endif
+#            ifdef EPROTOTYPE
+    if (e == EPROTOTYPE) {
+        return DRWAV_BAD_PROTOCOL;
+    }
+#            endif
+#            ifdef ENOPROTOOPT
+    if (e == ENOPROTOOPT) {
+        return DRWAV_PROTOCOL_UNAVAILABLE;
+    }
+#            endif
+#            ifdef EPROTONOSUPPORT
+    if (e == EPROTONOSUPPORT) {
+        return DRWAV_PROTOCOL_NOT_SUPPORTED;
+    }
+#            endif
+#            ifdef ESOCKTNOSUPPORT
+    if (e == ESOCKTNOSUPPORT) {
+        return DRWAV_SOCKET_NOT_SUPPORTED;
+    }
+#            endif
+#            ifdef EOPNOTSUPP
+    if (e == EOPNOTSUPP) {
+        return DRWAV_INVALID_OPERATION;
+    }
+#            endif
+#            ifdef EPFNOSUPPORT
+    if (e == EPFNOSUPPORT) {
+        return DRWAV_PROTOCOL_FAMILY_NOT_SUPPORTED;
+    }
+#            endif
+#            ifdef EAFNOSUPPORT
+    if (e == EAFNOSUPPORT) {
+        return DRWAV_ADDRESS_FAMILY_NOT_SUPPORTED;
+    }
+#            endif
+#            ifdef EADDRINUSE
+    if (e == EADDRINUSE) {
+        return DRWAV_ALREADY_IN_USE;
+    }
+#            endif
+#            ifdef EADDRNOTAVAIL
+    if (e == EADDRNOTAVAIL) {
+        return DRWAV_ERROR;
+    }
+#            endif
+#            ifdef ENETDOWN
+    if (e == ENETDOWN) {
+        return DRWAV_NO_NETWORK;
+    }
+#            endif
+#            ifdef ENETUNREACH
+    if (e == ENETUNREACH) {
+        return DRWAV_NO_NETWORK;
+    }
+#            endif
+#            ifdef ENETRESET
+    if (e == ENETRESET) {
+        return DRWAV_NO_NETWORK;
+    }
+#            endif
+#            ifdef ECONNABORTED
+    if (e == ECONNABORTED) {
+        return DRWAV_NO_NETWORK;
+    }
+#            endif
+#            ifdef ECONNRESET
+    if (e == ECONNRESET) {
+        return DRWAV_CONNECTION_RESET;
+    }
+#            endif
+#            ifdef ENOBUFS
+    if (e == ENOBUFS) {
+        return DRWAV_NO_SPACE;
+    }
+#            endif
+#            ifdef EISCONN
+    if (e == EISCONN) {
+        return DRWAV_ALREADY_CONNECTED;
+    }
+#            endif
+#            ifdef ENOTCONN
+    if (e == ENOTCONN) {
+        return DRWAV_NOT_CONNECTED;
+    }
+#            endif
+#            ifdef ESHUTDOWN
+    if (e == ESHUTDOWN) {
+        return DRWAV_ERROR;
+    }
+#            endif
+#            ifdef ETOOMANYREFS
+    if (e == ETOOMANYREFS) {
+        return DRWAV_ERROR;
+    }
+#            endif
+#            ifdef ETIMEDOUT
+    if (e == ETIMEDOUT) {
+        return DRWAV_TIMEOUT;
+    }
+#            endif
+#            ifdef ECONNREFUSED
+    if (e == ECONNREFUSED) {
+        return DRWAV_CONNECTION_REFUSED;
+    }
+#            endif
+#            ifdef EHOSTDOWN
+    if (e == EHOSTDOWN) {
+        return DRWAV_NO_HOST;
+    }
+#            endif
+#            ifdef EHOSTUNREACH
+    if (e == EHOSTUNREACH) {
+        return DRWAV_NO_HOST;
+    }
+#            endif
+#            ifdef EALREADY
+    if (e == EALREADY) {
+        return DRWAV_IN_PROGRESS;
+    }
+#            endif
+#            ifdef EINPROGRESS
+    if (e == EINPROGRESS) {
+        return DRWAV_IN_PROGRESS;
+    }
+#            endif
+#            ifdef ESTALE
+    if (e == ESTALE) {
+        return DRWAV_INVALID_FILE;
+    }
+#            endif
+#            ifdef EUCLEAN
+    if (e == EUCLEAN) {
+        return DRWAV_ERROR;
+    }
+#            endif
+#            ifdef ENOTNAM
+    if (e == ENOTNAM) {
+        return DRWAV_ERROR;
+    }
+#            endif
+#            ifdef ENAVAIL
+    if (e == ENAVAIL) {
+        return DRWAV_ERROR;
+    }
+#            endif
+#            ifdef EISNAM
+    if (e == EISNAM) {
+        return DRWAV_ERROR;
+    }
+#            endif
+#            ifdef EREMOTEIO
+    if (e == EREMOTEIO) {
+        return DRWAV_IO_ERROR;
+    }
+#            endif
+#            ifdef EDQUOT
+    if (e == EDQUOT) {
+        return DRWAV_NO_SPACE;
+    }
+#            endif
+#            ifdef ENOMEDIUM
+    if (e == ENOMEDIUM) {
+        return DRWAV_DOES_NOT_EXIST;
+    }
+#            endif
+#            ifdef EMEDIUMTYPE
+    if (e == EMEDIUMTYPE) {
+        return DRWAV_ERROR;
+    }
+#            endif
+#            ifdef ECANCELED
+    if (e == ECANCELED) {
+        return DRWAV_CANCELLED;
+    }
+#            endif
+#            ifdef ENOKEY
+    if (e == ENOKEY) {
+        return DRWAV_ERROR;
+    }
+#            endif
+#            ifdef EKEYEXPIRED
+    if (e == EKEYEXPIRED) {
+        return DRWAV_ERROR;
+    }
+#            endif
+#            ifdef EKEYREVOKED
+    if (e == EKEYREVOKED) {
+        return DRWAV_ERROR;
+    }
+#            endif
+#            ifdef EKEYREJECTED
+    if (e == EKEYREJECTED) {
+        return DRWAV_ERROR;
     }
-
-    return drwav_init_write__internal(pWav, pFormat, totalSampleCount); /* DRWAV_TRUE = Sequential */
-}
-
-DRWAV_API drwav_bool32 drwav_init_write_sequential_pcm_frames(drwav* pWav, const drwav_data_format* pFormat, drwav_uint64 totalPCMFrameCount, drwav_write_proc onWrite, void* pUserData, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
-    if (pFormat == NULL) {
-        return DRWAV_FALSE;
+#            endif
+#            ifdef EOWNERDEAD
+    if (e == EOWNERDEAD) {
+        return DRWAV_ERROR;
     }
-
-    return drwav_init_write_sequential(pWav, pFormat, totalPCMFrameCount*pFormat->channels, onWrite, pUserData, pAllocationCallbacks);
-}
-
-DRWAV_API drwav_uint64 drwav_target_write_size_bytes(const drwav_data_format* pFormat, drwav_uint64 totalSampleCount)
-{
-    /* Casting totalSampleCount to drwav_int64 for VC6 compatibility. No issues in practice because nobody is going to exhaust the whole 63 bits. */
-    drwav_uint64 targetDataSizeBytes = (drwav_uint64)((drwav_int64)totalSampleCount * pFormat->channels * pFormat->bitsPerSample/8.0);
-    drwav_uint64 riffChunkSizeBytes;
-    drwav_uint64 fileSizeBytes = 0;
-
-    if (pFormat->container == drwav_container_riff) {
-        riffChunkSizeBytes = drwav__riff_chunk_size_riff(targetDataSizeBytes);
-        fileSizeBytes = (8 + riffChunkSizeBytes);   /* +8 because WAV doesn't include the size of the ChunkID and ChunkSize fields. */
-    } else if (pFormat->container == drwav_container_w64) {
-        riffChunkSizeBytes = drwav__riff_chunk_size_w64(targetDataSizeBytes);
-        fileSizeBytes = riffChunkSizeBytes;
-    } else if (pFormat->container == drwav_container_rf64) {
-        riffChunkSizeBytes = drwav__riff_chunk_size_rf64(targetDataSizeBytes);
-        fileSizeBytes = (8 + riffChunkSizeBytes);   /* +8 because WAV doesn't include the size of the ChunkID and ChunkSize fields. */
+#            endif
+#            ifdef ENOTRECOVERABLE
+    if (e == ENOTRECOVERABLE) {
+        return DRWAV_ERROR;
     }
-
-    return fileSizeBytes;
-}
-
-
-#ifndef DR_WAV_NO_STDIO
-
-/* drwav_result_from_errno() is only used for fopen() and wfopen() so putting it inside DR_WAV_NO_STDIO for now. If something else needs this later we can move it out. */
-#include <errno.h>
-static drwav_result drwav_result_from_errno(int e)
-{
-    // [jart] errno toil
-    if (e == 0) return DRWAV_SUCCESS;
-    #ifdef EPERM
-    if (e == EPERM) return DRWAV_INVALID_OPERATION;
-    #endif
-    #ifdef ENOENT
-    if (e == ENOENT) return DRWAV_DOES_NOT_EXIST;
-    #endif
-    #ifdef ESRCH
-    if (e == ESRCH) return DRWAV_DOES_NOT_EXIST;
-    #endif
-    #ifdef EINTR
-    if (e == EINTR) return DRWAV_INTERRUPT;
-    #endif
-    #ifdef EIO
-    if (e == EIO) return DRWAV_IO_ERROR;
-    #endif
-    #ifdef ENXIO
-    if (e == ENXIO) return DRWAV_DOES_NOT_EXIST;
-    #endif
-    #ifdef E2BIG
-    if (e == E2BIG) return DRWAV_INVALID_ARGS;
-    #endif
-    #ifdef ENOEXEC
-    if (e == ENOEXEC) return DRWAV_INVALID_FILE;
-    #endif
-    #ifdef EBADF
-    if (e == EBADF) return DRWAV_INVALID_FILE;
-    #endif
-    #ifdef ECHILD
-    if (e == ECHILD) return DRWAV_ERROR;
-    #endif
-    #ifdef EAGAIN
-    if (e == EAGAIN) return DRWAV_UNAVAILABLE;
-    #endif
-    #ifdef ENOMEM
-    if (e == ENOMEM) return DRWAV_OUT_OF_MEMORY;
-    #endif
-    #ifdef EACCES
-    if (e == EACCES) return DRWAV_ACCESS_DENIED;
-    #endif
-    #ifdef EFAULT
-    if (e == EFAULT) return DRWAV_BAD_ADDRESS;
-    #endif
-    #ifdef ENOTBLK
-    if (e == ENOTBLK) return DRWAV_ERROR;
-    #endif
-    #ifdef EBUSY
-    if (e == EBUSY) return DRWAV_BUSY;
-    #endif
-    #ifdef EEXIST
-    if (e == EEXIST) return DRWAV_ALREADY_EXISTS;
-    #endif
-    #ifdef EXDEV
-    if (e == EXDEV) return DRWAV_ERROR;
-    #endif
-    #ifdef ENODEV
-    if (e == ENODEV) return DRWAV_DOES_NOT_EXIST;
-    #endif
-    #ifdef ENOTDIR
-    if (e == ENOTDIR) return DRWAV_NOT_DIRECTORY;
-    #endif
-    #ifdef EISDIR
-    if (e == EISDIR) return DRWAV_IS_DIRECTORY;
-    #endif
-    #ifdef EINVAL
-    if (e == EINVAL) return DRWAV_INVALID_ARGS;
-    #endif
-    #ifdef ENFILE
-    if (e == ENFILE) return DRWAV_TOO_MANY_OPEN_FILES;
-    #endif
-    #ifdef EMFILE
-    if (e == EMFILE) return DRWAV_TOO_MANY_OPEN_FILES;
-    #endif
-    #ifdef ENOTTY
-    if (e == ENOTTY) return DRWAV_INVALID_OPERATION;
-    #endif
-    #ifdef ETXTBSY
-    if (e == ETXTBSY) return DRWAV_BUSY;
-    #endif
-    #ifdef EFBIG
-    if (e == EFBIG) return DRWAV_TOO_BIG;
-    #endif
-    #ifdef ENOSPC
-    if (e == ENOSPC) return DRWAV_NO_SPACE;
-    #endif
-    #ifdef ESPIPE
-    if (e == ESPIPE) return DRWAV_BAD_SEEK;
-    #endif
-    #ifdef EROFS
-    if (e == EROFS) return DRWAV_ACCESS_DENIED;
-    #endif
-    #ifdef EMLINK
-    if (e == EMLINK) return DRWAV_TOO_MANY_LINKS;
-    #endif
-    #ifdef EPIPE
-    if (e == EPIPE) return DRWAV_BAD_PIPE;
-    #endif
-    #ifdef EDOM
-    if (e == EDOM) return DRWAV_OUT_OF_RANGE;
-    #endif
-    #ifdef ERANGE
-    if (e == ERANGE) return DRWAV_OUT_OF_RANGE;
-    #endif
-    #ifdef EDEADLK
-    if (e == EDEADLK) return DRWAV_DEADLOCK;
-    #endif
-    #ifdef ENAMETOOLONG
-    if (e == ENAMETOOLONG) return DRWAV_PATH_TOO_LONG;
-    #endif
-    #ifdef ENOLCK
-    if (e == ENOLCK) return DRWAV_ERROR;
-    #endif
-    #ifdef ENOSYS
-    if (e == ENOSYS) return DRWAV_NOT_IMPLEMENTED;
-    #endif
-    #ifdef ENOTEMPTY
-    if (e == ENOTEMPTY) return DRWAV_DIRECTORY_NOT_EMPTY;
-    #endif
-    #ifdef ELOOP
-    if (e == ELOOP) return DRWAV_TOO_MANY_LINKS;
-    #endif
-    #ifdef ENOMSG
-    if (e == ENOMSG) return DRWAV_NO_MESSAGE;
-    #endif
-    #ifdef EIDRM
-    if (e == EIDRM) return DRWAV_ERROR;
-    #endif
-    #ifdef ECHRNG
-    if (e == ECHRNG) return DRWAV_ERROR;
-    #endif
-    #ifdef EL2NSYNC
-    if (e == EL2NSYNC) return DRWAV_ERROR;
-    #endif
-    #ifdef EL3HLT
-    if (e == EL3HLT) return DRWAV_ERROR;
-    #endif
-    #ifdef EL3RST
-    if (e == EL3RST) return DRWAV_ERROR;
-    #endif
-    #ifdef ELNRNG
-    if (e == ELNRNG) return DRWAV_OUT_OF_RANGE;
-    #endif
-    #ifdef EUNATCH
-    if (e == EUNATCH) return DRWAV_ERROR;
-    #endif
-    #ifdef ENOCSI
-    if (e == ENOCSI) return DRWAV_ERROR;
-    #endif
-    #ifdef EL2HLT
-    if (e == EL2HLT) return DRWAV_ERROR;
-    #endif
-    #ifdef EBADE
-    if (e == EBADE) return DRWAV_ERROR;
-    #endif
-    #ifdef EBADR
-    if (e == EBADR) return DRWAV_ERROR;
-    #endif
-    #ifdef EXFULL
-    if (e == EXFULL) return DRWAV_ERROR;
-    #endif
-    #ifdef ENOANO
-    if (e == ENOANO) return DRWAV_ERROR;
-    #endif
-    #ifdef EBADRQC
-    if (e == EBADRQC) return DRWAV_ERROR;
-    #endif
-    #ifdef EBADSLT
-    if (e == EBADSLT) return DRWAV_ERROR;
-    #endif
-    #ifdef EBFONT
-    if (e == EBFONT) return DRWAV_INVALID_FILE;
-    #endif
-    #ifdef ENOSTR
-    if (e == ENOSTR) return DRWAV_ERROR;
-    #endif
-    #ifdef ENODATA
-    if (e == ENODATA) return DRWAV_NO_DATA_AVAILABLE;
-    #endif
-    #ifdef ETIME
-    if (e == ETIME) return DRWAV_TIMEOUT;
-    #endif
-    #ifdef ENOSR
-    if (e == ENOSR) return DRWAV_NO_DATA_AVAILABLE;
-    #endif
-    #ifdef ENONET
-    if (e == ENONET) return DRWAV_NO_NETWORK;
-    #endif
-    #ifdef ENOPKG
-    if (e == ENOPKG) return DRWAV_ERROR;
-    #endif
-    #ifdef EREMOTE
-    if (e == EREMOTE) return DRWAV_ERROR;
-    #endif
-    #ifdef ENOLINK
-    if (e == ENOLINK) return DRWAV_ERROR;
-    #endif
-    #ifdef EADV
-    if (e == EADV) return DRWAV_ERROR;
-    #endif
-    #ifdef ESRMNT
-    if (e == ESRMNT) return DRWAV_ERROR;
-    #endif
-    #ifdef ECOMM
-    if (e == ECOMM) return DRWAV_ERROR;
-    #endif
-    #ifdef EPROTO
-    if (e == EPROTO) return DRWAV_ERROR;
-    #endif
-    #ifdef EMULTIHOP
-    if (e == EMULTIHOP) return DRWAV_ERROR;
-    #endif
-    #ifdef EDOTDOT
-    if (e == EDOTDOT) return DRWAV_ERROR;
-    #endif
-    #ifdef EBADMSG
-    if (e == EBADMSG) return DRWAV_BAD_MESSAGE;
-    #endif
-    #ifdef EOVERFLOW
-    if (e == EOVERFLOW) return DRWAV_TOO_BIG;
-    #endif
-    #ifdef ENOTUNIQ
-    if (e == ENOTUNIQ) return DRWAV_NOT_UNIQUE;
-    #endif
-    #ifdef EBADFD
-    if (e == EBADFD) return DRWAV_ERROR;
-    #endif
-    #ifdef EREMCHG
-    if (e == EREMCHG) return DRWAV_ERROR;
-    #endif
-    #ifdef ELIBACC
-    if (e == ELIBACC) return DRWAV_ACCESS_DENIED;
-    #endif
-    #ifdef ELIBBAD
-    if (e == ELIBBAD) return DRWAV_INVALID_FILE;
-    #endif
-    #ifdef ELIBSCN
-    if (e == ELIBSCN) return DRWAV_INVALID_FILE;
-    #endif
-    #ifdef ELIBMAX
-    if (e == ELIBMAX) return DRWAV_ERROR;
-    #endif
-    #ifdef ELIBEXEC
-    if (e == ELIBEXEC) return DRWAV_ERROR;
-    #endif
-    #ifdef EILSEQ
-    if (e == EILSEQ) return DRWAV_INVALID_DATA;
-    #endif
-    #ifdef ERESTART
-    if (e == ERESTART) return DRWAV_ERROR;
-    #endif
-    #ifdef ESTRPIPE
-    if (e == ESTRPIPE) return DRWAV_ERROR;
-    #endif
-    #ifdef EUSERS
-    if (e == EUSERS) return DRWAV_ERROR;
-    #endif
-    #ifdef ENOTSOCK
-    if (e == ENOTSOCK) return DRWAV_NOT_SOCKET;
-    #endif
-    #ifdef EDESTADDRREQ
-    if (e == EDESTADDRREQ) return DRWAV_NO_ADDRESS;
-    #endif
-    #ifdef EMSGSIZE
-    if (e == EMSGSIZE) return DRWAV_TOO_BIG;
-    #endif
-    #ifdef EPROTOTYPE
-    if (e == EPROTOTYPE) return DRWAV_BAD_PROTOCOL;
-    #endif
-    #ifdef ENOPROTOOPT
-    if (e == ENOPROTOOPT) return DRWAV_PROTOCOL_UNAVAILABLE;
-    #endif
-    #ifdef EPROTONOSUPPORT
-    if (e == EPROTONOSUPPORT) return DRWAV_PROTOCOL_NOT_SUPPORTED;
-    #endif
-    #ifdef ESOCKTNOSUPPORT
-    if (e == ESOCKTNOSUPPORT) return DRWAV_SOCKET_NOT_SUPPORTED;
-    #endif
-    #ifdef EOPNOTSUPP
-    if (e == EOPNOTSUPP) return DRWAV_INVALID_OPERATION;
-    #endif
-    #ifdef EPFNOSUPPORT
-    if (e == EPFNOSUPPORT) return DRWAV_PROTOCOL_FAMILY_NOT_SUPPORTED;
-    #endif
-    #ifdef EAFNOSUPPORT
-    if (e == EAFNOSUPPORT) return DRWAV_ADDRESS_FAMILY_NOT_SUPPORTED;
-    #endif
-    #ifdef EADDRINUSE
-    if (e == EADDRINUSE) return DRWAV_ALREADY_IN_USE;
-    #endif
-    #ifdef EADDRNOTAVAIL
-    if (e == EADDRNOTAVAIL) return DRWAV_ERROR;
-    #endif
-    #ifdef ENETDOWN
-    if (e == ENETDOWN) return DRWAV_NO_NETWORK;
-    #endif
-    #ifdef ENETUNREACH
-    if (e == ENETUNREACH) return DRWAV_NO_NETWORK;
-    #endif
-    #ifdef ENETRESET
-    if (e == ENETRESET) return DRWAV_NO_NETWORK;
-    #endif
-    #ifdef ECONNABORTED
-    if (e == ECONNABORTED) return DRWAV_NO_NETWORK;
-    #endif
-    #ifdef ECONNRESET
-    if (e == ECONNRESET) return DRWAV_CONNECTION_RESET;
-    #endif
-    #ifdef ENOBUFS
-    if (e == ENOBUFS) return DRWAV_NO_SPACE;
-    #endif
-    #ifdef EISCONN
-    if (e == EISCONN) return DRWAV_ALREADY_CONNECTED;
-    #endif
-    #ifdef ENOTCONN
-    if (e == ENOTCONN) return DRWAV_NOT_CONNECTED;
-    #endif
-    #ifdef ESHUTDOWN
-    if (e == ESHUTDOWN) return DRWAV_ERROR;
-    #endif
-    #ifdef ETOOMANYREFS
-    if (e == ETOOMANYREFS) return DRWAV_ERROR;
-    #endif
-    #ifdef ETIMEDOUT
-    if (e == ETIMEDOUT) return DRWAV_TIMEOUT;
-    #endif
-    #ifdef ECONNREFUSED
-    if (e == ECONNREFUSED) return DRWAV_CONNECTION_REFUSED;
-    #endif
-    #ifdef EHOSTDOWN
-    if (e == EHOSTDOWN) return DRWAV_NO_HOST;
-    #endif
-    #ifdef EHOSTUNREACH
-    if (e == EHOSTUNREACH) return DRWAV_NO_HOST;
-    #endif
-    #ifdef EALREADY
-    if (e == EALREADY) return DRWAV_IN_PROGRESS;
-    #endif
-    #ifdef EINPROGRESS
-    if (e == EINPROGRESS) return DRWAV_IN_PROGRESS;
-    #endif
-    #ifdef ESTALE
-    if (e == ESTALE) return DRWAV_INVALID_FILE;
-    #endif
-    #ifdef EUCLEAN
-    if (e == EUCLEAN) return DRWAV_ERROR;
-    #endif
-    #ifdef ENOTNAM
-    if (e == ENOTNAM) return DRWAV_ERROR;
-    #endif
-    #ifdef ENAVAIL
-    if (e == ENAVAIL) return DRWAV_ERROR;
-    #endif
-    #ifdef EISNAM
-    if (e == EISNAM) return DRWAV_ERROR;
-    #endif
-    #ifdef EREMOTEIO
-    if (e == EREMOTEIO) return DRWAV_IO_ERROR;
-    #endif
-    #ifdef EDQUOT
-    if (e == EDQUOT) return DRWAV_NO_SPACE;
-    #endif
-    #ifdef ENOMEDIUM
-    if (e == ENOMEDIUM) return DRWAV_DOES_NOT_EXIST;
-    #endif
-    #ifdef EMEDIUMTYPE
-    if (e == EMEDIUMTYPE) return DRWAV_ERROR;
-    #endif
-    #ifdef ECANCELED
-    if (e == ECANCELED) return DRWAV_CANCELLED;
-    #endif
-    #ifdef ENOKEY
-    if (e == ENOKEY) return DRWAV_ERROR;
-    #endif
-    #ifdef EKEYEXPIRED
-    if (e == EKEYEXPIRED) return DRWAV_ERROR;
-    #endif
-    #ifdef EKEYREVOKED
-    if (e == EKEYREVOKED) return DRWAV_ERROR;
-    #endif
-    #ifdef EKEYREJECTED
-    if (e == EKEYREJECTED) return DRWAV_ERROR;
-    #endif
-    #ifdef EOWNERDEAD
-    if (e == EOWNERDEAD) return DRWAV_ERROR;
-    #endif
-    #ifdef ENOTRECOVERABLE
-    if (e == ENOTRECOVERABLE) return DRWAV_ERROR;
-    #endif
-    #ifdef ERFKILL
-    if (e == ERFKILL) return DRWAV_ERROR;
-    #endif
-    #ifdef EHWPOISON
-    if (e == EHWPOISON) return DRWAV_ERROR;
-    #endif
+#            endif
+#            ifdef ERFKILL
+    if (e == ERFKILL) {
+        return DRWAV_ERROR;
+    }
+#            endif
+#            ifdef EHWPOISON
+    if (e == EHWPOISON) {
+        return DRWAV_ERROR;
+    }
+#            endif
     return DRWAV_ERROR;
 }
 
-static drwav_result drwav_fopen(FILE** ppFile, const char* pFilePath, const char* pOpenMode)
-{
-#if _MSC_VER && _MSC_VER >= 1400
+static drwav_result drwav_fopen(FILE ** ppFile, const char * pFilePath, const char * pOpenMode) {
+#            if _MSC_VER && _MSC_VER >= 1400
     errno_t err;
-#endif
+#            endif
 
     if (ppFile != NULL) {
-        *ppFile = NULL;  /* Safety. */
+        *ppFile = NULL; /* Safety. */
     }
 
     if (pFilePath == NULL || pOpenMode == NULL || ppFile == NULL) {
         return DRWAV_INVALID_ARGS;
     }
 
-#if _MSC_VER && _MSC_VER >= 1400
+#            if _MSC_VER && _MSC_VER >= 1400
     err = fopen_s(ppFile, pFilePath, pOpenMode);
     if (err != 0) {
         return drwav_result_from_errno(err);
     }
-#else
-#if defined(_WIN32) || defined(__APPLE__)
+#            else
+#                if defined(_WIN32) || defined(__APPLE__)
+    *ppFile = fopen(pFilePath, pOpenMode);
+#                else
+#                    if defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS == 64 && defined(_LARGEFILE64_SOURCE)
+    *ppFile = fopen64(pFilePath, pOpenMode);
+#                    else
     *ppFile = fopen(pFilePath, pOpenMode);
-#else
-    #if defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS == 64 && defined(_LARGEFILE64_SOURCE)
-        *ppFile = fopen64(pFilePath, pOpenMode);
-    #else
-        *ppFile = fopen(pFilePath, pOpenMode);
-    #endif
-#endif
+#                    endif
+#                endif
     if (*ppFile == NULL) {
         drwav_result result = drwav_result_from_errno(errno);
         if (result == DRWAV_SUCCESS) {
-            result = DRWAV_ERROR;   /* Just a safety check to make sure we never ever return success when pFile == NULL. */
+            result =
+                DRWAV_ERROR; /* Just a safety check to make sure we never ever return success when pFile == NULL. */
         }
 
         return result;
     }
-#endif
+#            endif
 
     return DRWAV_SUCCESS;
 }
@@ -3005,59 +3408,61 @@ _wfopen() isn't always available in all compilation environments.
 This can be reviewed as compatibility issues arise. The preference is to use _wfopen_s() and _wfopen() as opposed to the wcsrtombs()
 fallback, so if you notice your compiler not detecting this properly I'm happy to look at adding support.
 */
-#if defined(_WIN32)
-    #if defined(_MSC_VER) || defined(__MINGW64__) || (!defined(__STRICT_ANSI__) && !defined(_NO_EXT_KEYS))
-        #define DRWAV_HAS_WFOPEN
-    #endif
-#endif
-
-static drwav_result drwav_wfopen(FILE** ppFile, const wchar_t* pFilePath, const wchar_t* pOpenMode, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
+#            if defined(_WIN32)
+#                if defined(_MSC_VER) || defined(__MINGW64__) || (!defined(__STRICT_ANSI__) && !defined(_NO_EXT_KEYS))
+#                    define DRWAV_HAS_WFOPEN
+#                endif
+#            endif
+
+static drwav_result drwav_wfopen(FILE **                            ppFile,
+                                 const wchar_t *                    pFilePath,
+                                 const wchar_t *                    pOpenMode,
+                                 const drwav_allocation_callbacks * pAllocationCallbacks) {
     if (ppFile != NULL) {
-        *ppFile = NULL;  /* Safety. */
+        *ppFile = NULL; /* Safety. */
     }
 
     if (pFilePath == NULL || pOpenMode == NULL || ppFile == NULL) {
         return DRWAV_INVALID_ARGS;
     }
 
-#if defined(DRWAV_HAS_WFOPEN)
+#            if defined(DRWAV_HAS_WFOPEN)
     {
         /* Use _wfopen() on Windows. */
-    #if defined(_MSC_VER) && _MSC_VER >= 1400
+#                if defined(_MSC_VER) && _MSC_VER >= 1400
         errno_t err = _wfopen_s(ppFile, pFilePath, pOpenMode);
         if (err != 0) {
             return drwav_result_from_errno(err);
         }
-    #else
+#                else
         *ppFile = _wfopen(pFilePath, pOpenMode);
         if (*ppFile == NULL) {
             return drwav_result_from_errno(errno);
         }
-    #endif
-        (void)pAllocationCallbacks;
+#                endif
+        (void) pAllocationCallbacks;
     }
-#else
+#            else
     /*
     Use fopen() on anything other than Windows. Requires a conversion. This is annoying because fopen() is locale specific. The only real way I can
     think of to do this is with wcsrtombs(). Note that wcstombs() is apparently not thread-safe because it uses a static global mbstate_t object for
     maintaining state. I've checked this with -std=c89 and it works, but if somebody get's a compiler error I'll look into improving compatibility.
     */
     {
-        mbstate_t mbs;
-        size_t lenMB;
-        const wchar_t* pFilePathTemp = pFilePath;
-        char* pFilePathMB = NULL;
-        char pOpenModeMB[32] = {0};
+        mbstate_t       mbs;
+        size_t          lenMB;
+        const wchar_t * pFilePathTemp   = pFilePath;
+        char *          pFilePathMB     = NULL;
+        char            pOpenModeMB[32] = { 0 };
 
         /* Get the length first. */
         DRWAV_ZERO_OBJECT(&mbs);
         lenMB = wcsrtombs(NULL, &pFilePathTemp, 0, &mbs);
-        if (lenMB == (size_t)-1) {
+        if (lenMB == (size_t) -1) {
             return drwav_result_from_errno(errno);
         }
 
-        pFilePathMB = (char*)drwav__malloc_from_callbacks(lenMB + 1, pAllocationCallbacks);
+        pFilePathMB = (char *) drwav__malloc_from_callbacks(lenMB + 1, pAllocationCallbacks);
         if (pFilePathMB == NULL) {
             return DRWAV_OUT_OF_MEMORY;
         }
@@ -3075,7 +3480,7 @@ static drwav_result drwav_wfopen(FILE** ppFile, const wchar_t* pFilePath, const
                     break;
                 }
 
-                pOpenModeMB[i] = (char)pOpenMode[i];
+                pOpenModeMB[i] = (char) pOpenMode[i];
                 i += 1;
             }
         }
@@ -3088,38 +3493,38 @@ static drwav_result drwav_wfopen(FILE** ppFile, const wchar_t* pFilePath, const
     if (*ppFile == NULL) {
         return DRWAV_ERROR;
     }
-#endif
+#            endif
 
     return DRWAV_SUCCESS;
 }
 
-
-static size_t drwav__on_read_stdio(void* pUserData, void* pBufferOut, size_t bytesToRead)
-{
-    return fread(pBufferOut, 1, bytesToRead, (FILE*)pUserData);
+static size_t drwav__on_read_stdio(void * pUserData, void * pBufferOut, size_t bytesToRead) {
+    return fread(pBufferOut, 1, bytesToRead, (FILE *) pUserData);
 }
 
-static size_t drwav__on_write_stdio(void* pUserData, const void* pData, size_t bytesToWrite)
-{
-    return fwrite(pData, 1, bytesToWrite, (FILE*)pUserData);
+static size_t drwav__on_write_stdio(void * pUserData, const void * pData, size_t bytesToWrite) {
+    return fwrite(pData, 1, bytesToWrite, (FILE *) pUserData);
 }
 
-static drwav_bool32 drwav__on_seek_stdio(void* pUserData, int offset, drwav_seek_origin origin)
-{
-    return fseek((FILE*)pUserData, offset, (origin == drwav_seek_origin_current) ? SEEK_CUR : SEEK_SET) == 0;
+static drwav_bool32 drwav__on_seek_stdio(void * pUserData, int offset, drwav_seek_origin origin) {
+    return fseek((FILE *) pUserData, offset, (origin == drwav_seek_origin_current) ? SEEK_CUR : SEEK_SET) == 0;
 }
 
-DRWAV_API drwav_bool32 drwav_init_file(drwav* pWav, const char* filename, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
+DRWAV_API drwav_bool32 drwav_init_file(drwav *                            pWav,
+                                       const char *                       filename,
+                                       const drwav_allocation_callbacks * pAllocationCallbacks) {
     return drwav_init_file_ex(pWav, filename, NULL, NULL, 0, pAllocationCallbacks);
 }
 
-
-static drwav_bool32 drwav_init_file__internal_FILE(drwav* pWav, FILE* pFile, drwav_chunk_proc onChunk, void* pChunkUserData, drwav_uint32 flags, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
+static drwav_bool32 drwav_init_file__internal_FILE(drwav *                            pWav,
+                                                   FILE *                             pFile,
+                                                   drwav_chunk_proc                   onChunk,
+                                                   void *                             pChunkUserData,
+                                                   drwav_uint32                       flags,
+                                                   const drwav_allocation_callbacks * pAllocationCallbacks) {
     drwav_bool32 result;
 
-    result = drwav_preinit(pWav, drwav__on_read_stdio, drwav__on_seek_stdio, (void*)pFile, pAllocationCallbacks);
+    result = drwav_preinit(pWav, drwav__on_read_stdio, drwav__on_seek_stdio, (void *) pFile, pAllocationCallbacks);
     if (result != DRWAV_TRUE) {
         fclose(pFile);
         return result;
@@ -3134,9 +3539,13 @@ static drwav_bool32 drwav_init_file__internal_FILE(drwav* pWav, FILE* pFile, drw
     return DRWAV_TRUE;
 }
 
-DRWAV_API drwav_bool32 drwav_init_file_ex(drwav* pWav, const char* filename, drwav_chunk_proc onChunk, void* pChunkUserData, drwav_uint32 flags, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
-    FILE* pFile;
+DRWAV_API drwav_bool32 drwav_init_file_ex(drwav *                            pWav,
+                                          const char *                       filename,
+                                          drwav_chunk_proc                   onChunk,
+                                          void *                             pChunkUserData,
+                                          drwav_uint32                       flags,
+                                          const drwav_allocation_callbacks * pAllocationCallbacks) {
+    FILE * pFile;
     if (drwav_fopen(&pFile, filename, "rb") != DRWAV_SUCCESS) {
         return DRWAV_FALSE;
     }
@@ -3145,14 +3554,19 @@ DRWAV_API drwav_bool32 drwav_init_file_ex(drwav* pWav, const char* filename, drw
     return drwav_init_file__internal_FILE(pWav, pFile, onChunk, pChunkUserData, flags, pAllocationCallbacks);
 }
 
-DRWAV_API drwav_bool32 drwav_init_file_w(drwav* pWav, const wchar_t* filename, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
+DRWAV_API drwav_bool32 drwav_init_file_w(drwav *                            pWav,
+                                         const wchar_t *                    filename,
+                                         const drwav_allocation_callbacks * pAllocationCallbacks) {
     return drwav_init_file_ex_w(pWav, filename, NULL, NULL, 0, pAllocationCallbacks);
 }
 
-DRWAV_API drwav_bool32 drwav_init_file_ex_w(drwav* pWav, const wchar_t* filename, drwav_chunk_proc onChunk, void* pChunkUserData, drwav_uint32 flags, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
-    FILE* pFile;
+DRWAV_API drwav_bool32 drwav_init_file_ex_w(drwav *                            pWav,
+                                            const wchar_t *                    filename,
+                                            drwav_chunk_proc                   onChunk,
+                                            void *                             pChunkUserData,
+                                            drwav_uint32                       flags,
+                                            const drwav_allocation_callbacks * pAllocationCallbacks) {
+    FILE * pFile;
     if (drwav_wfopen(&pFile, filename, L"rb", pAllocationCallbacks) != DRWAV_SUCCESS) {
         return DRWAV_FALSE;
     }
@@ -3161,12 +3575,16 @@ DRWAV_API drwav_bool32 drwav_init_file_ex_w(drwav* pWav, const wchar_t* filename
     return drwav_init_file__internal_FILE(pWav, pFile, onChunk, pChunkUserData, flags, pAllocationCallbacks);
 }
 
-
-static drwav_bool32 drwav_init_file_write__internal_FILE(drwav* pWav, FILE* pFile, const drwav_data_format* pFormat, drwav_uint64 totalSampleCount, drwav_bool32 isSequential, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
+static drwav_bool32 drwav_init_file_write__internal_FILE(drwav *                            pWav,
+                                                         FILE *                             pFile,
+                                                         const drwav_data_format *          pFormat,
+                                                         drwav_uint64                       totalSampleCount,
+                                                         drwav_bool32                       isSequential,
+                                                         const drwav_allocation_callbacks * pAllocationCallbacks) {
     drwav_bool32 result;
 
-    result = drwav_preinit_write(pWav, pFormat, isSequential, drwav__on_write_stdio, drwav__on_seek_stdio, (void*)pFile, pAllocationCallbacks);
+    result = drwav_preinit_write(pWav, pFormat, isSequential, drwav__on_write_stdio, drwav__on_seek_stdio,
+                                 (void *) pFile, pAllocationCallbacks);
     if (result != DRWAV_TRUE) {
         fclose(pFile);
         return result;
@@ -3181,72 +3599,101 @@ static drwav_bool32 drwav_init_file_write__internal_FILE(drwav* pWav, FILE* pFil
     return DRWAV_TRUE;
 }
 
-static drwav_bool32 drwav_init_file_write__internal(drwav* pWav, const char* filename, const drwav_data_format* pFormat, drwav_uint64 totalSampleCount, drwav_bool32 isSequential, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
-    FILE* pFile;
+static drwav_bool32 drwav_init_file_write__internal(drwav *                            pWav,
+                                                    const char *                       filename,
+                                                    const drwav_data_format *          pFormat,
+                                                    drwav_uint64                       totalSampleCount,
+                                                    drwav_bool32                       isSequential,
+                                                    const drwav_allocation_callbacks * pAllocationCallbacks) {
+    FILE * pFile;
     if (drwav_fopen(&pFile, filename, "wb") != DRWAV_SUCCESS) {
         return DRWAV_FALSE;
     }
 
     /* This takes ownership of the FILE* object. */
-    return drwav_init_file_write__internal_FILE(pWav, pFile, pFormat, totalSampleCount, isSequential, pAllocationCallbacks);
+    return drwav_init_file_write__internal_FILE(pWav, pFile, pFormat, totalSampleCount, isSequential,
+                                                pAllocationCallbacks);
 }
 
-static drwav_bool32 drwav_init_file_write_w__internal(drwav* pWav, const wchar_t* filename, const drwav_data_format* pFormat, drwav_uint64 totalSampleCount, drwav_bool32 isSequential, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
-    FILE* pFile;
+static drwav_bool32 drwav_init_file_write_w__internal(drwav *                            pWav,
+                                                      const wchar_t *                    filename,
+                                                      const drwav_data_format *          pFormat,
+                                                      drwav_uint64                       totalSampleCount,
+                                                      drwav_bool32                       isSequential,
+                                                      const drwav_allocation_callbacks * pAllocationCallbacks) {
+    FILE * pFile;
     if (drwav_wfopen(&pFile, filename, L"wb", pAllocationCallbacks) != DRWAV_SUCCESS) {
         return DRWAV_FALSE;
     }
 
     /* This takes ownership of the FILE* object. */
-    return drwav_init_file_write__internal_FILE(pWav, pFile, pFormat, totalSampleCount, isSequential, pAllocationCallbacks);
+    return drwav_init_file_write__internal_FILE(pWav, pFile, pFormat, totalSampleCount, isSequential,
+                                                pAllocationCallbacks);
 }
 
-DRWAV_API drwav_bool32 drwav_init_file_write(drwav* pWav, const char* filename, const drwav_data_format* pFormat, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
+DRWAV_API drwav_bool32 drwav_init_file_write(drwav *                            pWav,
+                                             const char *                       filename,
+                                             const drwav_data_format *          pFormat,
+                                             const drwav_allocation_callbacks * pAllocationCallbacks) {
     return drwav_init_file_write__internal(pWav, filename, pFormat, 0, DRWAV_FALSE, pAllocationCallbacks);
 }
 
-DRWAV_API drwav_bool32 drwav_init_file_write_sequential(drwav* pWav, const char* filename, const drwav_data_format* pFormat, drwav_uint64 totalSampleCount, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
+DRWAV_API drwav_bool32 drwav_init_file_write_sequential(drwav *                            pWav,
+                                                        const char *                       filename,
+                                                        const drwav_data_format *          pFormat,
+                                                        drwav_uint64                       totalSampleCount,
+                                                        const drwav_allocation_callbacks * pAllocationCallbacks) {
     return drwav_init_file_write__internal(pWav, filename, pFormat, totalSampleCount, DRWAV_TRUE, pAllocationCallbacks);
 }
 
-DRWAV_API drwav_bool32 drwav_init_file_write_sequential_pcm_frames(drwav* pWav, const char* filename, const drwav_data_format* pFormat, drwav_uint64 totalPCMFrameCount, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
+DRWAV_API drwav_bool32
+drwav_init_file_write_sequential_pcm_frames(drwav *                            pWav,
+                                            const char *                       filename,
+                                            const drwav_data_format *          pFormat,
+                                            drwav_uint64                       totalPCMFrameCount,
+                                            const drwav_allocation_callbacks * pAllocationCallbacks) {
     if (pFormat == NULL) {
         return DRWAV_FALSE;
     }
 
-    return drwav_init_file_write_sequential(pWav, filename, pFormat, totalPCMFrameCount*pFormat->channels, pAllocationCallbacks);
+    return drwav_init_file_write_sequential(pWav, filename, pFormat, totalPCMFrameCount * pFormat->channels,
+                                            pAllocationCallbacks);
 }
 
-DRWAV_API drwav_bool32 drwav_init_file_write_w(drwav* pWav, const wchar_t* filename, const drwav_data_format* pFormat, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
+DRWAV_API drwav_bool32 drwav_init_file_write_w(drwav *                            pWav,
+                                               const wchar_t *                    filename,
+                                               const drwav_data_format *          pFormat,
+                                               const drwav_allocation_callbacks * pAllocationCallbacks) {
     return drwav_init_file_write_w__internal(pWav, filename, pFormat, 0, DRWAV_FALSE, pAllocationCallbacks);
 }
 
-DRWAV_API drwav_bool32 drwav_init_file_write_sequential_w(drwav* pWav, const wchar_t* filename, const drwav_data_format* pFormat, drwav_uint64 totalSampleCount, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
-    return drwav_init_file_write_w__internal(pWav, filename, pFormat, totalSampleCount, DRWAV_TRUE, pAllocationCallbacks);
+DRWAV_API drwav_bool32 drwav_init_file_write_sequential_w(drwav *                            pWav,
+                                                          const wchar_t *                    filename,
+                                                          const drwav_data_format *          pFormat,
+                                                          drwav_uint64                       totalSampleCount,
+                                                          const drwav_allocation_callbacks * pAllocationCallbacks) {
+    return drwav_init_file_write_w__internal(pWav, filename, pFormat, totalSampleCount, DRWAV_TRUE,
+                                             pAllocationCallbacks);
 }
 
-DRWAV_API drwav_bool32 drwav_init_file_write_sequential_pcm_frames_w(drwav* pWav, const wchar_t* filename, const drwav_data_format* pFormat, drwav_uint64 totalPCMFrameCount, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
+DRWAV_API drwav_bool32
+drwav_init_file_write_sequential_pcm_frames_w(drwav *                            pWav,
+                                              const wchar_t *                    filename,
+                                              const drwav_data_format *          pFormat,
+                                              drwav_uint64                       totalPCMFrameCount,
+                                              const drwav_allocation_callbacks * pAllocationCallbacks) {
     if (pFormat == NULL) {
         return DRWAV_FALSE;
     }
 
-    return drwav_init_file_write_sequential_w(pWav, filename, pFormat, totalPCMFrameCount*pFormat->channels, pAllocationCallbacks);
+    return drwav_init_file_write_sequential_w(pWav, filename, pFormat, totalPCMFrameCount * pFormat->channels,
+                                              pAllocationCallbacks);
 }
-#endif  /* DR_WAV_NO_STDIO */
+#        endif /* DR_WAV_NO_STDIO */
 
-
-static size_t drwav__on_read_memory(void* pUserData, void* pBufferOut, size_t bytesToRead)
-{
-    drwav* pWav = (drwav*)pUserData;
-    size_t bytesRemaining;
+static size_t drwav__on_read_memory(void * pUserData, void * pBufferOut, size_t bytesToRead) {
+    drwav * pWav = (drwav *) pUserData;
+    size_t  bytesRemaining;
 
     DRWAV_ASSERT(pWav != NULL);
     DRWAV_ASSERT(pWav->memoryStream.dataSize >= pWav->memoryStream.currentReadPos);
@@ -3264,9 +3711,8 @@ static size_t drwav__on_read_memory(void* pUserData, void* pBufferOut, size_t by
     return bytesToRead;
 }
 
-static drwav_bool32 drwav__on_seek_memory(void* pUserData, int offset, drwav_seek_origin origin)
-{
-    drwav* pWav = (drwav*)pUserData;
+static drwav_bool32 drwav__on_seek_memory(void * pUserData, int offset, drwav_seek_origin origin) {
+    drwav * pWav = (drwav *) pUserData;
     DRWAV_ASSERT(pWav != NULL);
 
     if (origin == drwav_seek_origin_current) {
@@ -3275,7 +3721,7 @@ static drwav_bool32 drwav__on_seek_memory(void* pUserData, int offset, drwav_see
                 return DRWAV_FALSE; /* Trying to seek too far forward. */
             }
         } else {
-            if (pWav->memoryStream.currentReadPos < (size_t)-offset) {
+            if (pWav->memoryStream.currentReadPos < (size_t) -offset) {
                 return DRWAV_FALSE; /* Trying to seek too far backwards. */
             }
         }
@@ -3283,20 +3729,19 @@ static drwav_bool32 drwav__on_seek_memory(void* pUserData, int offset, drwav_see
         /* This will never underflow thanks to the clamps above. */
         pWav->memoryStream.currentReadPos += offset;
     } else {
-        if ((drwav_uint32)offset <= pWav->memoryStream.dataSize) {
+        if ((drwav_uint32) offset <= pWav->memoryStream.dataSize) {
             pWav->memoryStream.currentReadPos = offset;
         } else {
             return DRWAV_FALSE; /* Trying to seek too far forward. */
         }
     }
-    
+
     return DRWAV_TRUE;
 }
 
-static size_t drwav__on_write_memory(void* pUserData, const void* pDataIn, size_t bytesToWrite)
-{
-    drwav* pWav = (drwav*)pUserData;
-    size_t bytesRemaining;
+static size_t drwav__on_write_memory(void * pUserData, const void * pDataIn, size_t bytesToWrite) {
+    drwav * pWav = (drwav *) pUserData;
+    size_t  bytesRemaining;
 
     DRWAV_ASSERT(pWav != NULL);
     DRWAV_ASSERT(pWav->memoryStreamWrite.dataCapacity >= pWav->memoryStreamWrite.currentWritePos);
@@ -3304,24 +3749,27 @@ static size_t drwav__on_write_memory(void* pUserData, const void* pDataIn, size_
     bytesRemaining = pWav->memoryStreamWrite.dataCapacity - pWav->memoryStreamWrite.currentWritePos;
     if (bytesRemaining < bytesToWrite) {
         /* Need to reallocate. */
-        void* pNewData;
-        size_t newDataCapacity = (pWav->memoryStreamWrite.dataCapacity == 0) ? 256 : pWav->memoryStreamWrite.dataCapacity * 2;
+        void * pNewData;
+        size_t newDataCapacity =
+            (pWav->memoryStreamWrite.dataCapacity == 0) ? 256 : pWav->memoryStreamWrite.dataCapacity * 2;
 
         /* If doubling wasn't enough, just make it the minimum required size to write the data. */
         if ((newDataCapacity - pWav->memoryStreamWrite.currentWritePos) < bytesToWrite) {
             newDataCapacity = pWav->memoryStreamWrite.currentWritePos + bytesToWrite;
         }
 
-        pNewData = drwav__realloc_from_callbacks(*pWav->memoryStreamWrite.ppData, newDataCapacity, pWav->memoryStreamWrite.dataCapacity, &pWav->allocationCallbacks);
+        pNewData = drwav__realloc_from_callbacks(*pWav->memoryStreamWrite.ppData, newDataCapacity,
+                                                 pWav->memoryStreamWrite.dataCapacity, &pWav->allocationCallbacks);
         if (pNewData == NULL) {
             return 0;
         }
 
-        *pWav->memoryStreamWrite.ppData = pNewData;
+        *pWav->memoryStreamWrite.ppData      = pNewData;
         pWav->memoryStreamWrite.dataCapacity = newDataCapacity;
     }
 
-    DRWAV_COPY_MEMORY(((drwav_uint8*)(*pWav->memoryStreamWrite.ppData)) + pWav->memoryStreamWrite.currentWritePos, pDataIn, bytesToWrite);
+    DRWAV_COPY_MEMORY(((drwav_uint8 *) (*pWav->memoryStreamWrite.ppData)) + pWav->memoryStreamWrite.currentWritePos,
+                      pDataIn, bytesToWrite);
 
     pWav->memoryStreamWrite.currentWritePos += bytesToWrite;
     if (pWav->memoryStreamWrite.dataSize < pWav->memoryStreamWrite.currentWritePos) {
@@ -3333,42 +3781,50 @@ static size_t drwav__on_write_memory(void* pUserData, const void* pDataIn, size_
     return bytesToWrite;
 }
 
-static drwav_bool32 drwav__on_seek_memory_write(void* pUserData, int offset, drwav_seek_origin origin)
-{
-    drwav* pWav = (drwav*)pUserData;
+static drwav_bool32 drwav__on_seek_memory_write(void * pUserData, int offset, drwav_seek_origin origin) {
+    drwav * pWav = (drwav *) pUserData;
     DRWAV_ASSERT(pWav != NULL);
 
     if (origin == drwav_seek_origin_current) {
         if (offset > 0) {
             if (pWav->memoryStreamWrite.currentWritePos + offset > pWav->memoryStreamWrite.dataSize) {
-                offset = (int)(pWav->memoryStreamWrite.dataSize - pWav->memoryStreamWrite.currentWritePos);  /* Trying to seek too far forward. */
+                offset = (int) (pWav->memoryStreamWrite.dataSize -
+                                pWav->memoryStreamWrite.currentWritePos); /* Trying to seek too far forward. */
             }
         } else {
-            if (pWav->memoryStreamWrite.currentWritePos < (size_t)-offset) {
-                offset = -(int)pWav->memoryStreamWrite.currentWritePos;  /* Trying to seek too far backwards. */
+            if (pWav->memoryStreamWrite.currentWritePos < (size_t) -offset) {
+                offset = -(int) pWav->memoryStreamWrite.currentWritePos; /* Trying to seek too far backwards. */
             }
         }
 
         /* This will never underflow thanks to the clamps above. */
         pWav->memoryStreamWrite.currentWritePos += offset;
     } else {
-        if ((drwav_uint32)offset <= pWav->memoryStreamWrite.dataSize) {
+        if ((drwav_uint32) offset <= pWav->memoryStreamWrite.dataSize) {
             pWav->memoryStreamWrite.currentWritePos = offset;
         } else {
-            pWav->memoryStreamWrite.currentWritePos = pWav->memoryStreamWrite.dataSize;  /* Trying to seek too far forward. */
+            pWav->memoryStreamWrite.currentWritePos =
+                pWav->memoryStreamWrite.dataSize; /* Trying to seek too far forward. */
         }
     }
-    
+
     return DRWAV_TRUE;
 }
 
-DRWAV_API drwav_bool32 drwav_init_memory(drwav* pWav, const void* data, size_t dataSize, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
+DRWAV_API drwav_bool32 drwav_init_memory(drwav *                            pWav,
+                                         const void *                       data,
+                                         size_t                             dataSize,
+                                         const drwav_allocation_callbacks * pAllocationCallbacks) {
     return drwav_init_memory_ex(pWav, data, dataSize, NULL, NULL, 0, pAllocationCallbacks);
 }
 
-DRWAV_API drwav_bool32 drwav_init_memory_ex(drwav* pWav, const void* data, size_t dataSize, drwav_chunk_proc onChunk, void* pChunkUserData, drwav_uint32 flags, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
+DRWAV_API drwav_bool32 drwav_init_memory_ex(drwav *                            pWav,
+                                            const void *                       data,
+                                            size_t                             dataSize,
+                                            drwav_chunk_proc                   onChunk,
+                                            void *                             pChunkUserData,
+                                            drwav_uint32                       flags,
+                                            const drwav_allocation_callbacks * pAllocationCallbacks) {
     if (data == NULL || dataSize == 0) {
         return DRWAV_FALSE;
     }
@@ -3377,59 +3833,75 @@ DRWAV_API drwav_bool32 drwav_init_memory_ex(drwav* pWav, const void* data, size_
         return DRWAV_FALSE;
     }
 
-    pWav->memoryStream.data = (const drwav_uint8*)data;
-    pWav->memoryStream.dataSize = dataSize;
+    pWav->memoryStream.data           = (const drwav_uint8 *) data;
+    pWav->memoryStream.dataSize       = dataSize;
     pWav->memoryStream.currentReadPos = 0;
 
     return drwav_init__internal(pWav, onChunk, pChunkUserData, flags);
 }
 
-
-static drwav_bool32 drwav_init_memory_write__internal(drwav* pWav, void** ppData, size_t* pDataSize, const drwav_data_format* pFormat, drwav_uint64 totalSampleCount, drwav_bool32 isSequential, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
+static drwav_bool32 drwav_init_memory_write__internal(drwav *                            pWav,
+                                                      void **                            ppData,
+                                                      size_t *                           pDataSize,
+                                                      const drwav_data_format *          pFormat,
+                                                      drwav_uint64                       totalSampleCount,
+                                                      drwav_bool32                       isSequential,
+                                                      const drwav_allocation_callbacks * pAllocationCallbacks) {
     if (ppData == NULL || pDataSize == NULL) {
         return DRWAV_FALSE;
     }
 
-    *ppData = NULL; /* Important because we're using realloc()! */
+    *ppData    = NULL; /* Important because we're using realloc()! */
     *pDataSize = 0;
 
-    if (!drwav_preinit_write(pWav, pFormat, isSequential, drwav__on_write_memory, drwav__on_seek_memory_write, pWav, pAllocationCallbacks)) {
+    if (!drwav_preinit_write(pWav, pFormat, isSequential, drwav__on_write_memory, drwav__on_seek_memory_write, pWav,
+                             pAllocationCallbacks)) {
         return DRWAV_FALSE;
     }
 
-    pWav->memoryStreamWrite.ppData = ppData;
-    pWav->memoryStreamWrite.pDataSize = pDataSize;
-    pWav->memoryStreamWrite.dataSize = 0;
-    pWav->memoryStreamWrite.dataCapacity = 0;
+    pWav->memoryStreamWrite.ppData          = ppData;
+    pWav->memoryStreamWrite.pDataSize       = pDataSize;
+    pWav->memoryStreamWrite.dataSize        = 0;
+    pWav->memoryStreamWrite.dataCapacity    = 0;
     pWav->memoryStreamWrite.currentWritePos = 0;
 
     return drwav_init_write__internal(pWav, pFormat, totalSampleCount);
 }
 
-DRWAV_API drwav_bool32 drwav_init_memory_write(drwav* pWav, void** ppData, size_t* pDataSize, const drwav_data_format* pFormat, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
+DRWAV_API drwav_bool32 drwav_init_memory_write(drwav *                            pWav,
+                                               void **                            ppData,
+                                               size_t *                           pDataSize,
+                                               const drwav_data_format *          pFormat,
+                                               const drwav_allocation_callbacks * pAllocationCallbacks) {
     return drwav_init_memory_write__internal(pWav, ppData, pDataSize, pFormat, 0, DRWAV_FALSE, pAllocationCallbacks);
 }
 
-DRWAV_API drwav_bool32 drwav_init_memory_write_sequential(drwav* pWav, void** ppData, size_t* pDataSize, const drwav_data_format* pFormat, drwav_uint64 totalSampleCount, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
-    return drwav_init_memory_write__internal(pWav, ppData, pDataSize, pFormat, totalSampleCount, DRWAV_TRUE, pAllocationCallbacks);
+DRWAV_API drwav_bool32 drwav_init_memory_write_sequential(drwav *                            pWav,
+                                                          void **                            ppData,
+                                                          size_t *                           pDataSize,
+                                                          const drwav_data_format *          pFormat,
+                                                          drwav_uint64                       totalSampleCount,
+                                                          const drwav_allocation_callbacks * pAllocationCallbacks) {
+    return drwav_init_memory_write__internal(pWav, ppData, pDataSize, pFormat, totalSampleCount, DRWAV_TRUE,
+                                             pAllocationCallbacks);
 }
 
-DRWAV_API drwav_bool32 drwav_init_memory_write_sequential_pcm_frames(drwav* pWav, void** ppData, size_t* pDataSize, const drwav_data_format* pFormat, drwav_uint64 totalPCMFrameCount, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
+DRWAV_API drwav_bool32
+drwav_init_memory_write_sequential_pcm_frames(drwav *                            pWav,
+                                              void **                            ppData,
+                                              size_t *                           pDataSize,
+                                              const drwav_data_format *          pFormat,
+                                              drwav_uint64                       totalPCMFrameCount,
+                                              const drwav_allocation_callbacks * pAllocationCallbacks) {
     if (pFormat == NULL) {
         return DRWAV_FALSE;
     }
 
-    return drwav_init_memory_write_sequential(pWav, ppData, pDataSize, pFormat, totalPCMFrameCount*pFormat->channels, pAllocationCallbacks);
+    return drwav_init_memory_write_sequential(pWav, ppData, pDataSize, pFormat, totalPCMFrameCount * pFormat->channels,
+                                              pAllocationCallbacks);
 }
 
-
-
-DRWAV_API drwav_result drwav_uninit(drwav* pWav)
-{
+DRWAV_API drwav_result drwav_uninit(drwav * pWav) {
     drwav_result result = DRWAV_SUCCESS;
 
     if (pWav == NULL) {
@@ -3450,10 +3922,10 @@ DRWAV_API drwav_result drwav_uninit(drwav* pWav)
         } else {
             paddingSize = drwav__chunk_padding_size_w64(pWav->dataChunkDataSize);
         }
-        
+
         if (paddingSize > 0) {
             drwav_uint64 paddingData = 0;
-            drwav__write(pWav, &paddingData, paddingSize);  /* Byte order does not matter for this. */
+            drwav__write(pWav, &paddingData, paddingSize); /* Byte order does not matter for this. */
         }
 
         /*
@@ -3469,7 +3941,7 @@ DRWAV_API drwav_result drwav_uninit(drwav* pWav)
                 }
 
                 /* the "data" chunk size. */
-                if (pWav->onSeek(pWav->pUserData, (int)pWav->dataChunkDataPos + 4, drwav_seek_origin_start)) {
+                if (pWav->onSeek(pWav->pUserData, (int) pWav->dataChunkDataPos + 4, drwav_seek_origin_start)) {
                     drwav_uint32 dataChunkSize = drwav__data_chunk_size_riff(pWav->dataChunkDataSize);
                     drwav__write_u32ne_to_le(pWav, dataChunkSize);
                 }
@@ -3481,7 +3953,7 @@ DRWAV_API drwav_result drwav_uninit(drwav* pWav)
                 }
 
                 /* The "data" chunk size. */
-                if (pWav->onSeek(pWav->pUserData, (int)pWav->dataChunkDataPos + 16, drwav_seek_origin_start)) {
+                if (pWav->onSeek(pWav->pUserData, (int) pWav->dataChunkDataPos + 16, drwav_seek_origin_start)) {
                     drwav_uint64 dataChunkSize = drwav__data_chunk_size_w64(pWav->dataChunkDataSize);
                     drwav__write_u64ne_to_le(pWav, dataChunkSize);
                 }
@@ -3511,23 +3983,20 @@ DRWAV_API drwav_result drwav_uninit(drwav* pWav)
         }
     }
 
-#ifndef DR_WAV_NO_STDIO
+#        ifndef DR_WAV_NO_STDIO
     /*
     If we opened the file with drwav_open_file() we will want to close the file handle. We can know whether or not drwav_open_file()
     was used by looking at the onRead and onSeek callbacks.
     */
     if (pWav->onRead == drwav__on_read_stdio || pWav->onWrite == drwav__on_write_stdio) {
-        fclose((FILE*)pWav->pUserData);
+        fclose((FILE *) pWav->pUserData);
     }
-#endif
+#        endif
 
     return result;
 }
 
-
-
-DRWAV_API size_t drwav_read_raw(drwav* pWav, size_t bytesToRead, void* pBufferOut)
-{
+DRWAV_API size_t drwav_read_raw(drwav * pWav, size_t bytesToRead, void * pBufferOut) {
     size_t bytesRead;
 
     if (pWav == NULL || bytesToRead == 0) {
@@ -3535,7 +4004,7 @@ DRWAV_API size_t drwav_read_raw(drwav* pWav, size_t bytesToRead, void* pBufferOu
     }
 
     if (bytesToRead > pWav->bytesRemaining) {
-        bytesToRead = (size_t)pWav->bytesRemaining;
+        bytesToRead = (size_t) pWav->bytesRemaining;
     }
 
     if (pBufferOut != NULL) {
@@ -3549,7 +4018,7 @@ DRWAV_API size_t drwav_read_raw(drwav* pWav, size_t bytesToRead, void* pBufferOu
                 bytesToSeek = 0x7FFFFFFF;
             }
 
-            if (pWav->onSeek(pWav->pUserData, (int)bytesToSeek, drwav_seek_origin_current) == DRWAV_FALSE) {
+            if (pWav->onSeek(pWav->pUserData, (int) bytesToSeek, drwav_seek_origin_current) == DRWAV_FALSE) {
                 break;
             }
 
@@ -3559,8 +4028,8 @@ DRWAV_API size_t drwav_read_raw(drwav* pWav, size_t bytesToRead, void* pBufferOu
         /* When we get here we may need to read-and-discard some data. */
         while (bytesRead < bytesToRead) {
             drwav_uint8 buffer[4096];
-            size_t bytesSeeked;
-            size_t bytesToSeek = (bytesToRead - bytesRead);
+            size_t      bytesSeeked;
+            size_t      bytesToSeek = (bytesToRead - bytesRead);
             if (bytesToSeek > sizeof(buffer)) {
                 bytesToSeek = sizeof(buffer);
             }
@@ -3569,7 +4038,7 @@ DRWAV_API size_t drwav_read_raw(drwav* pWav, size_t bytesToRead, void* pBufferOu
             bytesRead += bytesSeeked;
 
             if (bytesSeeked < bytesToSeek) {
-                break;  /* Reached the end. */
+                break; /* Reached the end. */
             }
         }
     }
@@ -3578,12 +4047,10 @@ DRWAV_API size_t drwav_read_raw(drwav* pWav, size_t bytesToRead, void* pBufferOu
     return bytesRead;
 }
 
-
-
-DRWAV_API drwav_uint64 drwav_read_pcm_frames_le(drwav* pWav, drwav_uint64 framesToRead, void* pBufferOut)
-{
+DRWAV_API drwav_uint64 drwav_read_pcm_frames_le(drwav * pWav, drwav_uint64 framesToRead, void * pBufferOut) {
     drwav_uint32 bytesPerFrame;
-    drwav_uint64 bytesToRead;   /* Intentionally uint64 instead of size_t so we can do a check that we're not reading too much on 32-bit builds. */
+    drwav_uint64
+        bytesToRead; /* Intentionally uint64 instead of size_t so we can do a check that we're not reading too much on 32-bit builds. */
 
     if (pWav == NULL || framesToRead == 0) {
         return 0;
@@ -3602,7 +4069,8 @@ DRWAV_API drwav_uint64 drwav_read_pcm_frames_le(drwav* pWav, drwav_uint64 frames
     /* Don't try to read more samples than can potentially fit in the output buffer. */
     bytesToRead = framesToRead * bytesPerFrame;
     if (bytesToRead > DRWAV_SIZE_MAX) {
-        bytesToRead = (DRWAV_SIZE_MAX / bytesPerFrame) * bytesPerFrame; /* Round the number of bytes to read to a clean frame boundary. */
+        bytesToRead = (DRWAV_SIZE_MAX / bytesPerFrame) *
+                      bytesPerFrame; /* Round the number of bytes to read to a clean frame boundary. */
     }
 
     /*
@@ -3613,22 +4081,21 @@ DRWAV_API drwav_uint64 drwav_read_pcm_frames_le(drwav* pWav, drwav_uint64 frames
         return 0;
     }
 
-    return drwav_read_raw(pWav, (size_t)bytesToRead, pBufferOut) / bytesPerFrame;
+    return drwav_read_raw(pWav, (size_t) bytesToRead, pBufferOut) / bytesPerFrame;
 }
 
-DRWAV_API drwav_uint64 drwav_read_pcm_frames_be(drwav* pWav, drwav_uint64 framesToRead, void* pBufferOut)
-{
+DRWAV_API drwav_uint64 drwav_read_pcm_frames_be(drwav * pWav, drwav_uint64 framesToRead, void * pBufferOut) {
     drwav_uint64 framesRead = drwav_read_pcm_frames_le(pWav, framesToRead, pBufferOut);
 
     if (pBufferOut != NULL) {
-        drwav__bswap_samples(pBufferOut, framesRead*pWav->channels, drwav_get_bytes_per_pcm_frame(pWav)/pWav->channels, pWav->translatedFormatTag);
+        drwav__bswap_samples(pBufferOut, framesRead * pWav->channels,
+                             drwav_get_bytes_per_pcm_frame(pWav) / pWav->channels, pWav->translatedFormatTag);
     }
 
     return framesRead;
 }
 
-DRWAV_API drwav_uint64 drwav_read_pcm_frames(drwav* pWav, drwav_uint64 framesToRead, void* pBufferOut)
-{
+DRWAV_API drwav_uint64 drwav_read_pcm_frames(drwav * pWav, drwav_uint64 framesToRead, void * pBufferOut) {
     if (drwav__is_little_endian()) {
         return drwav_read_pcm_frames_le(pWav, framesToRead, pBufferOut);
     } else {
@@ -3636,15 +4103,12 @@ DRWAV_API drwav_uint64 drwav_read_pcm_frames(drwav* pWav, drwav_uint64 framesToR
     }
 }
 
-
-
-DRWAV_API drwav_bool32 drwav_seek_to_first_pcm_frame(drwav* pWav)
-{
+DRWAV_API drwav_bool32 drwav_seek_to_first_pcm_frame(drwav * pWav) {
     if (pWav->onWrite != NULL) {
         return DRWAV_FALSE; /* No seeking in write mode. */
     }
 
-    if (!pWav->onSeek(pWav->pUserData, (int)pWav->dataChunkDataPos, drwav_seek_origin_start)) {
+    if (!pWav->onSeek(pWav->pUserData, (int) pWav->dataChunkDataPos, drwav_seek_origin_start)) {
         return DRWAV_FALSE;
     }
 
@@ -3657,16 +4121,16 @@ DRWAV_API drwav_bool32 drwav_seek_to_first_pcm_frame(drwav* pWav)
         } else if (pWav->translatedFormatTag == DR_WAVE_FORMAT_DVI_ADPCM) {
             DRWAV_ZERO_OBJECT(&pWav->ima);
         } else {
-            DRWAV_ASSERT(DRWAV_FALSE);  /* If this assertion is triggered it means I've implemented a new compressed format but forgot to add a branch for it here. */
+            DRWAV_ASSERT(
+                DRWAV_FALSE); /* If this assertion is triggered it means I've implemented a new compressed format but forgot to add a branch for it here. */
         }
     }
-    
+
     pWav->bytesRemaining = pWav->dataChunkDataSize;
     return DRWAV_TRUE;
 }
 
-DRWAV_API drwav_bool32 drwav_seek_to_pcm_frame(drwav* pWav, drwav_uint64 targetFrameIndex)
-{
+DRWAV_API drwav_bool32 drwav_seek_to_pcm_frame(drwav * pWav, drwav_uint64 targetFrameIndex) {
     /* Seeking should be compatible with wave files > 2GB. */
 
     if (pWav == NULL || pWav->onSeek == NULL) {
@@ -3685,7 +4149,7 @@ DRWAV_API drwav_bool32 drwav_seek_to_pcm_frame(drwav* pWav, drwav_uint64 targetF
 
     /* Make sure the sample is clamped. */
     if (targetFrameIndex >= pWav->totalPCMFrameCount) {
-        targetFrameIndex  = pWav->totalPCMFrameCount - 1;
+        targetFrameIndex = pWav->totalPCMFrameCount - 1;
     }
 
     /*
@@ -3694,7 +4158,7 @@ DRWAV_API drwav_bool32 drwav_seek_to_pcm_frame(drwav* pWav, drwav_uint64 targetF
     */
     if (drwav__is_compressed_format_tag(pWav->translatedFormatTag)) {
         /* TODO: This can be optimized. */
-        
+
         /*
         If we're seeking forward it's simple - just keep reading samples until we hit the sample we're requesting. If we're seeking backwards,
         we first need to seek back to the start and then just do the same thing as a forward seek.
@@ -3710,10 +4174,10 @@ DRWAV_API drwav_bool32 drwav_seek_to_pcm_frame(drwav* pWav, drwav_uint64 targetF
 
             drwav_int16 devnull[2048];
             while (offsetInFrames > 0) {
-                drwav_uint64 framesRead = 0;
+                drwav_uint64 framesRead   = 0;
                 drwav_uint64 framesToRead = offsetInFrames;
-                if (framesToRead > drwav_countof(devnull)/pWav->channels) {
-                    framesToRead = drwav_countof(devnull)/pWav->channels;
+                if (framesToRead > drwav_countof(devnull) / pWav->channels) {
+                    framesToRead = drwav_countof(devnull) / pWav->channels;
                 }
 
                 if (pWav->translatedFormatTag == DR_WAVE_FORMAT_ADPCM) {
@@ -3721,7 +4185,8 @@ DRWAV_API drwav_bool32 drwav_seek_to_pcm_frame(drwav* pWav, drwav_uint64 targetF
                 } else if (pWav->translatedFormatTag == DR_WAVE_FORMAT_DVI_ADPCM) {
                     framesRead = drwav_read_pcm_frames_s16__ima(pWav, framesToRead, devnull);
                 } else {
-                    DRWAV_ASSERT(DRWAV_FALSE);  /* If this assertion is triggered it means I've implemented a new compressed format but forgot to add a branch for it here. */
+                    DRWAV_ASSERT(
+                        DRWAV_FALSE); /* If this assertion is triggered it means I've implemented a new compressed format but forgot to add a branch for it here. */
                 }
 
                 if (framesRead != framesToRead) {
@@ -3755,7 +4220,7 @@ DRWAV_API drwav_bool32 drwav_seek_to_pcm_frame(drwav* pWav, drwav_uint64 targetF
         }
 
         while (offset > 0) {
-            int offset32 = ((offset > INT_MAX) ? INT_MAX : (int)offset);
+            int offset32 = ((offset > INT_MAX) ? INT_MAX : (int) offset);
             if (!pWav->onSeek(pWav->pUserData, offset32, drwav_seek_origin_current)) {
                 return DRWAV_FALSE;
             }
@@ -3768,9 +4233,7 @@ DRWAV_API drwav_bool32 drwav_seek_to_pcm_frame(drwav* pWav, drwav_uint64 targetF
     return DRWAV_TRUE;
 }
 
-
-DRWAV_API size_t drwav_write_raw(drwav* pWav, size_t bytesToWrite, const void* pData)
-{
+DRWAV_API size_t drwav_write_raw(drwav * pWav, size_t bytesToWrite, const void * pData) {
     size_t bytesWritten;
 
     if (pWav == NULL || bytesToWrite == 0 || pData == NULL) {
@@ -3783,12 +4246,10 @@ DRWAV_API size_t drwav_write_raw(drwav* pWav, size_t bytesToWrite, const void* p
     return bytesWritten;
 }
 
-
-DRWAV_API drwav_uint64 drwav_write_pcm_frames_le(drwav* pWav, drwav_uint64 framesToWrite, const void* pData)
-{
-    drwav_uint64 bytesToWrite;
-    drwav_uint64 bytesWritten;
-    const drwav_uint8* pRunningData;
+DRWAV_API drwav_uint64 drwav_write_pcm_frames_le(drwav * pWav, drwav_uint64 framesToWrite, const void * pData) {
+    drwav_uint64        bytesToWrite;
+    drwav_uint64        bytesWritten;
+    const drwav_uint8 * pRunningData;
 
     if (pWav == NULL || framesToWrite == 0 || pData == NULL) {
         return 0;
@@ -3800,16 +4261,16 @@ DRWAV_API drwav_uint64 drwav_write_pcm_frames_le(drwav* pWav, drwav_uint64 frame
     }
 
     bytesWritten = 0;
-    pRunningData = (const drwav_uint8*)pData;
+    pRunningData = (const drwav_uint8 *) pData;
 
     while (bytesToWrite > 0) {
-        size_t bytesJustWritten;
+        size_t       bytesJustWritten;
         drwav_uint64 bytesToWriteThisIteration;
 
         bytesToWriteThisIteration = bytesToWrite;
-        DRWAV_ASSERT(bytesToWriteThisIteration <= DRWAV_SIZE_MAX);  /* <-- This is checked above. */
+        DRWAV_ASSERT(bytesToWriteThisIteration <= DRWAV_SIZE_MAX); /* <-- This is checked above. */
 
-        bytesJustWritten = drwav_write_raw(pWav, (size_t)bytesToWriteThisIteration, pRunningData);
+        bytesJustWritten = drwav_write_raw(pWav, (size_t) bytesToWriteThisIteration, pRunningData);
         if (bytesJustWritten == 0) {
             break;
         }
@@ -3822,12 +4283,11 @@ DRWAV_API drwav_uint64 drwav_write_pcm_frames_le(drwav* pWav, drwav_uint64 frame
     return (bytesWritten * 8) / pWav->bitsPerSample / pWav->channels;
 }
 
-DRWAV_API drwav_uint64 drwav_write_pcm_frames_be(drwav* pWav, drwav_uint64 framesToWrite, const void* pData)
-{
-    drwav_uint64 bytesToWrite;
-    drwav_uint64 bytesWritten;
-    drwav_uint32 bytesPerSample;
-    const drwav_uint8* pRunningData;
+DRWAV_API drwav_uint64 drwav_write_pcm_frames_be(drwav * pWav, drwav_uint64 framesToWrite, const void * pData) {
+    drwav_uint64        bytesToWrite;
+    drwav_uint64        bytesWritten;
+    drwav_uint32        bytesPerSample;
+    const drwav_uint8 * pRunningData;
 
     if (pWav == NULL || framesToWrite == 0 || pData == NULL) {
         return 0;
@@ -3839,33 +4299,33 @@ DRWAV_API drwav_uint64 drwav_write_pcm_frames_be(drwav* pWav, drwav_uint64 frame
     }
 
     bytesWritten = 0;
-    pRunningData = (const drwav_uint8*)pData;
+    pRunningData = (const drwav_uint8 *) pData;
 
     bytesPerSample = drwav_get_bytes_per_pcm_frame(pWav) / pWav->channels;
-    
+
     while (bytesToWrite > 0) {
-        drwav_uint8 temp[4096];
+        drwav_uint8  temp[4096];
         drwav_uint32 sampleCount;
-        size_t bytesJustWritten;
+        size_t       bytesJustWritten;
         drwav_uint64 bytesToWriteThisIteration;
 
         bytesToWriteThisIteration = bytesToWrite;
-        DRWAV_ASSERT(bytesToWriteThisIteration <= DRWAV_SIZE_MAX);  /* <-- This is checked above. */
+        DRWAV_ASSERT(bytesToWriteThisIteration <= DRWAV_SIZE_MAX); /* <-- This is checked above. */
 
         /*
         WAV files are always little-endian. We need to byte swap on big-endian architectures. Since our input buffer is read-only we need
         to use an intermediary buffer for the conversion.
         */
-        sampleCount = sizeof(temp)/bytesPerSample;
+        sampleCount = sizeof(temp) / bytesPerSample;
 
-        if (bytesToWriteThisIteration > ((drwav_uint64)sampleCount)*bytesPerSample) {
-            bytesToWriteThisIteration = ((drwav_uint64)sampleCount)*bytesPerSample;
+        if (bytesToWriteThisIteration > ((drwav_uint64) sampleCount) * bytesPerSample) {
+            bytesToWriteThisIteration = ((drwav_uint64) sampleCount) * bytesPerSample;
         }
 
-        DRWAV_COPY_MEMORY(temp, pRunningData, (size_t)bytesToWriteThisIteration);
+        DRWAV_COPY_MEMORY(temp, pRunningData, (size_t) bytesToWriteThisIteration);
         drwav__bswap_samples(temp, sampleCount, bytesPerSample, pWav->translatedFormatTag);
 
-        bytesJustWritten = drwav_write_raw(pWav, (size_t)bytesToWriteThisIteration, temp);
+        bytesJustWritten = drwav_write_raw(pWav, (size_t) bytesToWriteThisIteration, temp);
         if (bytesJustWritten == 0) {
             break;
         }
@@ -3878,8 +4338,7 @@ DRWAV_API drwav_uint64 drwav_write_pcm_frames_be(drwav* pWav, drwav_uint64 frame
     return (bytesWritten * 8) / pWav->bitsPerSample / pWav->channels;
 }
 
-DRWAV_API drwav_uint64 drwav_write_pcm_frames(drwav* pWav, drwav_uint64 framesToWrite, const void* pData)
-{
+DRWAV_API drwav_uint64 drwav_write_pcm_frames(drwav * pWav, drwav_uint64 framesToWrite, const void * pData) {
     if (drwav__is_little_endian()) {
         return drwav_write_pcm_frames_le(pWav, framesToWrite, pData);
     } else {
@@ -3887,9 +4346,9 @@ DRWAV_API drwav_uint64 drwav_write_pcm_frames(drwav* pWav, drwav_uint64 framesTo
     }
 }
 
-
-static drwav_uint64 drwav_read_pcm_frames_s16__msadpcm(drwav* pWav, drwav_uint64 framesToRead, drwav_int16* pBufferOut)
-{
+static drwav_uint64 drwav_read_pcm_frames_s16__msadpcm(drwav *       pWav,
+                                                       drwav_uint64  framesToRead,
+                                                       drwav_int16 * pBufferOut) {
     drwav_uint64 totalFramesRead = 0;
 
     DRWAV_ASSERT(pWav != NULL);
@@ -3910,8 +4369,8 @@ static drwav_uint64 drwav_read_pcm_frames_s16__msadpcm(drwav* pWav, drwav_uint64
 
                 pWav->msadpcm.predictor[0]     = header[0];
                 pWav->msadpcm.delta[0]         = drwav__bytes_to_s16(header + 1);
-                pWav->msadpcm.prevFrames[0][1] = (drwav_int32)drwav__bytes_to_s16(header + 3);
-                pWav->msadpcm.prevFrames[0][0] = (drwav_int32)drwav__bytes_to_s16(header + 5);
+                pWav->msadpcm.prevFrames[0][1] = (drwav_int32) drwav__bytes_to_s16(header + 3);
+                pWav->msadpcm.prevFrames[0][0] = (drwav_int32) drwav__bytes_to_s16(header + 5);
                 pWav->msadpcm.cachedFrames[2]  = pWav->msadpcm.prevFrames[0][0];
                 pWav->msadpcm.cachedFrames[3]  = pWav->msadpcm.prevFrames[0][1];
                 pWav->msadpcm.cachedFrameCount = 2;
@@ -3923,35 +4382,39 @@ static drwav_uint64 drwav_read_pcm_frames_s16__msadpcm(drwav* pWav, drwav_uint64
                 }
                 pWav->msadpcm.bytesRemainingInBlock = pWav->fmt.blockAlign - sizeof(header);
 
-                pWav->msadpcm.predictor[0] = header[0];
-                pWav->msadpcm.predictor[1] = header[1];
-                pWav->msadpcm.delta[0] = drwav__bytes_to_s16(header + 2);
-                pWav->msadpcm.delta[1] = drwav__bytes_to_s16(header + 4);
-                pWav->msadpcm.prevFrames[0][1] = (drwav_int32)drwav__bytes_to_s16(header + 6);
-                pWav->msadpcm.prevFrames[1][1] = (drwav_int32)drwav__bytes_to_s16(header + 8);
-                pWav->msadpcm.prevFrames[0][0] = (drwav_int32)drwav__bytes_to_s16(header + 10);
-                pWav->msadpcm.prevFrames[1][0] = (drwav_int32)drwav__bytes_to_s16(header + 12);
-
-                pWav->msadpcm.cachedFrames[0] = pWav->msadpcm.prevFrames[0][0];
-                pWav->msadpcm.cachedFrames[1] = pWav->msadpcm.prevFrames[1][0];
-                pWav->msadpcm.cachedFrames[2] = pWav->msadpcm.prevFrames[0][1];
-                pWav->msadpcm.cachedFrames[3] = pWav->msadpcm.prevFrames[1][1];
+                pWav->msadpcm.predictor[0]     = header[0];
+                pWav->msadpcm.predictor[1]     = header[1];
+                pWav->msadpcm.delta[0]         = drwav__bytes_to_s16(header + 2);
+                pWav->msadpcm.delta[1]         = drwav__bytes_to_s16(header + 4);
+                pWav->msadpcm.prevFrames[0][1] = (drwav_int32) drwav__bytes_to_s16(header + 6);
+                pWav->msadpcm.prevFrames[1][1] = (drwav_int32) drwav__bytes_to_s16(header + 8);
+                pWav->msadpcm.prevFrames[0][0] = (drwav_int32) drwav__bytes_to_s16(header + 10);
+                pWav->msadpcm.prevFrames[1][0] = (drwav_int32) drwav__bytes_to_s16(header + 12);
+
+                pWav->msadpcm.cachedFrames[0]  = pWav->msadpcm.prevFrames[0][0];
+                pWav->msadpcm.cachedFrames[1]  = pWav->msadpcm.prevFrames[1][0];
+                pWav->msadpcm.cachedFrames[2]  = pWav->msadpcm.prevFrames[0][1];
+                pWav->msadpcm.cachedFrames[3]  = pWav->msadpcm.prevFrames[1][1];
                 pWav->msadpcm.cachedFrameCount = 2;
             }
         }
 
         /* Output anything that's cached. */
-        while (framesToRead > 0 && pWav->msadpcm.cachedFrameCount > 0 && pWav->compressed.iCurrentPCMFrame < pWav->totalPCMFrameCount) {
+        while (framesToRead > 0 && pWav->msadpcm.cachedFrameCount > 0 &&
+               pWav->compressed.iCurrentPCMFrame < pWav->totalPCMFrameCount) {
             if (pBufferOut != NULL) {
                 drwav_uint32 iSample = 0;
                 for (iSample = 0; iSample < pWav->channels; iSample += 1) {
-                    pBufferOut[iSample] = (drwav_int16)pWav->msadpcm.cachedFrames[(drwav_countof(pWav->msadpcm.cachedFrames) - (pWav->msadpcm.cachedFrameCount*pWav->channels)) + iSample];
+                    pBufferOut[iSample] =
+                        (drwav_int16) pWav->msadpcm.cachedFrames[(drwav_countof(pWav->msadpcm.cachedFrames) -
+                                                                  (pWav->msadpcm.cachedFrameCount * pWav->channels)) +
+                                                                 iSample];
                 }
 
                 pBufferOut += pWav->channels;
             }
 
-            framesToRead    -= 1;
+            framesToRead -= 1;
             totalFramesRead += 1;
             pWav->compressed.iCurrentPCMFrame += 1;
             pWav->msadpcm.cachedFrameCount -= 1;
@@ -3961,7 +4424,6 @@ static drwav_uint64 drwav_read_pcm_frames_s16__msadpcm(drwav* pWav, drwav_uint64
             return totalFramesRead;
         }
 
-
         /*
         If there's nothing left in the cache, just go ahead and load more. If there's nothing left to load in the current block we just continue to the next
         loop iteration which will trigger the loading of a new block.
@@ -3970,12 +4432,10 @@ static drwav_uint64 drwav_read_pcm_frames_s16__msadpcm(drwav* pWav, drwav_uint64
             if (pWav->msadpcm.bytesRemainingInBlock == 0) {
                 continue;
             } else {
-                static drwav_int32 adaptationTable[] = { 
-                    230, 230, 230, 230, 307, 409, 512, 614, 
-                    768, 614, 512, 409, 307, 230, 230, 230 
-                };
-                static drwav_int32 coeff1Table[] = { 256, 512, 0, 192, 240, 460,  392 };
-                static drwav_int32 coeff2Table[] = { 0,  -256, 0, 64,  0,  -208, -232 };
+                static drwav_int32 adaptationTable[] = { 230, 230, 230, 230, 307, 409, 512, 614,
+                                                         768, 614, 512, 409, 307, 230, 230, 230 };
+                static drwav_int32 coeff1Table[]     = { 256, 512, 0, 192, 240, 460, 392 };
+                static drwav_int32 coeff2Table[]     = { 0, -256, 0, 64, 0, -208, -232 };
 
                 drwav_uint8 nibbles;
                 drwav_int32 nibble0;
@@ -3987,17 +4447,25 @@ static drwav_uint64 drwav_read_pcm_frames_s16__msadpcm(drwav* pWav, drwav_uint64
                 pWav->msadpcm.bytesRemainingInBlock -= 1;
 
                 /* TODO: Optimize away these if statements. */
-                nibble0 = ((nibbles & 0xF0) >> 4); if ((nibbles & 0x80)) { nibble0 |= 0xFFFFFFF0UL; }
-                nibble1 = ((nibbles & 0x0F) >> 0); if ((nibbles & 0x08)) { nibble1 |= 0xFFFFFFF0UL; }
+                nibble0 = ((nibbles & 0xF0) >> 4);
+                if ((nibbles & 0x80)) {
+                    nibble0 |= 0xFFFFFFF0UL;
+                }
+                nibble1 = ((nibbles & 0x0F) >> 0);
+                if ((nibbles & 0x08)) {
+                    nibble1 |= 0xFFFFFFF0UL;
+                }
 
                 if (pWav->channels == 1) {
                     /* Mono. */
                     drwav_int32 newSample0;
                     drwav_int32 newSample1;
 
-                    newSample0  = ((pWav->msadpcm.prevFrames[0][1] * coeff1Table[pWav->msadpcm.predictor[0]]) + (pWav->msadpcm.prevFrames[0][0] * coeff2Table[pWav->msadpcm.predictor[0]])) >> 8;
+                    newSample0 = ((pWav->msadpcm.prevFrames[0][1] * coeff1Table[pWav->msadpcm.predictor[0]]) +
+                                  (pWav->msadpcm.prevFrames[0][0] * coeff2Table[pWav->msadpcm.predictor[0]])) >>
+                                 8;
                     newSample0 += nibble0 * pWav->msadpcm.delta[0];
-                    newSample0  = drwav_clamp(newSample0, -32768, 32767);
+                    newSample0 = drwav_clamp(newSample0, -32768, 32767);
 
                     pWav->msadpcm.delta[0] = (adaptationTable[((nibbles & 0xF0) >> 4)] * pWav->msadpcm.delta[0]) >> 8;
                     if (pWav->msadpcm.delta[0] < 16) {
@@ -4007,10 +4475,11 @@ static drwav_uint64 drwav_read_pcm_frames_s16__msadpcm(drwav* pWav, drwav_uint64
                     pWav->msadpcm.prevFrames[0][0] = pWav->msadpcm.prevFrames[0][1];
                     pWav->msadpcm.prevFrames[0][1] = newSample0;
 
-
-                    newSample1  = ((pWav->msadpcm.prevFrames[0][1] * coeff1Table[pWav->msadpcm.predictor[0]]) + (pWav->msadpcm.prevFrames[0][0] * coeff2Table[pWav->msadpcm.predictor[0]])) >> 8;
+                    newSample1 = ((pWav->msadpcm.prevFrames[0][1] * coeff1Table[pWav->msadpcm.predictor[0]]) +
+                                  (pWav->msadpcm.prevFrames[0][0] * coeff2Table[pWav->msadpcm.predictor[0]])) >>
+                                 8;
                     newSample1 += nibble1 * pWav->msadpcm.delta[0];
-                    newSample1  = drwav_clamp(newSample1, -32768, 32767);
+                    newSample1 = drwav_clamp(newSample1, -32768, 32767);
 
                     pWav->msadpcm.delta[0] = (adaptationTable[((nibbles & 0x0F) >> 0)] * pWav->msadpcm.delta[0]) >> 8;
                     if (pWav->msadpcm.delta[0] < 16) {
@@ -4020,9 +4489,8 @@ static drwav_uint64 drwav_read_pcm_frames_s16__msadpcm(drwav* pWav, drwav_uint64
                     pWav->msadpcm.prevFrames[0][0] = pWav->msadpcm.prevFrames[0][1];
                     pWav->msadpcm.prevFrames[0][1] = newSample1;
 
-
-                    pWav->msadpcm.cachedFrames[2] = newSample0;
-                    pWav->msadpcm.cachedFrames[3] = newSample1;
+                    pWav->msadpcm.cachedFrames[2]  = newSample0;
+                    pWav->msadpcm.cachedFrames[3]  = newSample1;
                     pWav->msadpcm.cachedFrameCount = 2;
                 } else {
                     /* Stereo. */
@@ -4030,9 +4498,11 @@ static drwav_uint64 drwav_read_pcm_frames_s16__msadpcm(drwav* pWav, drwav_uint64
                     drwav_int32 newSample1;
 
                     /* Left. */
-                    newSample0  = ((pWav->msadpcm.prevFrames[0][1] * coeff1Table[pWav->msadpcm.predictor[0]]) + (pWav->msadpcm.prevFrames[0][0] * coeff2Table[pWav->msadpcm.predictor[0]])) >> 8;
+                    newSample0 = ((pWav->msadpcm.prevFrames[0][1] * coeff1Table[pWav->msadpcm.predictor[0]]) +
+                                  (pWav->msadpcm.prevFrames[0][0] * coeff2Table[pWav->msadpcm.predictor[0]])) >>
+                                 8;
                     newSample0 += nibble0 * pWav->msadpcm.delta[0];
-                    newSample0  = drwav_clamp(newSample0, -32768, 32767);
+                    newSample0 = drwav_clamp(newSample0, -32768, 32767);
 
                     pWav->msadpcm.delta[0] = (adaptationTable[((nibbles & 0xF0) >> 4)] * pWav->msadpcm.delta[0]) >> 8;
                     if (pWav->msadpcm.delta[0] < 16) {
@@ -4042,11 +4512,12 @@ static drwav_uint64 drwav_read_pcm_frames_s16__msadpcm(drwav* pWav, drwav_uint64
                     pWav->msadpcm.prevFrames[0][0] = pWav->msadpcm.prevFrames[0][1];
                     pWav->msadpcm.prevFrames[0][1] = newSample0;
 
-
                     /* Right. */
-                    newSample1  = ((pWav->msadpcm.prevFrames[1][1] * coeff1Table[pWav->msadpcm.predictor[1]]) + (pWav->msadpcm.prevFrames[1][0] * coeff2Table[pWav->msadpcm.predictor[1]])) >> 8;
+                    newSample1 = ((pWav->msadpcm.prevFrames[1][1] * coeff1Table[pWav->msadpcm.predictor[1]]) +
+                                  (pWav->msadpcm.prevFrames[1][0] * coeff2Table[pWav->msadpcm.predictor[1]])) >>
+                                 8;
                     newSample1 += nibble1 * pWav->msadpcm.delta[1];
-                    newSample1  = drwav_clamp(newSample1, -32768, 32767);
+                    newSample1 = drwav_clamp(newSample1, -32768, 32767);
 
                     pWav->msadpcm.delta[1] = (adaptationTable[((nibbles & 0x0F) >> 0)] * pWav->msadpcm.delta[1]) >> 8;
                     if (pWav->msadpcm.delta[1] < 16) {
@@ -4056,8 +4527,8 @@ static drwav_uint64 drwav_read_pcm_frames_s16__msadpcm(drwav* pWav, drwav_uint64
                     pWav->msadpcm.prevFrames[1][0] = pWav->msadpcm.prevFrames[1][1];
                     pWav->msadpcm.prevFrames[1][1] = newSample1;
 
-                    pWav->msadpcm.cachedFrames[2] = newSample0;
-                    pWav->msadpcm.cachedFrames[3] = newSample1;
+                    pWav->msadpcm.cachedFrames[2]  = newSample0;
+                    pWav->msadpcm.cachedFrames[3]  = newSample1;
                     pWav->msadpcm.cachedFrameCount = 1;
                 }
             }
@@ -4067,27 +4538,19 @@ static drwav_uint64 drwav_read_pcm_frames_s16__msadpcm(drwav* pWav, drwav_uint64
     return totalFramesRead;
 }
 
-
-static drwav_uint64 drwav_read_pcm_frames_s16__ima(drwav* pWav, drwav_uint64 framesToRead, drwav_int16* pBufferOut)
-{
+static drwav_uint64 drwav_read_pcm_frames_s16__ima(drwav * pWav, drwav_uint64 framesToRead, drwav_int16 * pBufferOut) {
     drwav_uint64 totalFramesRead = 0;
     drwav_uint32 iChannel;
 
-    static drwav_int32 indexTable[16] = {
-        -1, -1, -1, -1, 2, 4, 6, 8,
-        -1, -1, -1, -1, 2, 4, 6, 8
-    };
+    static drwav_int32 indexTable[16] = { -1, -1, -1, -1, 2, 4, 6, 8, -1, -1, -1, -1, 2, 4, 6, 8 };
 
     static drwav_int32 stepTable[89] = {
-        7,     8,     9,     10,    11,    12,    13,    14,    16,    17, 
-        19,    21,    23,    25,    28,    31,    34,    37,    41,    45, 
-        50,    55,    60,    66,    73,    80,    88,    97,    107,   118, 
-        130,   143,   157,   173,   190,   209,   230,   253,   279,   307,
-        337,   371,   408,   449,   494,   544,   598,   658,   724,   796,
-        876,   963,   1060,  1166,  1282,  1411,  1552,  1707,  1878,  2066, 
-        2272,  2499,  2749,  3024,  3327,  3660,  4026,  4428,  4871,  5358,
-        5894,  6484,  7132,  7845,  8630,  9493,  10442, 11487, 12635, 13899, 
-        15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767 
+        7,    8,     9,     10,    11,    12,    13,    14,    16,    17,    19,    21,    23,    25,   28,
+        31,   34,    37,    41,    45,    50,    55,    60,    66,    73,    80,    88,    97,    107,  118,
+        130,  143,   157,   173,   190,   209,   230,   253,   279,   307,   337,   371,   408,   449,  494,
+        544,  598,   658,   724,   796,   876,   963,   1060,  1166,  1282,  1411,  1552,  1707,  1878, 2066,
+        2272, 2499,  2749,  3024,  3327,  3660,  4026,  4428,  4871,  5358,  5894,  6484,  7132,  7845, 8630,
+        9493, 10442, 11487, 12635, 13899, 15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767
     };
 
     DRWAV_ASSERT(pWav != NULL);
@@ -4112,10 +4575,10 @@ static drwav_uint64 drwav_read_pcm_frames_s16__ima(drwav* pWav, drwav_uint64 fra
                     return totalFramesRead; /* Invalid data. */
                 }
 
-                pWav->ima.predictor[0] = drwav__bytes_to_s16(header + 0);
-                pWav->ima.stepIndex[0] = header[2];
+                pWav->ima.predictor[0]                                            = drwav__bytes_to_s16(header + 0);
+                pWav->ima.stepIndex[0]                                            = header[2];
                 pWav->ima.cachedFrames[drwav_countof(pWav->ima.cachedFrames) - 1] = pWav->ima.predictor[0];
-                pWav->ima.cachedFrameCount = 1;
+                pWav->ima.cachedFrameCount                                        = 1;
             } else {
                 /* Stereo. */
                 drwav_uint8 header[8];
@@ -4137,21 +4600,25 @@ static drwav_uint64 drwav_read_pcm_frames_s16__ima(drwav* pWav, drwav_uint64 fra
 
                 pWav->ima.cachedFrames[drwav_countof(pWav->ima.cachedFrames) - 2] = pWav->ima.predictor[0];
                 pWav->ima.cachedFrames[drwav_countof(pWav->ima.cachedFrames) - 1] = pWav->ima.predictor[1];
-                pWav->ima.cachedFrameCount = 1;
+                pWav->ima.cachedFrameCount                                        = 1;
             }
         }
 
         /* Output anything that's cached. */
-        while (framesToRead > 0 && pWav->ima.cachedFrameCount > 0 && pWav->compressed.iCurrentPCMFrame < pWav->totalPCMFrameCount) {
+        while (framesToRead > 0 && pWav->ima.cachedFrameCount > 0 &&
+               pWav->compressed.iCurrentPCMFrame < pWav->totalPCMFrameCount) {
             if (pBufferOut != NULL) {
                 drwav_uint32 iSample;
                 for (iSample = 0; iSample < pWav->channels; iSample += 1) {
-                    pBufferOut[iSample] = (drwav_int16)pWav->ima.cachedFrames[(drwav_countof(pWav->ima.cachedFrames) - (pWav->ima.cachedFrameCount*pWav->channels)) + iSample];
+                    pBufferOut[iSample] =
+                        (drwav_int16) pWav->ima.cachedFrames[(drwav_countof(pWav->ima.cachedFrames) -
+                                                              (pWav->ima.cachedFrameCount * pWav->channels)) +
+                                                             iSample];
                 }
                 pBufferOut += pWav->channels;
             }
 
-            framesToRead    -= 1;
+            framesToRead -= 1;
             totalFramesRead += 1;
             pWav->compressed.iCurrentPCMFrame += 1;
             pWav->ima.cachedFrameCount -= 1;
@@ -4176,7 +4643,7 @@ static drwav_uint64 drwav_read_pcm_frames_s16__ima(drwav* pWav, drwav_uint64 fra
                 pWav->ima.cachedFrameCount = 8;
                 for (iChannel = 0; iChannel < pWav->channels; ++iChannel) {
                     drwav_uint32 iByte;
-                    drwav_uint8 nibbles[4];
+                    drwav_uint8  nibbles[4];
                     if (pWav->onRead(pWav->pUserData, &nibbles, 4) != 4) {
                         pWav->ima.cachedFrameCount = 0;
                         return totalFramesRead;
@@ -4190,31 +4657,52 @@ static drwav_uint64 drwav_read_pcm_frames_s16__ima(drwav* pWav, drwav_uint64 fra
                         drwav_int32 step      = stepTable[pWav->ima.stepIndex[iChannel]];
                         drwav_int32 predictor = pWav->ima.predictor[iChannel];
 
-                        drwav_int32      diff  = step >> 3;
-                        if (nibble0 & 1) diff += step >> 2;
-                        if (nibble0 & 2) diff += step >> 1;
-                        if (nibble0 & 4) diff += step;
-                        if (nibble0 & 8) diff  = -diff;
+                        drwav_int32 diff = step >> 3;
+                        if (nibble0 & 1) {
+                            diff += step >> 2;
+                        }
+                        if (nibble0 & 2) {
+                            diff += step >> 1;
+                        }
+                        if (nibble0 & 4) {
+                            diff += step;
+                        }
+                        if (nibble0 & 8) {
+                            diff = -diff;
+                        }
 
-                        predictor = drwav_clamp(predictor + diff, -32768, 32767);
+                        predictor                     = drwav_clamp(predictor + diff, -32768, 32767);
                         pWav->ima.predictor[iChannel] = predictor;
-                        pWav->ima.stepIndex[iChannel] = drwav_clamp(pWav->ima.stepIndex[iChannel] + indexTable[nibble0], 0, (drwav_int32)drwav_countof(stepTable)-1);
-                        pWav->ima.cachedFrames[(drwav_countof(pWav->ima.cachedFrames) - (pWav->ima.cachedFrameCount*pWav->channels)) + (iByte*2+0)*pWav->channels + iChannel] = predictor;
-
+                        pWav->ima.stepIndex[iChannel] = drwav_clamp(pWav->ima.stepIndex[iChannel] + indexTable[nibble0],
+                                                                    0, (drwav_int32) drwav_countof(stepTable) - 1);
+                        pWav->ima.cachedFrames[(drwav_countof(pWav->ima.cachedFrames) -
+                                                (pWav->ima.cachedFrameCount * pWav->channels)) +
+                                               (iByte * 2 + 0) * pWav->channels + iChannel] = predictor;
 
                         step      = stepTable[pWav->ima.stepIndex[iChannel]];
                         predictor = pWav->ima.predictor[iChannel];
 
-                                         diff  = step >> 3;
-                        if (nibble1 & 1) diff += step >> 2;
-                        if (nibble1 & 2) diff += step >> 1;
-                        if (nibble1 & 4) diff += step;
-                        if (nibble1 & 8) diff  = -diff;
+                        diff = step >> 3;
+                        if (nibble1 & 1) {
+                            diff += step >> 2;
+                        }
+                        if (nibble1 & 2) {
+                            diff += step >> 1;
+                        }
+                        if (nibble1 & 4) {
+                            diff += step;
+                        }
+                        if (nibble1 & 8) {
+                            diff = -diff;
+                        }
 
-                        predictor = drwav_clamp(predictor + diff, -32768, 32767);
+                        predictor                     = drwav_clamp(predictor + diff, -32768, 32767);
                         pWav->ima.predictor[iChannel] = predictor;
-                        pWav->ima.stepIndex[iChannel] = drwav_clamp(pWav->ima.stepIndex[iChannel] + indexTable[nibble1], 0, (drwav_int32)drwav_countof(stepTable)-1);
-                        pWav->ima.cachedFrames[(drwav_countof(pWav->ima.cachedFrames) - (pWav->ima.cachedFrameCount*pWav->channels)) + (iByte*2+1)*pWav->channels + iChannel] = predictor;
+                        pWav->ima.stepIndex[iChannel] = drwav_clamp(pWav->ima.stepIndex[iChannel] + indexTable[nibble1],
+                                                                    0, (drwav_int32) drwav_countof(stepTable) - 1);
+                        pWav->ima.cachedFrames[(drwav_countof(pWav->ima.cachedFrames) -
+                                                (pWav->ima.cachedFrameCount * pWav->channels)) +
+                                               (iByte * 2 + 1) * pWav->channels + iChannel] = predictor;
                     }
                 }
             }
@@ -4224,60 +4712,63 @@ static drwav_uint64 drwav_read_pcm_frames_s16__ima(drwav* pWav, drwav_uint64 fra
     return totalFramesRead;
 }
 
-
-#ifndef DR_WAV_NO_CONVERSION_API
+#        ifndef DR_WAV_NO_CONVERSION_API
 static unsigned short g_drwavAlawTable[256] = {
-    0xEA80, 0xEB80, 0xE880, 0xE980, 0xEE80, 0xEF80, 0xEC80, 0xED80, 0xE280, 0xE380, 0xE080, 0xE180, 0xE680, 0xE780, 0xE480, 0xE580, 
-    0xF540, 0xF5C0, 0xF440, 0xF4C0, 0xF740, 0xF7C0, 0xF640, 0xF6C0, 0xF140, 0xF1C0, 0xF040, 0xF0C0, 0xF340, 0xF3C0, 0xF240, 0xF2C0, 
-    0xAA00, 0xAE00, 0xA200, 0xA600, 0xBA00, 0xBE00, 0xB200, 0xB600, 0x8A00, 0x8E00, 0x8200, 0x8600, 0x9A00, 0x9E00, 0x9200, 0x9600, 
-    0xD500, 0xD700, 0xD100, 0xD300, 0xDD00, 0xDF00, 0xD900, 0xDB00, 0xC500, 0xC700, 0xC100, 0xC300, 0xCD00, 0xCF00, 0xC900, 0xCB00, 
-    0xFEA8, 0xFEB8, 0xFE88, 0xFE98, 0xFEE8, 0xFEF8, 0xFEC8, 0xFED8, 0xFE28, 0xFE38, 0xFE08, 0xFE18, 0xFE68, 0xFE78, 0xFE48, 0xFE58, 
-    0xFFA8, 0xFFB8, 0xFF88, 0xFF98, 0xFFE8, 0xFFF8, 0xFFC8, 0xFFD8, 0xFF28, 0xFF38, 0xFF08, 0xFF18, 0xFF68, 0xFF78, 0xFF48, 0xFF58, 
-    0xFAA0, 0xFAE0, 0xFA20, 0xFA60, 0xFBA0, 0xFBE0, 0xFB20, 0xFB60, 0xF8A0, 0xF8E0, 0xF820, 0xF860, 0xF9A0, 0xF9E0, 0xF920, 0xF960, 
-    0xFD50, 0xFD70, 0xFD10, 0xFD30, 0xFDD0, 0xFDF0, 0xFD90, 0xFDB0, 0xFC50, 0xFC70, 0xFC10, 0xFC30, 0xFCD0, 0xFCF0, 0xFC90, 0xFCB0, 
-    0x1580, 0x1480, 0x1780, 0x1680, 0x1180, 0x1080, 0x1380, 0x1280, 0x1D80, 0x1C80, 0x1F80, 0x1E80, 0x1980, 0x1880, 0x1B80, 0x1A80, 
-    0x0AC0, 0x0A40, 0x0BC0, 0x0B40, 0x08C0, 0x0840, 0x09C0, 0x0940, 0x0EC0, 0x0E40, 0x0FC0, 0x0F40, 0x0CC0, 0x0C40, 0x0DC0, 0x0D40, 
-    0x5600, 0x5200, 0x5E00, 0x5A00, 0x4600, 0x4200, 0x4E00, 0x4A00, 0x7600, 0x7200, 0x7E00, 0x7A00, 0x6600, 0x6200, 0x6E00, 0x6A00, 
-    0x2B00, 0x2900, 0x2F00, 0x2D00, 0x2300, 0x2100, 0x2700, 0x2500, 0x3B00, 0x3900, 0x3F00, 0x3D00, 0x3300, 0x3100, 0x3700, 0x3500, 
-    0x0158, 0x0148, 0x0178, 0x0168, 0x0118, 0x0108, 0x0138, 0x0128, 0x01D8, 0x01C8, 0x01F8, 0x01E8, 0x0198, 0x0188, 0x01B8, 0x01A8, 
-    0x0058, 0x0048, 0x0078, 0x0068, 0x0018, 0x0008, 0x0038, 0x0028, 0x00D8, 0x00C8, 0x00F8, 0x00E8, 0x0098, 0x0088, 0x00B8, 0x00A8, 
-    0x0560, 0x0520, 0x05E0, 0x05A0, 0x0460, 0x0420, 0x04E0, 0x04A0, 0x0760, 0x0720, 0x07E0, 0x07A0, 0x0660, 0x0620, 0x06E0, 0x06A0, 
-    0x02B0, 0x0290, 0x02F0, 0x02D0, 0x0230, 0x0210, 0x0270, 0x0250, 0x03B0, 0x0390, 0x03F0, 0x03D0, 0x0330, 0x0310, 0x0370, 0x0350
+    0xEA80, 0xEB80, 0xE880, 0xE980, 0xEE80, 0xEF80, 0xEC80, 0xED80, 0xE280, 0xE380, 0xE080, 0xE180, 0xE680, 0xE780,
+    0xE480, 0xE580, 0xF540, 0xF5C0, 0xF440, 0xF4C0, 0xF740, 0xF7C0, 0xF640, 0xF6C0, 0xF140, 0xF1C0, 0xF040, 0xF0C0,
+    0xF340, 0xF3C0, 0xF240, 0xF2C0, 0xAA00, 0xAE00, 0xA200, 0xA600, 0xBA00, 0xBE00, 0xB200, 0xB600, 0x8A00, 0x8E00,
+    0x8200, 0x8600, 0x9A00, 0x9E00, 0x9200, 0x9600, 0xD500, 0xD700, 0xD100, 0xD300, 0xDD00, 0xDF00, 0xD900, 0xDB00,
+    0xC500, 0xC700, 0xC100, 0xC300, 0xCD00, 0xCF00, 0xC900, 0xCB00, 0xFEA8, 0xFEB8, 0xFE88, 0xFE98, 0xFEE8, 0xFEF8,
+    0xFEC8, 0xFED8, 0xFE28, 0xFE38, 0xFE08, 0xFE18, 0xFE68, 0xFE78, 0xFE48, 0xFE58, 0xFFA8, 0xFFB8, 0xFF88, 0xFF98,
+    0xFFE8, 0xFFF8, 0xFFC8, 0xFFD8, 0xFF28, 0xFF38, 0xFF08, 0xFF18, 0xFF68, 0xFF78, 0xFF48, 0xFF58, 0xFAA0, 0xFAE0,
+    0xFA20, 0xFA60, 0xFBA0, 0xFBE0, 0xFB20, 0xFB60, 0xF8A0, 0xF8E0, 0xF820, 0xF860, 0xF9A0, 0xF9E0, 0xF920, 0xF960,
+    0xFD50, 0xFD70, 0xFD10, 0xFD30, 0xFDD0, 0xFDF0, 0xFD90, 0xFDB0, 0xFC50, 0xFC70, 0xFC10, 0xFC30, 0xFCD0, 0xFCF0,
+    0xFC90, 0xFCB0, 0x1580, 0x1480, 0x1780, 0x1680, 0x1180, 0x1080, 0x1380, 0x1280, 0x1D80, 0x1C80, 0x1F80, 0x1E80,
+    0x1980, 0x1880, 0x1B80, 0x1A80, 0x0AC0, 0x0A40, 0x0BC0, 0x0B40, 0x08C0, 0x0840, 0x09C0, 0x0940, 0x0EC0, 0x0E40,
+    0x0FC0, 0x0F40, 0x0CC0, 0x0C40, 0x0DC0, 0x0D40, 0x5600, 0x5200, 0x5E00, 0x5A00, 0x4600, 0x4200, 0x4E00, 0x4A00,
+    0x7600, 0x7200, 0x7E00, 0x7A00, 0x6600, 0x6200, 0x6E00, 0x6A00, 0x2B00, 0x2900, 0x2F00, 0x2D00, 0x2300, 0x2100,
+    0x2700, 0x2500, 0x3B00, 0x3900, 0x3F00, 0x3D00, 0x3300, 0x3100, 0x3700, 0x3500, 0x0158, 0x0148, 0x0178, 0x0168,
+    0x0118, 0x0108, 0x0138, 0x0128, 0x01D8, 0x01C8, 0x01F8, 0x01E8, 0x0198, 0x0188, 0x01B8, 0x01A8, 0x0058, 0x0048,
+    0x0078, 0x0068, 0x0018, 0x0008, 0x0038, 0x0028, 0x00D8, 0x00C8, 0x00F8, 0x00E8, 0x0098, 0x0088, 0x00B8, 0x00A8,
+    0x0560, 0x0520, 0x05E0, 0x05A0, 0x0460, 0x0420, 0x04E0, 0x04A0, 0x0760, 0x0720, 0x07E0, 0x07A0, 0x0660, 0x0620,
+    0x06E0, 0x06A0, 0x02B0, 0x0290, 0x02F0, 0x02D0, 0x0230, 0x0210, 0x0270, 0x0250, 0x03B0, 0x0390, 0x03F0, 0x03D0,
+    0x0330, 0x0310, 0x0370, 0x0350
 };
 
 static unsigned short g_drwavMulawTable[256] = {
-    0x8284, 0x8684, 0x8A84, 0x8E84, 0x9284, 0x9684, 0x9A84, 0x9E84, 0xA284, 0xA684, 0xAA84, 0xAE84, 0xB284, 0xB684, 0xBA84, 0xBE84, 
-    0xC184, 0xC384, 0xC584, 0xC784, 0xC984, 0xCB84, 0xCD84, 0xCF84, 0xD184, 0xD384, 0xD584, 0xD784, 0xD984, 0xDB84, 0xDD84, 0xDF84, 
-    0xE104, 0xE204, 0xE304, 0xE404, 0xE504, 0xE604, 0xE704, 0xE804, 0xE904, 0xEA04, 0xEB04, 0xEC04, 0xED04, 0xEE04, 0xEF04, 0xF004, 
-    0xF0C4, 0xF144, 0xF1C4, 0xF244, 0xF2C4, 0xF344, 0xF3C4, 0xF444, 0xF4C4, 0xF544, 0xF5C4, 0xF644, 0xF6C4, 0xF744, 0xF7C4, 0xF844, 
-    0xF8A4, 0xF8E4, 0xF924, 0xF964, 0xF9A4, 0xF9E4, 0xFA24, 0xFA64, 0xFAA4, 0xFAE4, 0xFB24, 0xFB64, 0xFBA4, 0xFBE4, 0xFC24, 0xFC64, 
-    0xFC94, 0xFCB4, 0xFCD4, 0xFCF4, 0xFD14, 0xFD34, 0xFD54, 0xFD74, 0xFD94, 0xFDB4, 0xFDD4, 0xFDF4, 0xFE14, 0xFE34, 0xFE54, 0xFE74, 
-    0xFE8C, 0xFE9C, 0xFEAC, 0xFEBC, 0xFECC, 0xFEDC, 0xFEEC, 0xFEFC, 0xFF0C, 0xFF1C, 0xFF2C, 0xFF3C, 0xFF4C, 0xFF5C, 0xFF6C, 0xFF7C, 
-    0xFF88, 0xFF90, 0xFF98, 0xFFA0, 0xFFA8, 0xFFB0, 0xFFB8, 0xFFC0, 0xFFC8, 0xFFD0, 0xFFD8, 0xFFE0, 0xFFE8, 0xFFF0, 0xFFF8, 0x0000, 
-    0x7D7C, 0x797C, 0x757C, 0x717C, 0x6D7C, 0x697C, 0x657C, 0x617C, 0x5D7C, 0x597C, 0x557C, 0x517C, 0x4D7C, 0x497C, 0x457C, 0x417C, 
-    0x3E7C, 0x3C7C, 0x3A7C, 0x387C, 0x367C, 0x347C, 0x327C, 0x307C, 0x2E7C, 0x2C7C, 0x2A7C, 0x287C, 0x267C, 0x247C, 0x227C, 0x207C, 
-    0x1EFC, 0x1DFC, 0x1CFC, 0x1BFC, 0x1AFC, 0x19FC, 0x18FC, 0x17FC, 0x16FC, 0x15FC, 0x14FC, 0x13FC, 0x12FC, 0x11FC, 0x10FC, 0x0FFC, 
-    0x0F3C, 0x0EBC, 0x0E3C, 0x0DBC, 0x0D3C, 0x0CBC, 0x0C3C, 0x0BBC, 0x0B3C, 0x0ABC, 0x0A3C, 0x09BC, 0x093C, 0x08BC, 0x083C, 0x07BC, 
-    0x075C, 0x071C, 0x06DC, 0x069C, 0x065C, 0x061C, 0x05DC, 0x059C, 0x055C, 0x051C, 0x04DC, 0x049C, 0x045C, 0x041C, 0x03DC, 0x039C, 
-    0x036C, 0x034C, 0x032C, 0x030C, 0x02EC, 0x02CC, 0x02AC, 0x028C, 0x026C, 0x024C, 0x022C, 0x020C, 0x01EC, 0x01CC, 0x01AC, 0x018C, 
-    0x0174, 0x0164, 0x0154, 0x0144, 0x0134, 0x0124, 0x0114, 0x0104, 0x00F4, 0x00E4, 0x00D4, 0x00C4, 0x00B4, 0x00A4, 0x0094, 0x0084, 
-    0x0078, 0x0070, 0x0068, 0x0060, 0x0058, 0x0050, 0x0048, 0x0040, 0x0038, 0x0030, 0x0028, 0x0020, 0x0018, 0x0010, 0x0008, 0x0000
+    0x8284, 0x8684, 0x8A84, 0x8E84, 0x9284, 0x9684, 0x9A84, 0x9E84, 0xA284, 0xA684, 0xAA84, 0xAE84, 0xB284, 0xB684,
+    0xBA84, 0xBE84, 0xC184, 0xC384, 0xC584, 0xC784, 0xC984, 0xCB84, 0xCD84, 0xCF84, 0xD184, 0xD384, 0xD584, 0xD784,
+    0xD984, 0xDB84, 0xDD84, 0xDF84, 0xE104, 0xE204, 0xE304, 0xE404, 0xE504, 0xE604, 0xE704, 0xE804, 0xE904, 0xEA04,
+    0xEB04, 0xEC04, 0xED04, 0xEE04, 0xEF04, 0xF004, 0xF0C4, 0xF144, 0xF1C4, 0xF244, 0xF2C4, 0xF344, 0xF3C4, 0xF444,
+    0xF4C4, 0xF544, 0xF5C4, 0xF644, 0xF6C4, 0xF744, 0xF7C4, 0xF844, 0xF8A4, 0xF8E4, 0xF924, 0xF964, 0xF9A4, 0xF9E4,
+    0xFA24, 0xFA64, 0xFAA4, 0xFAE4, 0xFB24, 0xFB64, 0xFBA4, 0xFBE4, 0xFC24, 0xFC64, 0xFC94, 0xFCB4, 0xFCD4, 0xFCF4,
+    0xFD14, 0xFD34, 0xFD54, 0xFD74, 0xFD94, 0xFDB4, 0xFDD4, 0xFDF4, 0xFE14, 0xFE34, 0xFE54, 0xFE74, 0xFE8C, 0xFE9C,
+    0xFEAC, 0xFEBC, 0xFECC, 0xFEDC, 0xFEEC, 0xFEFC, 0xFF0C, 0xFF1C, 0xFF2C, 0xFF3C, 0xFF4C, 0xFF5C, 0xFF6C, 0xFF7C,
+    0xFF88, 0xFF90, 0xFF98, 0xFFA0, 0xFFA8, 0xFFB0, 0xFFB8, 0xFFC0, 0xFFC8, 0xFFD0, 0xFFD8, 0xFFE0, 0xFFE8, 0xFFF0,
+    0xFFF8, 0x0000, 0x7D7C, 0x797C, 0x757C, 0x717C, 0x6D7C, 0x697C, 0x657C, 0x617C, 0x5D7C, 0x597C, 0x557C, 0x517C,
+    0x4D7C, 0x497C, 0x457C, 0x417C, 0x3E7C, 0x3C7C, 0x3A7C, 0x387C, 0x367C, 0x347C, 0x327C, 0x307C, 0x2E7C, 0x2C7C,
+    0x2A7C, 0x287C, 0x267C, 0x247C, 0x227C, 0x207C, 0x1EFC, 0x1DFC, 0x1CFC, 0x1BFC, 0x1AFC, 0x19FC, 0x18FC, 0x17FC,
+    0x16FC, 0x15FC, 0x14FC, 0x13FC, 0x12FC, 0x11FC, 0x10FC, 0x0FFC, 0x0F3C, 0x0EBC, 0x0E3C, 0x0DBC, 0x0D3C, 0x0CBC,
+    0x0C3C, 0x0BBC, 0x0B3C, 0x0ABC, 0x0A3C, 0x09BC, 0x093C, 0x08BC, 0x083C, 0x07BC, 0x075C, 0x071C, 0x06DC, 0x069C,
+    0x065C, 0x061C, 0x05DC, 0x059C, 0x055C, 0x051C, 0x04DC, 0x049C, 0x045C, 0x041C, 0x03DC, 0x039C, 0x036C, 0x034C,
+    0x032C, 0x030C, 0x02EC, 0x02CC, 0x02AC, 0x028C, 0x026C, 0x024C, 0x022C, 0x020C, 0x01EC, 0x01CC, 0x01AC, 0x018C,
+    0x0174, 0x0164, 0x0154, 0x0144, 0x0134, 0x0124, 0x0114, 0x0104, 0x00F4, 0x00E4, 0x00D4, 0x00C4, 0x00B4, 0x00A4,
+    0x0094, 0x0084, 0x0078, 0x0070, 0x0068, 0x0060, 0x0058, 0x0050, 0x0048, 0x0040, 0x0038, 0x0030, 0x0028, 0x0020,
+    0x0018, 0x0010, 0x0008, 0x0000
 };
 
-static DRWAV_INLINE drwav_int16 drwav__alaw_to_s16(drwav_uint8 sampleIn)
-{
-    return (short)g_drwavAlawTable[sampleIn];
+static DRWAV_INLINE drwav_int16 drwav__alaw_to_s16(drwav_uint8 sampleIn) {
+    return (short) g_drwavAlawTable[sampleIn];
 }
 
-static DRWAV_INLINE drwav_int16 drwav__mulaw_to_s16(drwav_uint8 sampleIn)
-{
-    return (short)g_drwavMulawTable[sampleIn];
+static DRWAV_INLINE drwav_int16 drwav__mulaw_to_s16(drwav_uint8 sampleIn) {
+    return (short) g_drwavMulawTable[sampleIn];
 }
 
-
-
-static void drwav__pcm_to_s16(drwav_int16* pOut, const drwav_uint8* pIn, size_t totalSampleCount, unsigned int bytesPerSample)
-{
+static void drwav__pcm_to_s16(drwav_int16 *       pOut,
+                              const drwav_uint8 * pIn,
+                              size_t              totalSampleCount,
+                              unsigned int        bytesPerSample) {
     unsigned int i;
 
     /* Special case for 8-bit sample data because it's treated as unsigned. */
@@ -4286,11 +4777,10 @@ static void drwav__pcm_to_s16(drwav_int16* pOut, const drwav_uint8* pIn, size_t
         return;
     }
 
-
     /* Slightly more optimal implementation for common formats. */
     if (bytesPerSample == 2) {
         for (i = 0; i < totalSampleCount; ++i) {
-           *pOut++ = ((const drwav_int16*)pIn)[i];
+            *pOut++ = ((const drwav_int16 *) pIn)[i];
         }
         return;
     }
@@ -4299,18 +4789,16 @@ static void drwav__pcm_to_s16(drwav_int16* pOut, const drwav_uint8* pIn, size_t
         return;
     }
     if (bytesPerSample == 4) {
-        drwav_s32_to_s16(pOut, (const drwav_int32*)pIn, totalSampleCount);
+        drwav_s32_to_s16(pOut, (const drwav_int32 *) pIn, totalSampleCount);
         return;
     }
 
-
     /* Anything more than 64 bits per sample is not supported. */
     if (bytesPerSample > 8) {
         DRWAV_ZERO_MEMORY(pOut, totalSampleCount * sizeof(*pOut));
         return;
     }
 
-
     /* Generic, slow converter. */
     for (i = 0; i < totalSampleCount; ++i) {
         drwav_uint64 sample = 0;
@@ -4319,22 +4807,24 @@ static void drwav__pcm_to_s16(drwav_int16* pOut, const drwav_uint8* pIn, size_t
         unsigned int j;
         for (j = 0; j < bytesPerSample; j += 1) {
             DRWAV_ASSERT(j < 8);
-            sample |= (drwav_uint64)(pIn[j]) << shift;
-            shift  += 8;
+            sample |= (drwav_uint64) (pIn[j]) << shift;
+            shift += 8;
         }
 
         pIn += j;
-        *pOut++ = (drwav_int16)((drwav_int64)sample >> 48);
+        *pOut++ = (drwav_int16) ((drwav_int64) sample >> 48);
     }
 }
 
-static void drwav__ieee_to_s16(drwav_int16* pOut, const drwav_uint8* pIn, size_t totalSampleCount, unsigned int bytesPerSample)
-{
+static void drwav__ieee_to_s16(drwav_int16 *       pOut,
+                               const drwav_uint8 * pIn,
+                               size_t              totalSampleCount,
+                               unsigned int        bytesPerSample) {
     if (bytesPerSample == 4) {
-        drwav_f32_to_s16(pOut, (const float*)pIn, totalSampleCount);
+        drwav_f32_to_s16(pOut, (const float *) pIn, totalSampleCount);
         return;
     } else if (bytesPerSample == 8) {
-        drwav_f64_to_s16(pOut, (const double*)pIn, totalSampleCount);
+        drwav_f64_to_s16(pOut, (const double *) pIn, totalSampleCount);
         return;
     } else {
         /* Only supporting 32- and 64-bit float. Output silence in all other cases. Contributions welcome for 16-bit float. */
@@ -4343,44 +4833,44 @@ static void drwav__ieee_to_s16(drwav_int16* pOut, const drwav_uint8* pIn, size_t
     }
 }
 
-static drwav_uint64 drwav_read_pcm_frames_s16__pcm(drwav* pWav, drwav_uint64 framesToRead, drwav_int16* pBufferOut)
-{
+static drwav_uint64 drwav_read_pcm_frames_s16__pcm(drwav * pWav, drwav_uint64 framesToRead, drwav_int16 * pBufferOut) {
     drwav_uint32 bytesPerFrame;
     drwav_uint64 totalFramesRead;
-    drwav_uint8 sampleData[4096];
+    drwav_uint8  sampleData[4096];
 
     /* Fast path. */
     if ((pWav->translatedFormatTag == DR_WAVE_FORMAT_PCM && pWav->bitsPerSample == 16) || pBufferOut == NULL) {
         return drwav_read_pcm_frames(pWav, framesToRead, pBufferOut);
     }
-    
+
     bytesPerFrame = drwav_get_bytes_per_pcm_frame(pWav);
     if (bytesPerFrame == 0) {
         return 0;
     }
 
     totalFramesRead = 0;
-    
+
     while (framesToRead > 0) {
-        drwav_uint64 framesRead = drwav_read_pcm_frames(pWav, drwav_min(framesToRead, sizeof(sampleData)/bytesPerFrame), sampleData);
+        drwav_uint64 framesRead =
+            drwav_read_pcm_frames(pWav, drwav_min(framesToRead, sizeof(sampleData) / bytesPerFrame), sampleData);
         if (framesRead == 0) {
             break;
         }
 
-        drwav__pcm_to_s16(pBufferOut, sampleData, (size_t)(framesRead*pWav->channels), bytesPerFrame/pWav->channels);
+        drwav__pcm_to_s16(pBufferOut, sampleData, (size_t) (framesRead * pWav->channels),
+                          bytesPerFrame / pWav->channels);
 
-        pBufferOut      += framesRead*pWav->channels;
-        framesToRead    -= framesRead;
+        pBufferOut += framesRead * pWav->channels;
+        framesToRead -= framesRead;
         totalFramesRead += framesRead;
     }
 
     return totalFramesRead;
 }
 
-static drwav_uint64 drwav_read_pcm_frames_s16__ieee(drwav* pWav, drwav_uint64 framesToRead, drwav_int16* pBufferOut)
-{
+static drwav_uint64 drwav_read_pcm_frames_s16__ieee(drwav * pWav, drwav_uint64 framesToRead, drwav_int16 * pBufferOut) {
     drwav_uint64 totalFramesRead;
-    drwav_uint8 sampleData[4096];
+    drwav_uint8  sampleData[4096];
     drwav_uint32 bytesPerFrame;
 
     if (pBufferOut == NULL) {
@@ -4393,27 +4883,28 @@ static drwav_uint64 drwav_read_pcm_frames_s16__ieee(drwav* pWav, drwav_uint64 fr
     }
 
     totalFramesRead = 0;
-    
+
     while (framesToRead > 0) {
-        drwav_uint64 framesRead = drwav_read_pcm_frames(pWav, drwav_min(framesToRead, sizeof(sampleData)/bytesPerFrame), sampleData);
+        drwav_uint64 framesRead =
+            drwav_read_pcm_frames(pWav, drwav_min(framesToRead, sizeof(sampleData) / bytesPerFrame), sampleData);
         if (framesRead == 0) {
             break;
         }
 
-        drwav__ieee_to_s16(pBufferOut, sampleData, (size_t)(framesRead*pWav->channels), bytesPerFrame/pWav->channels);
+        drwav__ieee_to_s16(pBufferOut, sampleData, (size_t) (framesRead * pWav->channels),
+                           bytesPerFrame / pWav->channels);
 
-        pBufferOut      += framesRead*pWav->channels;
-        framesToRead    -= framesRead;
+        pBufferOut += framesRead * pWav->channels;
+        framesToRead -= framesRead;
         totalFramesRead += framesRead;
     }
 
     return totalFramesRead;
 }
 
-static drwav_uint64 drwav_read_pcm_frames_s16__alaw(drwav* pWav, drwav_uint64 framesToRead, drwav_int16* pBufferOut)
-{
+static drwav_uint64 drwav_read_pcm_frames_s16__alaw(drwav * pWav, drwav_uint64 framesToRead, drwav_int16 * pBufferOut) {
     drwav_uint64 totalFramesRead;
-    drwav_uint8 sampleData[4096];
+    drwav_uint8  sampleData[4096];
     drwav_uint32 bytesPerFrame;
 
     if (pBufferOut == NULL) {
@@ -4426,27 +4917,29 @@ static drwav_uint64 drwav_read_pcm_frames_s16__alaw(drwav* pWav, drwav_uint64 fr
     }
 
     totalFramesRead = 0;
-    
+
     while (framesToRead > 0) {
-        drwav_uint64 framesRead = drwav_read_pcm_frames(pWav, drwav_min(framesToRead, sizeof(sampleData)/bytesPerFrame), sampleData);
+        drwav_uint64 framesRead =
+            drwav_read_pcm_frames(pWav, drwav_min(framesToRead, sizeof(sampleData) / bytesPerFrame), sampleData);
         if (framesRead == 0) {
             break;
         }
 
-        drwav_alaw_to_s16(pBufferOut, sampleData, (size_t)(framesRead*pWav->channels));
+        drwav_alaw_to_s16(pBufferOut, sampleData, (size_t) (framesRead * pWav->channels));
 
-        pBufferOut      += framesRead*pWav->channels;
-        framesToRead    -= framesRead;
+        pBufferOut += framesRead * pWav->channels;
+        framesToRead -= framesRead;
         totalFramesRead += framesRead;
     }
 
     return totalFramesRead;
 }
 
-static drwav_uint64 drwav_read_pcm_frames_s16__mulaw(drwav* pWav, drwav_uint64 framesToRead, drwav_int16* pBufferOut)
-{
+static drwav_uint64 drwav_read_pcm_frames_s16__mulaw(drwav *       pWav,
+                                                     drwav_uint64  framesToRead,
+                                                     drwav_int16 * pBufferOut) {
     drwav_uint64 totalFramesRead;
-    drwav_uint8 sampleData[4096];
+    drwav_uint8  sampleData[4096];
     drwav_uint32 bytesPerFrame;
 
     if (pBufferOut == NULL) {
@@ -4461,23 +4954,23 @@ static drwav_uint64 drwav_read_pcm_frames_s16__mulaw(drwav* pWav, drwav_uint64 f
     totalFramesRead = 0;
 
     while (framesToRead > 0) {
-        drwav_uint64 framesRead = drwav_read_pcm_frames(pWav, drwav_min(framesToRead, sizeof(sampleData)/bytesPerFrame), sampleData);
+        drwav_uint64 framesRead =
+            drwav_read_pcm_frames(pWav, drwav_min(framesToRead, sizeof(sampleData) / bytesPerFrame), sampleData);
         if (framesRead == 0) {
             break;
         }
 
-        drwav_mulaw_to_s16(pBufferOut, sampleData, (size_t)(framesRead*pWav->channels));
+        drwav_mulaw_to_s16(pBufferOut, sampleData, (size_t) (framesRead * pWav->channels));
 
-        pBufferOut      += framesRead*pWav->channels;
-        framesToRead    -= framesRead;
+        pBufferOut += framesRead * pWav->channels;
+        framesToRead -= framesRead;
         totalFramesRead += framesRead;
     }
 
     return totalFramesRead;
 }
 
-DRWAV_API drwav_uint64 drwav_read_pcm_frames_s16(drwav* pWav, drwav_uint64 framesToRead, drwav_int16* pBufferOut)
-{
+DRWAV_API drwav_uint64 drwav_read_pcm_frames_s16(drwav * pWav, drwav_uint64 framesToRead, drwav_int16 * pBufferOut) {
     if (pWav == NULL || framesToRead == 0) {
         return 0;
     }
@@ -4518,111 +5011,101 @@ DRWAV_API drwav_uint64 drwav_read_pcm_frames_s16(drwav* pWav, drwav_uint64 frame
     return 0;
 }
 
-DRWAV_API drwav_uint64 drwav_read_pcm_frames_s16le(drwav* pWav, drwav_uint64 framesToRead, drwav_int16* pBufferOut)
-{
+DRWAV_API drwav_uint64 drwav_read_pcm_frames_s16le(drwav * pWav, drwav_uint64 framesToRead, drwav_int16 * pBufferOut) {
     drwav_uint64 framesRead = drwav_read_pcm_frames_s16(pWav, framesToRead, pBufferOut);
     if (pBufferOut != NULL && drwav__is_little_endian() == DRWAV_FALSE) {
-        drwav__bswap_samples_s16(pBufferOut, framesRead*pWav->channels);
+        drwav__bswap_samples_s16(pBufferOut, framesRead * pWav->channels);
     }
 
     return framesRead;
 }
 
-DRWAV_API drwav_uint64 drwav_read_pcm_frames_s16be(drwav* pWav, drwav_uint64 framesToRead, drwav_int16* pBufferOut)
-{
+DRWAV_API drwav_uint64 drwav_read_pcm_frames_s16be(drwav * pWav, drwav_uint64 framesToRead, drwav_int16 * pBufferOut) {
     drwav_uint64 framesRead = drwav_read_pcm_frames_s16(pWav, framesToRead, pBufferOut);
     if (pBufferOut != NULL && drwav__is_little_endian() == DRWAV_TRUE) {
-        drwav__bswap_samples_s16(pBufferOut, framesRead*pWav->channels);
+        drwav__bswap_samples_s16(pBufferOut, framesRead * pWav->channels);
     }
 
     return framesRead;
 }
 
-
-DRWAV_API void drwav_u8_to_s16(drwav_int16* pOut, const drwav_uint8* pIn, size_t sampleCount)
-{
-    int r;
+DRWAV_API void drwav_u8_to_s16(drwav_int16 * pOut, const drwav_uint8 * pIn, size_t sampleCount) {
+    int    r;
     size_t i;
     for (i = 0; i < sampleCount; ++i) {
-        int x = pIn[i];
-        r = x << 8;
-        r = r - 32768;
-        pOut[i] = (short)r;
+        int x   = pIn[i];
+        r       = x << 8;
+        r       = r - 32768;
+        pOut[i] = (short) r;
     }
 }
 
-DRWAV_API void drwav_s24_to_s16(drwav_int16* pOut, const drwav_uint8* pIn, size_t sampleCount)
-{
-    int r;
+DRWAV_API void drwav_s24_to_s16(drwav_int16 * pOut, const drwav_uint8 * pIn, size_t sampleCount) {
+    int    r;
     size_t i;
     for (i = 0; i < sampleCount; ++i) {
-        int x = ((int)(((unsigned int)(((const drwav_uint8*)pIn)[i*3+0]) << 8) | ((unsigned int)(((const drwav_uint8*)pIn)[i*3+1]) << 16) | ((unsigned int)(((const drwav_uint8*)pIn)[i*3+2])) << 24)) >> 8;
-        r = x >> 8;
-        pOut[i] = (short)r;
+        int x   = ((int) (((unsigned int) (((const drwav_uint8 *) pIn)[i * 3 + 0]) << 8) |
+                          ((unsigned int) (((const drwav_uint8 *) pIn)[i * 3 + 1]) << 16) |
+                          ((unsigned int) (((const drwav_uint8 *) pIn)[i * 3 + 2])) << 24)) >>
+                  8;
+        r       = x >> 8;
+        pOut[i] = (short) r;
     }
 }
 
-DRWAV_API void drwav_s32_to_s16(drwav_int16* pOut, const drwav_int32* pIn, size_t sampleCount)
-{
-    int r;
+DRWAV_API void drwav_s32_to_s16(drwav_int16 * pOut, const drwav_int32 * pIn, size_t sampleCount) {
+    int    r;
     size_t i;
     for (i = 0; i < sampleCount; ++i) {
-        int x = pIn[i];
-        r = x >> 16;
-        pOut[i] = (short)r;
+        int x   = pIn[i];
+        r       = x >> 16;
+        pOut[i] = (short) r;
     }
 }
 
-DRWAV_API void drwav_f32_to_s16(drwav_int16* pOut, const float* pIn, size_t sampleCount)
-{
-    int r;
+DRWAV_API void drwav_f32_to_s16(drwav_int16 * pOut, const float * pIn, size_t sampleCount) {
+    int    r;
     size_t i;
     for (i = 0; i < sampleCount; ++i) {
         float x = pIn[i];
         float c;
-        c = ((x < -1) ? -1 : ((x > 1) ? 1 : x));
-        c = c + 1;
-        r = (int)(c * 32767.5f);
-        r = r - 32768;
-        pOut[i] = (short)r;
+        c       = ((x < -1) ? -1 : ((x > 1) ? 1 : x));
+        c       = c + 1;
+        r       = (int) (c * 32767.5f);
+        r       = r - 32768;
+        pOut[i] = (short) r;
     }
 }
 
-DRWAV_API void drwav_f64_to_s16(drwav_int16* pOut, const double* pIn, size_t sampleCount)
-{
-    int r;
+DRWAV_API void drwav_f64_to_s16(drwav_int16 * pOut, const double * pIn, size_t sampleCount) {
+    int    r;
     size_t i;
     for (i = 0; i < sampleCount; ++i) {
         double x = pIn[i];
         double c;
-        c = ((x < -1) ? -1 : ((x > 1) ? 1 : x));
-        c = c + 1;
-        r = (int)(c * 32767.5);
-        r = r - 32768;
-        pOut[i] = (short)r;
+        c       = ((x < -1) ? -1 : ((x > 1) ? 1 : x));
+        c       = c + 1;
+        r       = (int) (c * 32767.5);
+        r       = r - 32768;
+        pOut[i] = (short) r;
     }
 }
 
-DRWAV_API void drwav_alaw_to_s16(drwav_int16* pOut, const drwav_uint8* pIn, size_t sampleCount)
-{
+DRWAV_API void drwav_alaw_to_s16(drwav_int16 * pOut, const drwav_uint8 * pIn, size_t sampleCount) {
     size_t i;
     for (i = 0; i < sampleCount; ++i) {
         pOut[i] = drwav__alaw_to_s16(pIn[i]);
     }
 }
 
-DRWAV_API void drwav_mulaw_to_s16(drwav_int16* pOut, const drwav_uint8* pIn, size_t sampleCount)
-{
+DRWAV_API void drwav_mulaw_to_s16(drwav_int16 * pOut, const drwav_uint8 * pIn, size_t sampleCount) {
     size_t i;
     for (i = 0; i < sampleCount; ++i) {
         pOut[i] = drwav__mulaw_to_s16(pIn[i]);
     }
 }
 
-
-
-static void drwav__pcm_to_f32(float* pOut, const drwav_uint8* pIn, size_t sampleCount, unsigned int bytesPerSample)
-{
+static void drwav__pcm_to_f32(float * pOut, const drwav_uint8 * pIn, size_t sampleCount, unsigned int bytesPerSample) {
     unsigned int i;
 
     /* Special case for 8-bit sample data because it's treated as unsigned. */
@@ -4633,7 +5116,7 @@ static void drwav__pcm_to_f32(float* pOut, const drwav_uint8* pIn, size_t sample
 
     /* Slightly more optimal implementation for common formats. */
     if (bytesPerSample == 2) {
-        drwav_s16_to_f32(pOut, (const drwav_int16*)pIn, sampleCount);
+        drwav_s16_to_f32(pOut, (const drwav_int16 *) pIn, sampleCount);
         return;
     }
     if (bytesPerSample == 3) {
@@ -4641,18 +5124,16 @@ static void drwav__pcm_to_f32(float* pOut, const drwav_uint8* pIn, size_t sample
         return;
     }
     if (bytesPerSample == 4) {
-        drwav_s32_to_f32(pOut, (const drwav_int32*)pIn, sampleCount);
+        drwav_s32_to_f32(pOut, (const drwav_int32 *) pIn, sampleCount);
         return;
     }
 
-
     /* Anything more than 64 bits per sample is not supported. */
     if (bytesPerSample > 8) {
         DRWAV_ZERO_MEMORY(pOut, sampleCount * sizeof(*pOut));
         return;
     }
 
-
     /* Generic, slow converter. */
     for (i = 0; i < sampleCount; ++i) {
         drwav_uint64 sample = 0;
@@ -4661,25 +5142,24 @@ static void drwav__pcm_to_f32(float* pOut, const drwav_uint8* pIn, size_t sample
         unsigned int j;
         for (j = 0; j < bytesPerSample; j += 1) {
             DRWAV_ASSERT(j < 8);
-            sample |= (drwav_uint64)(pIn[j]) << shift;
-            shift  += 8;
+            sample |= (drwav_uint64) (pIn[j]) << shift;
+            shift += 8;
         }
 
         pIn += j;
-        *pOut++ = (float)((drwav_int64)sample / 9223372036854775807.0);
+        *pOut++ = (float) ((drwav_int64) sample / 9223372036854775807.0);
     }
 }
 
-static void drwav__ieee_to_f32(float* pOut, const drwav_uint8* pIn, size_t sampleCount, unsigned int bytesPerSample)
-{
+static void drwav__ieee_to_f32(float * pOut, const drwav_uint8 * pIn, size_t sampleCount, unsigned int bytesPerSample) {
     if (bytesPerSample == 4) {
         unsigned int i;
         for (i = 0; i < sampleCount; ++i) {
-            *pOut++ = ((const float*)pIn)[i];
+            *pOut++ = ((const float *) pIn)[i];
         }
         return;
     } else if (bytesPerSample == 8) {
-        drwav_f64_to_f32(pOut, (const double*)pIn, sampleCount);
+        drwav_f64_to_f32(pOut, (const double *) pIn, sampleCount);
         return;
     } else {
         /* Only supporting 32- and 64-bit float. Output silence in all other cases. Contributions welcome for 16-bit float. */
@@ -4688,11 +5168,9 @@ static void drwav__ieee_to_f32(float* pOut, const drwav_uint8* pIn, size_t sampl
     }
 }
 
-
-static drwav_uint64 drwav_read_pcm_frames_f32__pcm(drwav* pWav, drwav_uint64 framesToRead, float* pBufferOut)
-{
+static drwav_uint64 drwav_read_pcm_frames_f32__pcm(drwav * pWav, drwav_uint64 framesToRead, float * pBufferOut) {
     drwav_uint64 totalFramesRead;
-    drwav_uint8 sampleData[4096];
+    drwav_uint8  sampleData[4096];
 
     drwav_uint32 bytesPerFrame = drwav_get_bytes_per_pcm_frame(pWav);
     if (bytesPerFrame == 0) {
@@ -4702,80 +5180,82 @@ static drwav_uint64 drwav_read_pcm_frames_f32__pcm(drwav* pWav, drwav_uint64 fra
     totalFramesRead = 0;
 
     while (framesToRead > 0) {
-        drwav_uint64 framesRead = drwav_read_pcm_frames(pWav, drwav_min(framesToRead, sizeof(sampleData)/bytesPerFrame), sampleData);
+        drwav_uint64 framesRead =
+            drwav_read_pcm_frames(pWav, drwav_min(framesToRead, sizeof(sampleData) / bytesPerFrame), sampleData);
         if (framesRead == 0) {
             break;
         }
 
-        drwav__pcm_to_f32(pBufferOut, sampleData, (size_t)framesRead*pWav->channels, bytesPerFrame/pWav->channels);
+        drwav__pcm_to_f32(pBufferOut, sampleData, (size_t) framesRead * pWav->channels, bytesPerFrame / pWav->channels);
 
-        pBufferOut      += framesRead*pWav->channels;
-        framesToRead    -= framesRead;
+        pBufferOut += framesRead * pWav->channels;
+        framesToRead -= framesRead;
         totalFramesRead += framesRead;
     }
 
     return totalFramesRead;
 }
 
-static drwav_uint64 drwav_read_pcm_frames_f32__msadpcm(drwav* pWav, drwav_uint64 framesToRead, float* pBufferOut)
-{
+static drwav_uint64 drwav_read_pcm_frames_f32__msadpcm(drwav * pWav, drwav_uint64 framesToRead, float * pBufferOut) {
     /*
     We're just going to borrow the implementation from the drwav_read_s16() since ADPCM is a little bit more complicated than other formats and I don't
     want to duplicate that code.
     */
     drwav_uint64 totalFramesRead = 0;
-    drwav_int16 samples16[2048];
+    drwav_int16  samples16[2048];
     while (framesToRead > 0) {
-        drwav_uint64 framesRead = drwav_read_pcm_frames_s16(pWav, drwav_min(framesToRead, drwav_countof(samples16)/pWav->channels), samples16);
+        drwav_uint64 framesRead = drwav_read_pcm_frames_s16(
+            pWav, drwav_min(framesToRead, drwav_countof(samples16) / pWav->channels), samples16);
         if (framesRead == 0) {
             break;
         }
 
-        drwav_s16_to_f32(pBufferOut, samples16, (size_t)(framesRead*pWav->channels));   /* <-- Safe cast because we're clamping to 2048. */
+        drwav_s16_to_f32(pBufferOut, samples16,
+                         (size_t) (framesRead * pWav->channels)); /* <-- Safe cast because we're clamping to 2048. */
 
-        pBufferOut      += framesRead*pWav->channels;
-        framesToRead    -= framesRead;
+        pBufferOut += framesRead * pWav->channels;
+        framesToRead -= framesRead;
         totalFramesRead += framesRead;
     }
 
     return totalFramesRead;
 }
 
-static drwav_uint64 drwav_read_pcm_frames_f32__ima(drwav* pWav, drwav_uint64 framesToRead, float* pBufferOut)
-{
+static drwav_uint64 drwav_read_pcm_frames_f32__ima(drwav * pWav, drwav_uint64 framesToRead, float * pBufferOut) {
     /*
     We're just going to borrow the implementation from the drwav_read_s16() since IMA-ADPCM is a little bit more complicated than other formats and I don't
     want to duplicate that code.
     */
     drwav_uint64 totalFramesRead = 0;
-    drwav_int16 samples16[2048];
+    drwav_int16  samples16[2048];
     while (framesToRead > 0) {
-        drwav_uint64 framesRead = drwav_read_pcm_frames_s16(pWav, drwav_min(framesToRead, drwav_countof(samples16)/pWav->channels), samples16);
+        drwav_uint64 framesRead = drwav_read_pcm_frames_s16(
+            pWav, drwav_min(framesToRead, drwav_countof(samples16) / pWav->channels), samples16);
         if (framesRead == 0) {
             break;
         }
 
-        drwav_s16_to_f32(pBufferOut, samples16, (size_t)(framesRead*pWav->channels));   /* <-- Safe cast because we're clamping to 2048. */
+        drwav_s16_to_f32(pBufferOut, samples16,
+                         (size_t) (framesRead * pWav->channels)); /* <-- Safe cast because we're clamping to 2048. */
 
-        pBufferOut      += framesRead*pWav->channels;
-        framesToRead    -= framesRead;
+        pBufferOut += framesRead * pWav->channels;
+        framesToRead -= framesRead;
         totalFramesRead += framesRead;
     }
 
     return totalFramesRead;
 }
 
-static drwav_uint64 drwav_read_pcm_frames_f32__ieee(drwav* pWav, drwav_uint64 framesToRead, float* pBufferOut)
-{
+static drwav_uint64 drwav_read_pcm_frames_f32__ieee(drwav * pWav, drwav_uint64 framesToRead, float * pBufferOut) {
     drwav_uint64 totalFramesRead;
-    drwav_uint8 sampleData[4096];
+    drwav_uint8  sampleData[4096];
     drwav_uint32 bytesPerFrame;
 
     /* Fast path. */
     if (pWav->translatedFormatTag == DR_WAVE_FORMAT_IEEE_FLOAT && pWav->bitsPerSample == 32) {
         return drwav_read_pcm_frames(pWav, framesToRead, pBufferOut);
     }
-    
+
     bytesPerFrame = drwav_get_bytes_per_pcm_frame(pWav);
     if (bytesPerFrame == 0) {
         return 0;
@@ -4784,25 +5264,26 @@ static drwav_uint64 drwav_read_pcm_frames_f32__ieee(drwav* pWav, drwav_uint64 fr
     totalFramesRead = 0;
 
     while (framesToRead > 0) {
-        drwav_uint64 framesRead = drwav_read_pcm_frames(pWav, drwav_min(framesToRead, sizeof(sampleData)/bytesPerFrame), sampleData);
+        drwav_uint64 framesRead =
+            drwav_read_pcm_frames(pWav, drwav_min(framesToRead, sizeof(sampleData) / bytesPerFrame), sampleData);
         if (framesRead == 0) {
             break;
         }
 
-        drwav__ieee_to_f32(pBufferOut, sampleData, (size_t)(framesRead*pWav->channels), bytesPerFrame/pWav->channels);
+        drwav__ieee_to_f32(pBufferOut, sampleData, (size_t) (framesRead * pWav->channels),
+                           bytesPerFrame / pWav->channels);
 
-        pBufferOut      += framesRead*pWav->channels;
-        framesToRead    -= framesRead;
+        pBufferOut += framesRead * pWav->channels;
+        framesToRead -= framesRead;
         totalFramesRead += framesRead;
     }
 
     return totalFramesRead;
 }
 
-static drwav_uint64 drwav_read_pcm_frames_f32__alaw(drwav* pWav, drwav_uint64 framesToRead, float* pBufferOut)
-{
+static drwav_uint64 drwav_read_pcm_frames_f32__alaw(drwav * pWav, drwav_uint64 framesToRead, float * pBufferOut) {
     drwav_uint64 totalFramesRead;
-    drwav_uint8 sampleData[4096];
+    drwav_uint8  sampleData[4096];
     drwav_uint32 bytesPerFrame = drwav_get_bytes_per_pcm_frame(pWav);
     if (bytesPerFrame == 0) {
         return 0;
@@ -4811,25 +5292,25 @@ static drwav_uint64 drwav_read_pcm_frames_f32__alaw(drwav* pWav, drwav_uint64 fr
     totalFramesRead = 0;
 
     while (framesToRead > 0) {
-        drwav_uint64 framesRead = drwav_read_pcm_frames(pWav, drwav_min(framesToRead, sizeof(sampleData)/bytesPerFrame), sampleData);
+        drwav_uint64 framesRead =
+            drwav_read_pcm_frames(pWav, drwav_min(framesToRead, sizeof(sampleData) / bytesPerFrame), sampleData);
         if (framesRead == 0) {
             break;
         }
 
-        drwav_alaw_to_f32(pBufferOut, sampleData, (size_t)(framesRead*pWav->channels));
+        drwav_alaw_to_f32(pBufferOut, sampleData, (size_t) (framesRead * pWav->channels));
 
-        pBufferOut      += framesRead*pWav->channels;
-        framesToRead    -= framesRead;
+        pBufferOut += framesRead * pWav->channels;
+        framesToRead -= framesRead;
         totalFramesRead += framesRead;
     }
 
     return totalFramesRead;
 }
 
-static drwav_uint64 drwav_read_pcm_frames_f32__mulaw(drwav* pWav, drwav_uint64 framesToRead, float* pBufferOut)
-{
+static drwav_uint64 drwav_read_pcm_frames_f32__mulaw(drwav * pWav, drwav_uint64 framesToRead, float * pBufferOut) {
     drwav_uint64 totalFramesRead;
-    drwav_uint8 sampleData[4096];
+    drwav_uint8  sampleData[4096];
 
     drwav_uint32 bytesPerFrame = drwav_get_bytes_per_pcm_frame(pWav);
     if (bytesPerFrame == 0) {
@@ -4839,23 +5320,23 @@ static drwav_uint64 drwav_read_pcm_frames_f32__mulaw(drwav* pWav, drwav_uint64 f
     totalFramesRead = 0;
 
     while (framesToRead > 0) {
-        drwav_uint64 framesRead = drwav_read_pcm_frames(pWav, drwav_min(framesToRead, sizeof(sampleData)/bytesPerFrame), sampleData);
+        drwav_uint64 framesRead =
+            drwav_read_pcm_frames(pWav, drwav_min(framesToRead, sizeof(sampleData) / bytesPerFrame), sampleData);
         if (framesRead == 0) {
             break;
         }
 
-        drwav_mulaw_to_f32(pBufferOut, sampleData, (size_t)(framesRead*pWav->channels));
+        drwav_mulaw_to_f32(pBufferOut, sampleData, (size_t) (framesRead * pWav->channels));
 
-        pBufferOut      += framesRead*pWav->channels;
-        framesToRead    -= framesRead;
+        pBufferOut += framesRead * pWav->channels;
+        framesToRead -= framesRead;
         totalFramesRead += framesRead;
     }
 
     return totalFramesRead;
 }
 
-DRWAV_API drwav_uint64 drwav_read_pcm_frames_f32(drwav* pWav, drwav_uint64 framesToRead, float* pBufferOut)
-{
+DRWAV_API drwav_uint64 drwav_read_pcm_frames_f32(drwav * pWav, drwav_uint64 framesToRead, float * pBufferOut) {
     if (pWav == NULL || framesToRead == 0) {
         return 0;
     }
@@ -4896,36 +5377,32 @@ DRWAV_API drwav_uint64 drwav_read_pcm_frames_f32(drwav* pWav, drwav_uint64 frame
     return 0;
 }
 
-DRWAV_API drwav_uint64 drwav_read_pcm_frames_f32le(drwav* pWav, drwav_uint64 framesToRead, float* pBufferOut)
-{
+DRWAV_API drwav_uint64 drwav_read_pcm_frames_f32le(drwav * pWav, drwav_uint64 framesToRead, float * pBufferOut) {
     drwav_uint64 framesRead = drwav_read_pcm_frames_f32(pWav, framesToRead, pBufferOut);
     if (pBufferOut != NULL && drwav__is_little_endian() == DRWAV_FALSE) {
-        drwav__bswap_samples_f32(pBufferOut, framesRead*pWav->channels);
+        drwav__bswap_samples_f32(pBufferOut, framesRead * pWav->channels);
     }
 
     return framesRead;
 }
 
-DRWAV_API drwav_uint64 drwav_read_pcm_frames_f32be(drwav* pWav, drwav_uint64 framesToRead, float* pBufferOut)
-{
+DRWAV_API drwav_uint64 drwav_read_pcm_frames_f32be(drwav * pWav, drwav_uint64 framesToRead, float * pBufferOut) {
     drwav_uint64 framesRead = drwav_read_pcm_frames_f32(pWav, framesToRead, pBufferOut);
     if (pBufferOut != NULL && drwav__is_little_endian() == DRWAV_TRUE) {
-        drwav__bswap_samples_f32(pBufferOut, framesRead*pWav->channels);
+        drwav__bswap_samples_f32(pBufferOut, framesRead * pWav->channels);
     }
 
     return framesRead;
 }
 
-
-DRWAV_API void drwav_u8_to_f32(float* pOut, const drwav_uint8* pIn, size_t sampleCount)
-{
+DRWAV_API void drwav_u8_to_f32(float * pOut, const drwav_uint8 * pIn, size_t sampleCount) {
     size_t i;
 
     if (pOut == NULL || pIn == NULL) {
         return;
     }
 
-#ifdef DR_WAV_LIBSNDFILE_COMPAT
+#            ifdef DR_WAV_LIBSNDFILE_COMPAT
     /*
     It appears libsndfile uses slightly different logic for the u8 -> f32 conversion to dr_wav, which in my opinion is incorrect. It appears
     libsndfile performs the conversion something like "f32 = (u8 / 256) * 2 - 1", however I think it should be "f32 = (u8 / 255) * 2 - 1" (note
@@ -4935,19 +5412,18 @@ DRWAV_API void drwav_u8_to_f32(float* pOut, const drwav_uint8* pIn, size_t sampl
     for (i = 0; i < sampleCount; ++i) {
         *pOut++ = (pIn[i] / 256.0f) * 2 - 1;
     }
-#else
+#            else
     for (i = 0; i < sampleCount; ++i) {
         float x = pIn[i];
-        x = x * 0.00784313725490196078f;    /* 0..255 to 0..2 */
-        x = x - 1;                          /* 0..2 to -1..1 */
+        x       = x * 0.00784313725490196078f; /* 0..255 to 0..2 */
+        x       = x - 1;                       /* 0..2 to -1..1 */
 
         *pOut++ = x;
     }
-#endif
+#            endif
 }
 
-DRWAV_API void drwav_s16_to_f32(float* pOut, const drwav_int16* pIn, size_t sampleCount)
-{
+DRWAV_API void drwav_s16_to_f32(float * pOut, const drwav_int16 * pIn, size_t sampleCount) {
     size_t i;
 
     if (pOut == NULL || pIn == NULL) {
@@ -4959,8 +5435,7 @@ DRWAV_API void drwav_s16_to_f32(float* pOut, const drwav_int16* pIn, size_t samp
     }
 }
 
-DRWAV_API void drwav_s24_to_f32(float* pOut, const drwav_uint8* pIn, size_t sampleCount)
-{
+DRWAV_API void drwav_s24_to_f32(float * pOut, const drwav_uint8 * pIn, size_t sampleCount) {
     size_t i;
 
     if (pOut == NULL || pIn == NULL) {
@@ -4968,30 +5443,28 @@ DRWAV_API void drwav_s24_to_f32(float* pOut, const drwav_uint8* pIn, size_t samp
     }
 
     for (i = 0; i < sampleCount; ++i) {
-        double x;
-        drwav_uint32 a = ((drwav_uint32)(pIn[i*3+0]) <<  8);
-        drwav_uint32 b = ((drwav_uint32)(pIn[i*3+1]) << 16);
-        drwav_uint32 c = ((drwav_uint32)(pIn[i*3+2]) << 24);
+        double       x;
+        drwav_uint32 a = ((drwav_uint32) (pIn[i * 3 + 0]) << 8);
+        drwav_uint32 b = ((drwav_uint32) (pIn[i * 3 + 1]) << 16);
+        drwav_uint32 c = ((drwav_uint32) (pIn[i * 3 + 2]) << 24);
 
-        x = (double)((drwav_int32)(a | b | c) >> 8);
-        *pOut++ = (float)(x * 0.00000011920928955078125);
+        x       = (double) ((drwav_int32) (a | b | c) >> 8);
+        *pOut++ = (float) (x * 0.00000011920928955078125);
     }
 }
 
-DRWAV_API void drwav_s32_to_f32(float* pOut, const drwav_int32* pIn, size_t sampleCount)
-{
+DRWAV_API void drwav_s32_to_f32(float * pOut, const drwav_int32 * pIn, size_t sampleCount) {
     size_t i;
     if (pOut == NULL || pIn == NULL) {
         return;
     }
 
     for (i = 0; i < sampleCount; ++i) {
-        *pOut++ = (float)(pIn[i] / 2147483648.0);
+        *pOut++ = (float) (pIn[i] / 2147483648.0);
     }
 }
 
-DRWAV_API void drwav_f64_to_f32(float* pOut, const double* pIn, size_t sampleCount)
-{
+DRWAV_API void drwav_f64_to_f32(float * pOut, const double * pIn, size_t sampleCount) {
     size_t i;
 
     if (pOut == NULL || pIn == NULL) {
@@ -4999,12 +5472,11 @@ DRWAV_API void drwav_f64_to_f32(float* pOut, const double* pIn, size_t sampleCou
     }
 
     for (i = 0; i < sampleCount; ++i) {
-        *pOut++ = (float)pIn[i];
+        *pOut++ = (float) pIn[i];
     }
 }
 
-DRWAV_API void drwav_alaw_to_f32(float* pOut, const drwav_uint8* pIn, size_t sampleCount)
-{
+DRWAV_API void drwav_alaw_to_f32(float * pOut, const drwav_uint8 * pIn, size_t sampleCount) {
     size_t i;
 
     if (pOut == NULL || pIn == NULL) {
@@ -5016,8 +5488,7 @@ DRWAV_API void drwav_alaw_to_f32(float* pOut, const drwav_uint8* pIn, size_t sam
     }
 }
 
-DRWAV_API void drwav_mulaw_to_f32(float* pOut, const drwav_uint8* pIn, size_t sampleCount)
-{
+DRWAV_API void drwav_mulaw_to_f32(float * pOut, const drwav_uint8 * pIn, size_t sampleCount) {
     size_t i;
 
     if (pOut == NULL || pIn == NULL) {
@@ -5029,10 +5500,10 @@ DRWAV_API void drwav_mulaw_to_f32(float* pOut, const drwav_uint8* pIn, size_t sa
     }
 }
 
-
-
-static void drwav__pcm_to_s32(drwav_int32* pOut, const drwav_uint8* pIn, size_t totalSampleCount, unsigned int bytesPerSample)
-{
+static void drwav__pcm_to_s32(drwav_int32 *       pOut,
+                              const drwav_uint8 * pIn,
+                              size_t              totalSampleCount,
+                              unsigned int        bytesPerSample) {
     unsigned int i;
 
     /* Special case for 8-bit sample data because it's treated as unsigned. */
@@ -5043,7 +5514,7 @@ static void drwav__pcm_to_s32(drwav_int32* pOut, const drwav_uint8* pIn, size_t
 
     /* Slightly more optimal implementation for common formats. */
     if (bytesPerSample == 2) {
-        drwav_s16_to_s32(pOut, (const drwav_int16*)pIn, totalSampleCount);
+        drwav_s16_to_s32(pOut, (const drwav_int16 *) pIn, totalSampleCount);
         return;
     }
     if (bytesPerSample == 3) {
@@ -5052,19 +5523,17 @@ static void drwav__pcm_to_s32(drwav_int32* pOut, const drwav_uint8* pIn, size_t
     }
     if (bytesPerSample == 4) {
         for (i = 0; i < totalSampleCount; ++i) {
-           *pOut++ = ((const drwav_int32*)pIn)[i];
+            *pOut++ = ((const drwav_int32 *) pIn)[i];
         }
         return;
     }
 
-
     /* Anything more than 64 bits per sample is not supported. */
     if (bytesPerSample > 8) {
         DRWAV_ZERO_MEMORY(pOut, totalSampleCount * sizeof(*pOut));
         return;
     }
 
-
     /* Generic, slow converter. */
     for (i = 0; i < totalSampleCount; ++i) {
         drwav_uint64 sample = 0;
@@ -5073,22 +5542,24 @@ static void drwav__pcm_to_s32(drwav_int32* pOut, const drwav_uint8* pIn, size_t
         unsigned int j;
         for (j = 0; j < bytesPerSample; j += 1) {
             DRWAV_ASSERT(j < 8);
-            sample |= (drwav_uint64)(pIn[j]) << shift;
-            shift  += 8;
+            sample |= (drwav_uint64) (pIn[j]) << shift;
+            shift += 8;
         }
 
         pIn += j;
-        *pOut++ = (drwav_int32)((drwav_int64)sample >> 32);
+        *pOut++ = (drwav_int32) ((drwav_int64) sample >> 32);
     }
 }
 
-static void drwav__ieee_to_s32(drwav_int32* pOut, const drwav_uint8* pIn, size_t totalSampleCount, unsigned int bytesPerSample)
-{
+static void drwav__ieee_to_s32(drwav_int32 *       pOut,
+                               const drwav_uint8 * pIn,
+                               size_t              totalSampleCount,
+                               unsigned int        bytesPerSample) {
     if (bytesPerSample == 4) {
-        drwav_f32_to_s32(pOut, (const float*)pIn, totalSampleCount);
+        drwav_f32_to_s32(pOut, (const float *) pIn, totalSampleCount);
         return;
     } else if (bytesPerSample == 8) {
-        drwav_f64_to_s32(pOut, (const double*)pIn, totalSampleCount);
+        drwav_f64_to_s32(pOut, (const double *) pIn, totalSampleCount);
         return;
     } else {
         /* Only supporting 32- and 64-bit float. Output silence in all other cases. Contributions welcome for 16-bit float. */
@@ -5097,18 +5568,16 @@ static void drwav__ieee_to_s32(drwav_int32* pOut, const drwav_uint8* pIn, size_t
     }
 }
 
-
-static drwav_uint64 drwav_read_pcm_frames_s32__pcm(drwav* pWav, drwav_uint64 framesToRead, drwav_int32* pBufferOut)
-{
+static drwav_uint64 drwav_read_pcm_frames_s32__pcm(drwav * pWav, drwav_uint64 framesToRead, drwav_int32 * pBufferOut) {
     drwav_uint64 totalFramesRead;
-    drwav_uint8 sampleData[4096];
+    drwav_uint8  sampleData[4096];
     drwav_uint32 bytesPerFrame;
 
     /* Fast path. */
     if (pWav->translatedFormatTag == DR_WAVE_FORMAT_PCM && pWav->bitsPerSample == 32) {
         return drwav_read_pcm_frames(pWav, framesToRead, pBufferOut);
     }
-    
+
     bytesPerFrame = drwav_get_bytes_per_pcm_frame(pWav);
     if (bytesPerFrame == 0) {
         return 0;
@@ -5117,73 +5586,78 @@ static drwav_uint64 drwav_read_pcm_frames_s32__pcm(drwav* pWav, drwav_uint64 fra
     totalFramesRead = 0;
 
     while (framesToRead > 0) {
-        drwav_uint64 framesRead = drwav_read_pcm_frames(pWav, drwav_min(framesToRead, sizeof(sampleData)/bytesPerFrame), sampleData);
+        drwav_uint64 framesRead =
+            drwav_read_pcm_frames(pWav, drwav_min(framesToRead, sizeof(sampleData) / bytesPerFrame), sampleData);
         if (framesRead == 0) {
             break;
         }
 
-        drwav__pcm_to_s32(pBufferOut, sampleData, (size_t)(framesRead*pWav->channels), bytesPerFrame/pWav->channels);
+        drwav__pcm_to_s32(pBufferOut, sampleData, (size_t) (framesRead * pWav->channels),
+                          bytesPerFrame / pWav->channels);
 
-        pBufferOut      += framesRead*pWav->channels;
-        framesToRead    -= framesRead;
+        pBufferOut += framesRead * pWav->channels;
+        framesToRead -= framesRead;
         totalFramesRead += framesRead;
     }
 
     return totalFramesRead;
 }
 
-static drwav_uint64 drwav_read_pcm_frames_s32__msadpcm(drwav* pWav, drwav_uint64 framesToRead, drwav_int32* pBufferOut)
-{
+static drwav_uint64 drwav_read_pcm_frames_s32__msadpcm(drwav *       pWav,
+                                                       drwav_uint64  framesToRead,
+                                                       drwav_int32 * pBufferOut) {
     /*
     We're just going to borrow the implementation from the drwav_read_s16() since ADPCM is a little bit more complicated than other formats and I don't
     want to duplicate that code.
     */
     drwav_uint64 totalFramesRead = 0;
-    drwav_int16 samples16[2048];
+    drwav_int16  samples16[2048];
     while (framesToRead > 0) {
-        drwav_uint64 framesRead = drwav_read_pcm_frames_s16(pWav, drwav_min(framesToRead, drwav_countof(samples16)/pWav->channels), samples16);
+        drwav_uint64 framesRead = drwav_read_pcm_frames_s16(
+            pWav, drwav_min(framesToRead, drwav_countof(samples16) / pWav->channels), samples16);
         if (framesRead == 0) {
             break;
         }
 
-        drwav_s16_to_s32(pBufferOut, samples16, (size_t)(framesRead*pWav->channels));   /* <-- Safe cast because we're clamping to 2048. */
+        drwav_s16_to_s32(pBufferOut, samples16,
+                         (size_t) (framesRead * pWav->channels)); /* <-- Safe cast because we're clamping to 2048. */
 
-        pBufferOut      += framesRead*pWav->channels;
-        framesToRead    -= framesRead;
+        pBufferOut += framesRead * pWav->channels;
+        framesToRead -= framesRead;
         totalFramesRead += framesRead;
     }
 
     return totalFramesRead;
 }
 
-static drwav_uint64 drwav_read_pcm_frames_s32__ima(drwav* pWav, drwav_uint64 framesToRead, drwav_int32* pBufferOut)
-{
+static drwav_uint64 drwav_read_pcm_frames_s32__ima(drwav * pWav, drwav_uint64 framesToRead, drwav_int32 * pBufferOut) {
     /*
     We're just going to borrow the implementation from the drwav_read_s16() since IMA-ADPCM is a little bit more complicated than other formats and I don't
     want to duplicate that code.
     */
     drwav_uint64 totalFramesRead = 0;
-    drwav_int16 samples16[2048];
+    drwav_int16  samples16[2048];
     while (framesToRead > 0) {
-        drwav_uint64 framesRead = drwav_read_pcm_frames_s16(pWav, drwav_min(framesToRead, drwav_countof(samples16)/pWav->channels), samples16);
+        drwav_uint64 framesRead = drwav_read_pcm_frames_s16(
+            pWav, drwav_min(framesToRead, drwav_countof(samples16) / pWav->channels), samples16);
         if (framesRead == 0) {
             break;
         }
 
-        drwav_s16_to_s32(pBufferOut, samples16, (size_t)(framesRead*pWav->channels));   /* <-- Safe cast because we're clamping to 2048. */
+        drwav_s16_to_s32(pBufferOut, samples16,
+                         (size_t) (framesRead * pWav->channels)); /* <-- Safe cast because we're clamping to 2048. */
 
-        pBufferOut      += framesRead*pWav->channels;
-        framesToRead    -= framesRead;
+        pBufferOut += framesRead * pWav->channels;
+        framesToRead -= framesRead;
         totalFramesRead += framesRead;
     }
 
     return totalFramesRead;
 }
 
-static drwav_uint64 drwav_read_pcm_frames_s32__ieee(drwav* pWav, drwav_uint64 framesToRead, drwav_int32* pBufferOut)
-{
+static drwav_uint64 drwav_read_pcm_frames_s32__ieee(drwav * pWav, drwav_uint64 framesToRead, drwav_int32 * pBufferOut) {
     drwav_uint64 totalFramesRead;
-    drwav_uint8 sampleData[4096];
+    drwav_uint8  sampleData[4096];
 
     drwav_uint32 bytesPerFrame = drwav_get_bytes_per_pcm_frame(pWav);
     if (bytesPerFrame == 0) {
@@ -5193,25 +5667,26 @@ static drwav_uint64 drwav_read_pcm_frames_s32__ieee(drwav* pWav, drwav_uint64 fr
     totalFramesRead = 0;
 
     while (framesToRead > 0) {
-        drwav_uint64 framesRead = drwav_read_pcm_frames(pWav, drwav_min(framesToRead, sizeof(sampleData)/bytesPerFrame), sampleData);
+        drwav_uint64 framesRead =
+            drwav_read_pcm_frames(pWav, drwav_min(framesToRead, sizeof(sampleData) / bytesPerFrame), sampleData);
         if (framesRead == 0) {
             break;
         }
 
-        drwav__ieee_to_s32(pBufferOut, sampleData, (size_t)(framesRead*pWav->channels), bytesPerFrame/pWav->channels);
+        drwav__ieee_to_s32(pBufferOut, sampleData, (size_t) (framesRead * pWav->channels),
+                           bytesPerFrame / pWav->channels);
 
-        pBufferOut      += framesRead*pWav->channels;
-        framesToRead    -= framesRead;
+        pBufferOut += framesRead * pWav->channels;
+        framesToRead -= framesRead;
         totalFramesRead += framesRead;
     }
 
     return totalFramesRead;
 }
 
-static drwav_uint64 drwav_read_pcm_frames_s32__alaw(drwav* pWav, drwav_uint64 framesToRead, drwav_int32* pBufferOut)
-{
+static drwav_uint64 drwav_read_pcm_frames_s32__alaw(drwav * pWav, drwav_uint64 framesToRead, drwav_int32 * pBufferOut) {
     drwav_uint64 totalFramesRead;
-    drwav_uint8 sampleData[4096];
+    drwav_uint8  sampleData[4096];
 
     drwav_uint32 bytesPerFrame = drwav_get_bytes_per_pcm_frame(pWav);
     if (bytesPerFrame == 0) {
@@ -5221,25 +5696,27 @@ static drwav_uint64 drwav_read_pcm_frames_s32__alaw(drwav* pWav, drwav_uint64 fr
     totalFramesRead = 0;
 
     while (framesToRead > 0) {
-        drwav_uint64 framesRead = drwav_read_pcm_frames(pWav, drwav_min(framesToRead, sizeof(sampleData)/bytesPerFrame), sampleData);
+        drwav_uint64 framesRead =
+            drwav_read_pcm_frames(pWav, drwav_min(framesToRead, sizeof(sampleData) / bytesPerFrame), sampleData);
         if (framesRead == 0) {
             break;
         }
 
-        drwav_alaw_to_s32(pBufferOut, sampleData, (size_t)(framesRead*pWav->channels));
+        drwav_alaw_to_s32(pBufferOut, sampleData, (size_t) (framesRead * pWav->channels));
 
-        pBufferOut      += framesRead*pWav->channels;
-        framesToRead    -= framesRead;
+        pBufferOut += framesRead * pWav->channels;
+        framesToRead -= framesRead;
         totalFramesRead += framesRead;
     }
 
     return totalFramesRead;
 }
 
-static drwav_uint64 drwav_read_pcm_frames_s32__mulaw(drwav* pWav, drwav_uint64 framesToRead, drwav_int32* pBufferOut)
-{
+static drwav_uint64 drwav_read_pcm_frames_s32__mulaw(drwav *       pWav,
+                                                     drwav_uint64  framesToRead,
+                                                     drwav_int32 * pBufferOut) {
     drwav_uint64 totalFramesRead;
-    drwav_uint8 sampleData[4096];
+    drwav_uint8  sampleData[4096];
 
     drwav_uint32 bytesPerFrame = drwav_get_bytes_per_pcm_frame(pWav);
     if (bytesPerFrame == 0) {
@@ -5249,23 +5726,23 @@ static drwav_uint64 drwav_read_pcm_frames_s32__mulaw(drwav* pWav, drwav_uint64 f
     totalFramesRead = 0;
 
     while (framesToRead > 0) {
-        drwav_uint64 framesRead = drwav_read_pcm_frames(pWav, drwav_min(framesToRead, sizeof(sampleData)/bytesPerFrame), sampleData);
+        drwav_uint64 framesRead =
+            drwav_read_pcm_frames(pWav, drwav_min(framesToRead, sizeof(sampleData) / bytesPerFrame), sampleData);
         if (framesRead == 0) {
             break;
         }
 
-        drwav_mulaw_to_s32(pBufferOut, sampleData, (size_t)(framesRead*pWav->channels));
+        drwav_mulaw_to_s32(pBufferOut, sampleData, (size_t) (framesRead * pWav->channels));
 
-        pBufferOut      += framesRead*pWav->channels;
-        framesToRead    -= framesRead;
+        pBufferOut += framesRead * pWav->channels;
+        framesToRead -= framesRead;
         totalFramesRead += framesRead;
     }
 
     return totalFramesRead;
 }
 
-DRWAV_API drwav_uint64 drwav_read_pcm_frames_s32(drwav* pWav, drwav_uint64 framesToRead, drwav_int32* pBufferOut)
-{
+DRWAV_API drwav_uint64 drwav_read_pcm_frames_s32(drwav * pWav, drwav_uint64 framesToRead, drwav_int32 * pBufferOut) {
     if (pWav == NULL || framesToRead == 0) {
         return 0;
     }
@@ -5306,29 +5783,25 @@ DRWAV_API drwav_uint64 drwav_read_pcm_frames_s32(drwav* pWav, drwav_uint64 frame
     return 0;
 }
 
-DRWAV_API drwav_uint64 drwav_read_pcm_frames_s32le(drwav* pWav, drwav_uint64 framesToRead, drwav_int32* pBufferOut)
-{
+DRWAV_API drwav_uint64 drwav_read_pcm_frames_s32le(drwav * pWav, drwav_uint64 framesToRead, drwav_int32 * pBufferOut) {
     drwav_uint64 framesRead = drwav_read_pcm_frames_s32(pWav, framesToRead, pBufferOut);
     if (pBufferOut != NULL && drwav__is_little_endian() == DRWAV_FALSE) {
-        drwav__bswap_samples_s32(pBufferOut, framesRead*pWav->channels);
+        drwav__bswap_samples_s32(pBufferOut, framesRead * pWav->channels);
     }
 
     return framesRead;
 }
 
-DRWAV_API drwav_uint64 drwav_read_pcm_frames_s32be(drwav* pWav, drwav_uint64 framesToRead, drwav_int32* pBufferOut)
-{
+DRWAV_API drwav_uint64 drwav_read_pcm_frames_s32be(drwav * pWav, drwav_uint64 framesToRead, drwav_int32 * pBufferOut) {
     drwav_uint64 framesRead = drwav_read_pcm_frames_s32(pWav, framesToRead, pBufferOut);
     if (pBufferOut != NULL && drwav__is_little_endian() == DRWAV_TRUE) {
-        drwav__bswap_samples_s32(pBufferOut, framesRead*pWav->channels);
+        drwav__bswap_samples_s32(pBufferOut, framesRead * pWav->channels);
     }
 
     return framesRead;
 }
 
-
-DRWAV_API void drwav_u8_to_s32(drwav_int32* pOut, const drwav_uint8* pIn, size_t sampleCount)
-{
+DRWAV_API void drwav_u8_to_s32(drwav_int32 * pOut, const drwav_uint8 * pIn, size_t sampleCount) {
     size_t i;
 
     if (pOut == NULL || pIn == NULL) {
@@ -5336,12 +5809,11 @@ DRWAV_API void drwav_u8_to_s32(drwav_int32* pOut, const drwav_uint8* pIn, size_t
     }
 
     for (i = 0; i < sampleCount; ++i) {
-        *pOut++ = ((int)pIn[i] - 128) << 24;
+        *pOut++ = ((int) pIn[i] - 128) << 24;
     }
 }
 
-DRWAV_API void drwav_s16_to_s32(drwav_int32* pOut, const drwav_int16* pIn, size_t sampleCount)
-{
+DRWAV_API void drwav_s16_to_s32(drwav_int32 * pOut, const drwav_int16 * pIn, size_t sampleCount) {
     size_t i;
 
     if (pOut == NULL || pIn == NULL) {
@@ -5353,8 +5825,7 @@ DRWAV_API void drwav_s16_to_s32(drwav_int32* pOut, const drwav_int16* pIn, size_
     }
 }
 
-DRWAV_API void drwav_s24_to_s32(drwav_int32* pOut, const drwav_uint8* pIn, size_t sampleCount)
-{
+DRWAV_API void drwav_s24_to_s32(drwav_int32 * pOut, const drwav_uint8 * pIn, size_t sampleCount) {
     size_t i;
 
     if (pOut == NULL || pIn == NULL) {
@@ -5362,17 +5833,16 @@ DRWAV_API void drwav_s24_to_s32(drwav_int32* pOut, const drwav_uint8* pIn, size_
     }
 
     for (i = 0; i < sampleCount; ++i) {
-        unsigned int s0 = pIn[i*3 + 0];
-        unsigned int s1 = pIn[i*3 + 1];
-        unsigned int s2 = pIn[i*3 + 2];
+        unsigned int s0 = pIn[i * 3 + 0];
+        unsigned int s1 = pIn[i * 3 + 1];
+        unsigned int s2 = pIn[i * 3 + 2];
 
-        drwav_int32 sample32 = (drwav_int32)((s0 << 8) | (s1 << 16) | (s2 << 24));
-        *pOut++ = sample32;
+        drwav_int32 sample32 = (drwav_int32) ((s0 << 8) | (s1 << 16) | (s2 << 24));
+        *pOut++              = sample32;
     }
 }
 
-DRWAV_API void drwav_f32_to_s32(drwav_int32* pOut, const float* pIn, size_t sampleCount)
-{
+DRWAV_API void drwav_f32_to_s32(drwav_int32 * pOut, const float * pIn, size_t sampleCount) {
     size_t i;
 
     if (pOut == NULL || pIn == NULL) {
@@ -5380,12 +5850,11 @@ DRWAV_API void drwav_f32_to_s32(drwav_int32* pOut, const float* pIn, size_t samp
     }
 
     for (i = 0; i < sampleCount; ++i) {
-        *pOut++ = (drwav_int32)(2147483648.0 * pIn[i]);
+        *pOut++ = (drwav_int32) (2147483648.0 * pIn[i]);
     }
 }
 
-DRWAV_API void drwav_f64_to_s32(drwav_int32* pOut, const double* pIn, size_t sampleCount)
-{
+DRWAV_API void drwav_f64_to_s32(drwav_int32 * pOut, const double * pIn, size_t sampleCount) {
     size_t i;
 
     if (pOut == NULL || pIn == NULL) {
@@ -5393,12 +5862,11 @@ DRWAV_API void drwav_f64_to_s32(drwav_int32* pOut, const double* pIn, size_t sam
     }
 
     for (i = 0; i < sampleCount; ++i) {
-        *pOut++ = (drwav_int32)(2147483648.0 * pIn[i]);
+        *pOut++ = (drwav_int32) (2147483648.0 * pIn[i]);
     }
 }
 
-DRWAV_API void drwav_alaw_to_s32(drwav_int32* pOut, const drwav_uint8* pIn, size_t sampleCount)
-{
+DRWAV_API void drwav_alaw_to_s32(drwav_int32 * pOut, const drwav_uint8 * pIn, size_t sampleCount) {
     size_t i;
 
     if (pOut == NULL || pIn == NULL) {
@@ -5406,50 +5874,50 @@ DRWAV_API void drwav_alaw_to_s32(drwav_int32* pOut, const drwav_uint8* pIn, size
     }
 
     for (i = 0; i < sampleCount; ++i) {
-        *pOut++ = ((drwav_int32)drwav__alaw_to_s16(pIn[i])) << 16;
+        *pOut++ = ((drwav_int32) drwav__alaw_to_s16(pIn[i])) << 16;
     }
 }
 
-DRWAV_API void drwav_mulaw_to_s32(drwav_int32* pOut, const drwav_uint8* pIn, size_t sampleCount)
-{
+DRWAV_API void drwav_mulaw_to_s32(drwav_int32 * pOut, const drwav_uint8 * pIn, size_t sampleCount) {
     size_t i;
 
     if (pOut == NULL || pIn == NULL) {
         return;
     }
 
-    for (i= 0; i < sampleCount; ++i) {
-        *pOut++ = ((drwav_int32)drwav__mulaw_to_s16(pIn[i])) << 16;
+    for (i = 0; i < sampleCount; ++i) {
+        *pOut++ = ((drwav_int32) drwav__mulaw_to_s16(pIn[i])) << 16;
     }
 }
 
-
-
-static drwav_int16* drwav__read_pcm_frames_and_close_s16(drwav* pWav, unsigned int* channels, unsigned int* sampleRate, drwav_uint64* totalFrameCount)
-{
-    drwav_uint64 sampleDataSize;
-    drwav_int16* pSampleData;
-    drwav_uint64 framesRead;
+static drwav_int16 * drwav__read_pcm_frames_and_close_s16(drwav *        pWav,
+                                                          unsigned int * channels,
+                                                          unsigned int * sampleRate,
+                                                          drwav_uint64 * totalFrameCount) {
+    drwav_uint64  sampleDataSize;
+    drwav_int16 * pSampleData;
+    drwav_uint64  framesRead;
 
     DRWAV_ASSERT(pWav != NULL);
 
     sampleDataSize = pWav->totalPCMFrameCount * pWav->channels * sizeof(drwav_int16);
     if (sampleDataSize > DRWAV_SIZE_MAX) {
         drwav_uninit(pWav);
-        return NULL;    /* File's too big. */
+        return NULL; /* File's too big. */
     }
 
-    pSampleData = (drwav_int16*)drwav__malloc_from_callbacks((size_t)sampleDataSize, &pWav->allocationCallbacks); /* <-- Safe cast due to the check above. */
+    pSampleData = (drwav_int16 *) drwav__malloc_from_callbacks(
+        (size_t) sampleDataSize, &pWav->allocationCallbacks); /* <-- Safe cast due to the check above. */
     if (pSampleData == NULL) {
         drwav_uninit(pWav);
-        return NULL;    /* Failed to allocate memory. */
+        return NULL; /* Failed to allocate memory. */
     }
 
-    framesRead = drwav_read_pcm_frames_s16(pWav, (size_t)pWav->totalPCMFrameCount, pSampleData);
+    framesRead = drwav_read_pcm_frames_s16(pWav, (size_t) pWav->totalPCMFrameCount, pSampleData);
     if (framesRead != pWav->totalPCMFrameCount) {
         drwav__free_from_callbacks(pSampleData, &pWav->allocationCallbacks);
         drwav_uninit(pWav);
-        return NULL;    /* There was an error reading the samples. */
+        return NULL; /* There was an error reading the samples. */
     }
 
     drwav_uninit(pWav);
@@ -5467,10 +5935,12 @@ static drwav_int16* drwav__read_pcm_frames_and_close_s16(drwav* pWav, unsigned i
     return pSampleData;
 }
 
-static float* drwav__read_pcm_frames_and_close_f32(drwav* pWav, unsigned int* channels, unsigned int* sampleRate, drwav_uint64* totalFrameCount)
-{
+static float * drwav__read_pcm_frames_and_close_f32(drwav *        pWav,
+                                                    unsigned int * channels,
+                                                    unsigned int * sampleRate,
+                                                    drwav_uint64 * totalFrameCount) {
     drwav_uint64 sampleDataSize;
-    float* pSampleData;
+    float *      pSampleData;
     drwav_uint64 framesRead;
 
     DRWAV_ASSERT(pWav != NULL);
@@ -5478,20 +5948,21 @@ static float* drwav__read_pcm_frames_and_close_f32(drwav* pWav, unsigned int* ch
     sampleDataSize = pWav->totalPCMFrameCount * pWav->channels * sizeof(float);
     if (sampleDataSize > DRWAV_SIZE_MAX) {
         drwav_uninit(pWav);
-        return NULL;    /* File's too big. */
+        return NULL; /* File's too big. */
     }
 
-    pSampleData = (float*)drwav__malloc_from_callbacks((size_t)sampleDataSize, &pWav->allocationCallbacks); /* <-- Safe cast due to the check above. */
+    pSampleData = (float *) drwav__malloc_from_callbacks(
+        (size_t) sampleDataSize, &pWav->allocationCallbacks); /* <-- Safe cast due to the check above. */
     if (pSampleData == NULL) {
         drwav_uninit(pWav);
-        return NULL;    /* Failed to allocate memory. */
+        return NULL; /* Failed to allocate memory. */
     }
 
-    framesRead = drwav_read_pcm_frames_f32(pWav, (size_t)pWav->totalPCMFrameCount, pSampleData);
+    framesRead = drwav_read_pcm_frames_f32(pWav, (size_t) pWav->totalPCMFrameCount, pSampleData);
     if (framesRead != pWav->totalPCMFrameCount) {
         drwav__free_from_callbacks(pSampleData, &pWav->allocationCallbacks);
         drwav_uninit(pWav);
-        return NULL;    /* There was an error reading the samples. */
+        return NULL; /* There was an error reading the samples. */
     }
 
     drwav_uninit(pWav);
@@ -5509,31 +5980,34 @@ static float* drwav__read_pcm_frames_and_close_f32(drwav* pWav, unsigned int* ch
     return pSampleData;
 }
 
-static drwav_int32* drwav__read_pcm_frames_and_close_s32(drwav* pWav, unsigned int* channels, unsigned int* sampleRate, drwav_uint64* totalFrameCount)
-{
-    drwav_uint64 sampleDataSize;
-    drwav_int32* pSampleData;
-    drwav_uint64 framesRead;
+static drwav_int32 * drwav__read_pcm_frames_and_close_s32(drwav *        pWav,
+                                                          unsigned int * channels,
+                                                          unsigned int * sampleRate,
+                                                          drwav_uint64 * totalFrameCount) {
+    drwav_uint64  sampleDataSize;
+    drwav_int32 * pSampleData;
+    drwav_uint64  framesRead;
 
     DRWAV_ASSERT(pWav != NULL);
 
     sampleDataSize = pWav->totalPCMFrameCount * pWav->channels * sizeof(drwav_int32);
     if (sampleDataSize > DRWAV_SIZE_MAX) {
         drwav_uninit(pWav);
-        return NULL;    /* File's too big. */
+        return NULL; /* File's too big. */
     }
 
-    pSampleData = (drwav_int32*)drwav__malloc_from_callbacks((size_t)sampleDataSize, &pWav->allocationCallbacks); /* <-- Safe cast due to the check above. */
+    pSampleData = (drwav_int32 *) drwav__malloc_from_callbacks(
+        (size_t) sampleDataSize, &pWav->allocationCallbacks); /* <-- Safe cast due to the check above. */
     if (pSampleData == NULL) {
         drwav_uninit(pWav);
-        return NULL;    /* Failed to allocate memory. */
+        return NULL; /* Failed to allocate memory. */
     }
 
-    framesRead = drwav_read_pcm_frames_s32(pWav, (size_t)pWav->totalPCMFrameCount, pSampleData);
+    framesRead = drwav_read_pcm_frames_s32(pWav, (size_t) pWav->totalPCMFrameCount, pSampleData);
     if (framesRead != pWav->totalPCMFrameCount) {
         drwav__free_from_callbacks(pSampleData, &pWav->allocationCallbacks);
         drwav_uninit(pWav);
-        return NULL;    /* There was an error reading the samples. */
+        return NULL; /* There was an error reading the samples. */
     }
 
     drwav_uninit(pWav);
@@ -5551,10 +6025,13 @@ static drwav_int32* drwav__read_pcm_frames_and_close_s32(drwav* pWav, unsigned i
     return pSampleData;
 }
 
-
-
-DRWAV_API drwav_int16* drwav_open_and_read_pcm_frames_s16(drwav_read_proc onRead, drwav_seek_proc onSeek, void* pUserData, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
+DRWAV_API drwav_int16 * drwav_open_and_read_pcm_frames_s16(drwav_read_proc                    onRead,
+                                                           drwav_seek_proc                    onSeek,
+                                                           void *                             pUserData,
+                                                           unsigned int *                     channelsOut,
+                                                           unsigned int *                     sampleRateOut,
+                                                           drwav_uint64 *                     totalFrameCountOut,
+                                                           const drwav_allocation_callbacks * pAllocationCallbacks) {
     drwav wav;
 
     if (channelsOut) {
@@ -5574,8 +6051,13 @@ DRWAV_API drwav_int16* drwav_open_and_read_pcm_frames_s16(drwav_read_proc onRead
     return drwav__read_pcm_frames_and_close_s16(&wav, channelsOut, sampleRateOut, totalFrameCountOut);
 }
 
-DRWAV_API float* drwav_open_and_read_pcm_frames_f32(drwav_read_proc onRead, drwav_seek_proc onSeek, void* pUserData, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
+DRWAV_API float * drwav_open_and_read_pcm_frames_f32(drwav_read_proc                    onRead,
+                                                     drwav_seek_proc                    onSeek,
+                                                     void *                             pUserData,
+                                                     unsigned int *                     channelsOut,
+                                                     unsigned int *                     sampleRateOut,
+                                                     drwav_uint64 *                     totalFrameCountOut,
+                                                     const drwav_allocation_callbacks * pAllocationCallbacks) {
     drwav wav;
 
     if (channelsOut) {
@@ -5595,8 +6077,13 @@ DRWAV_API float* drwav_open_and_read_pcm_frames_f32(drwav_read_proc onRead, drwa
     return drwav__read_pcm_frames_and_close_f32(&wav, channelsOut, sampleRateOut, totalFrameCountOut);
 }
 
-DRWAV_API drwav_int32* drwav_open_and_read_pcm_frames_s32(drwav_read_proc onRead, drwav_seek_proc onSeek, void* pUserData, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
+DRWAV_API drwav_int32 * drwav_open_and_read_pcm_frames_s32(drwav_read_proc                    onRead,
+                                                           drwav_seek_proc                    onSeek,
+                                                           void *                             pUserData,
+                                                           unsigned int *                     channelsOut,
+                                                           unsigned int *                     sampleRateOut,
+                                                           drwav_uint64 *                     totalFrameCountOut,
+                                                           const drwav_allocation_callbacks * pAllocationCallbacks) {
     drwav wav;
 
     if (channelsOut) {
@@ -5616,9 +6103,13 @@ DRWAV_API drwav_int32* drwav_open_and_read_pcm_frames_s32(drwav_read_proc onRead
     return drwav__read_pcm_frames_and_close_s32(&wav, channelsOut, sampleRateOut, totalFrameCountOut);
 }
 
-#ifndef DR_WAV_NO_STDIO
-DRWAV_API drwav_int16* drwav_open_file_and_read_pcm_frames_s16(const char* filename, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
+#            ifndef DR_WAV_NO_STDIO
+DRWAV_API drwav_int16 * drwav_open_file_and_read_pcm_frames_s16(
+    const char *                       filename,
+    unsigned int *                     channelsOut,
+    unsigned int *                     sampleRateOut,
+    drwav_uint64 *                     totalFrameCountOut,
+    const drwav_allocation_callbacks * pAllocationCallbacks) {
     drwav wav;
 
     if (channelsOut) {
@@ -5638,8 +6129,11 @@ DRWAV_API drwav_int16* drwav_open_file_and_read_pcm_frames_s16(const char* filen
     return drwav__read_pcm_frames_and_close_s16(&wav, channelsOut, sampleRateOut, totalFrameCountOut);
 }
 
-DRWAV_API float* drwav_open_file_and_read_pcm_frames_f32(const char* filename, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
+DRWAV_API float * drwav_open_file_and_read_pcm_frames_f32(const char *                       filename,
+                                                          unsigned int *                     channelsOut,
+                                                          unsigned int *                     sampleRateOut,
+                                                          drwav_uint64 *                     totalFrameCountOut,
+                                                          const drwav_allocation_callbacks * pAllocationCallbacks) {
     drwav wav;
 
     if (channelsOut) {
@@ -5659,8 +6153,12 @@ DRWAV_API float* drwav_open_file_and_read_pcm_frames_f32(const char* filename, u
     return drwav__read_pcm_frames_and_close_f32(&wav, channelsOut, sampleRateOut, totalFrameCountOut);
 }
 
-DRWAV_API drwav_int32* drwav_open_file_and_read_pcm_frames_s32(const char* filename, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
+DRWAV_API drwav_int32 * drwav_open_file_and_read_pcm_frames_s32(
+    const char *                       filename,
+    unsigned int *                     channelsOut,
+    unsigned int *                     sampleRateOut,
+    drwav_uint64 *                     totalFrameCountOut,
+    const drwav_allocation_callbacks * pAllocationCallbacks) {
     drwav wav;
 
     if (channelsOut) {
@@ -5680,9 +6178,12 @@ DRWAV_API drwav_int32* drwav_open_file_and_read_pcm_frames_s32(const char* filen
     return drwav__read_pcm_frames_and_close_s32(&wav, channelsOut, sampleRateOut, totalFrameCountOut);
 }
 
-
-DRWAV_API drwav_int16* drwav_open_file_and_read_pcm_frames_s16_w(const wchar_t* filename, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
+DRWAV_API drwav_int16 * drwav_open_file_and_read_pcm_frames_s16_w(
+    const wchar_t *                    filename,
+    unsigned int *                     channelsOut,
+    unsigned int *                     sampleRateOut,
+    drwav_uint64 *                     totalFrameCountOut,
+    const drwav_allocation_callbacks * pAllocationCallbacks) {
     drwav wav;
 
     if (sampleRateOut) {
@@ -5702,8 +6203,11 @@ DRWAV_API drwav_int16* drwav_open_file_and_read_pcm_frames_s16_w(const wchar_t*
     return drwav__read_pcm_frames_and_close_s16(&wav, channelsOut, sampleRateOut, totalFrameCountOut);
 }
 
-DRWAV_API float* drwav_open_file_and_read_pcm_frames_f32_w(const wchar_t* filename, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
+DRWAV_API float * drwav_open_file_and_read_pcm_frames_f32_w(const wchar_t *                    filename,
+                                                            unsigned int *                     channelsOut,
+                                                            unsigned int *                     sampleRateOut,
+                                                            drwav_uint64 *                     totalFrameCountOut,
+                                                            const drwav_allocation_callbacks * pAllocationCallbacks) {
     drwav wav;
 
     if (sampleRateOut) {
@@ -5723,8 +6227,12 @@ DRWAV_API float* drwav_open_file_and_read_pcm_frames_f32_w(const wchar_t* filena
     return drwav__read_pcm_frames_and_close_f32(&wav, channelsOut, sampleRateOut, totalFrameCountOut);
 }
 
-DRWAV_API drwav_int32* drwav_open_file_and_read_pcm_frames_s32_w(const wchar_t* filename, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
+DRWAV_API drwav_int32 * drwav_open_file_and_read_pcm_frames_s32_w(
+    const wchar_t *                    filename,
+    unsigned int *                     channelsOut,
+    unsigned int *                     sampleRateOut,
+    drwav_uint64 *                     totalFrameCountOut,
+    const drwav_allocation_callbacks * pAllocationCallbacks) {
     drwav wav;
 
     if (sampleRateOut) {
@@ -5743,10 +6251,15 @@ DRWAV_API drwav_int32* drwav_open_file_and_read_pcm_frames_s32_w(const wchar_t*
 
     return drwav__read_pcm_frames_and_close_s32(&wav, channelsOut, sampleRateOut, totalFrameCountOut);
 }
-#endif
+#            endif
 
-DRWAV_API drwav_int16* drwav_open_memory_and_read_pcm_frames_s16(const void* data, size_t dataSize, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
+DRWAV_API drwav_int16 * drwav_open_memory_and_read_pcm_frames_s16(
+    const void *                       data,
+    size_t                             dataSize,
+    unsigned int *                     channelsOut,
+    unsigned int *                     sampleRateOut,
+    drwav_uint64 *                     totalFrameCountOut,
+    const drwav_allocation_callbacks * pAllocationCallbacks) {
     drwav wav;
 
     if (channelsOut) {
@@ -5766,8 +6279,12 @@ DRWAV_API drwav_int16* drwav_open_memory_and_read_pcm_frames_s16(const void* dat
     return drwav__read_pcm_frames_and_close_s16(&wav, channelsOut, sampleRateOut, totalFrameCountOut);
 }
 
-DRWAV_API float* drwav_open_memory_and_read_pcm_frames_f32(const void* data, size_t dataSize, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
+DRWAV_API float * drwav_open_memory_and_read_pcm_frames_f32(const void *                       data,
+                                                            size_t                             dataSize,
+                                                            unsigned int *                     channelsOut,
+                                                            unsigned int *                     sampleRateOut,
+                                                            drwav_uint64 *                     totalFrameCountOut,
+                                                            const drwav_allocation_callbacks * pAllocationCallbacks) {
     drwav wav;
 
     if (channelsOut) {
@@ -5787,8 +6304,13 @@ DRWAV_API float* drwav_open_memory_and_read_pcm_frames_f32(const void* data, siz
     return drwav__read_pcm_frames_and_close_f32(&wav, channelsOut, sampleRateOut, totalFrameCountOut);
 }
 
-DRWAV_API drwav_int32* drwav_open_memory_and_read_pcm_frames_s32(const void* data, size_t dataSize, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
+DRWAV_API drwav_int32 * drwav_open_memory_and_read_pcm_frames_s32(
+    const void *                       data,
+    size_t                             dataSize,
+    unsigned int *                     channelsOut,
+    unsigned int *                     sampleRateOut,
+    drwav_uint64 *                     totalFrameCountOut,
+    const drwav_allocation_callbacks * pAllocationCallbacks) {
     drwav wav;
 
     if (channelsOut) {
@@ -5807,11 +6329,9 @@ DRWAV_API drwav_int32* drwav_open_memory_and_read_pcm_frames_s32(const void* dat
 
     return drwav__read_pcm_frames_and_close_s32(&wav, channelsOut, sampleRateOut, totalFrameCountOut);
 }
-#endif  /* DR_WAV_NO_CONVERSION_API */
-
+#        endif /* DR_WAV_NO_CONVERSION_API */
 
-DRWAV_API void drwav_free(void* p, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
+DRWAV_API void drwav_free(void * p, const drwav_allocation_callbacks * pAllocationCallbacks) {
     if (pAllocationCallbacks != NULL) {
         drwav__free_from_callbacks(p, pAllocationCallbacks);
     } else {
@@ -5819,49 +6339,40 @@ DRWAV_API void drwav_free(void* p, const drwav_allocation_callbacks* pAllocation
     }
 }
 
-DRWAV_API drwav_uint16 drwav_bytes_to_u16(const drwav_uint8* data)
-{
+DRWAV_API drwav_uint16 drwav_bytes_to_u16(const drwav_uint8 * data) {
     return drwav__bytes_to_u16(data);
 }
 
-DRWAV_API drwav_int16 drwav_bytes_to_s16(const drwav_uint8* data)
-{
+DRWAV_API drwav_int16 drwav_bytes_to_s16(const drwav_uint8 * data) {
     return drwav__bytes_to_s16(data);
 }
 
-DRWAV_API drwav_uint32 drwav_bytes_to_u32(const drwav_uint8* data)
-{
+DRWAV_API drwav_uint32 drwav_bytes_to_u32(const drwav_uint8 * data) {
     return drwav__bytes_to_u32(data);
 }
 
-DRWAV_API drwav_int32 drwav_bytes_to_s32(const drwav_uint8* data)
-{
+DRWAV_API drwav_int32 drwav_bytes_to_s32(const drwav_uint8 * data) {
     return drwav__bytes_to_s32(data);
 }
 
-DRWAV_API drwav_uint64 drwav_bytes_to_u64(const drwav_uint8* data)
-{
+DRWAV_API drwav_uint64 drwav_bytes_to_u64(const drwav_uint8 * data) {
     return drwav__bytes_to_u64(data);
 }
 
-DRWAV_API drwav_int64 drwav_bytes_to_s64(const drwav_uint8* data)
-{
+DRWAV_API drwav_int64 drwav_bytes_to_s64(const drwav_uint8 * data) {
     return drwav__bytes_to_s64(data);
 }
 
-
-DRWAV_API drwav_bool32 drwav_guid_equal(const drwav_uint8 a[16], const drwav_uint8 b[16])
-{
+DRWAV_API drwav_bool32 drwav_guid_equal(const drwav_uint8 a[16], const drwav_uint8 b[16]) {
     return drwav__guid_equal(a, b);
 }
 
-DRWAV_API drwav_bool32 drwav_fourcc_equal(const drwav_uint8* a, const char* b)
-{
+DRWAV_API drwav_bool32 drwav_fourcc_equal(const drwav_uint8 * a, const char * b) {
     return drwav__fourcc_equal(a, b);
 }
 
-#endif  /* dr_wav_c */
-#endif  /* DR_WAV_IMPLEMENTATION */
+#    endif /* dr_wav_c */
+#endif     /* DR_WAV_IMPLEMENTATION */
 
 /*
 RELEASE NOTES - v0.11.0
diff --git a/examples/common/wav.cpp b/examples/common/wav.cpp
index 5bbcc4ed..7dfaf090 100644
--- a/examples/common/wav.cpp
+++ b/examples/common/wav.cpp
@@ -32,11 +32,9 @@ std::string format_size_t(size_t v) {
     return std::string(buf);
 }
 
-} // namespace
+}  // namespace
 
-bool load_wav_mono_16k(const std::string &  path,
-                       std::vector<float> & out_pcm,
-                       std::string &        out_error) {
+bool load_wav_mono_16k(const std::string & path, std::vector<float> & out_pcm, std::string & out_error) {
     out_pcm.clear();
     out_error.clear();
 
@@ -55,11 +53,9 @@ bool load_wav_mono_16k(const std::string &  path,
     const size_t       total_frames = static_cast<size_t>(wav.totalPCMFrameCount);
 
     if (sample_rate != kRequiredSampleRate) {
-        out_error = "WAV sample rate is " + std::to_string(sample_rate)
-                  + " Hz; transcribe.cpp v1 only accepts 16000 Hz."
-                  + " Resample first, e.g.:\n"
-                  + "  sox '" + path + "' -r 16000 -c 1 out.wav\n"
-                  + "  ffmpeg -i '" + path + "' -ar 16000 -ac 1 out.wav";
+        out_error = "WAV sample rate is " + std::to_string(sample_rate) +
+                    " Hz; transcribe.cpp v1 only accepts 16000 Hz." + " Resample first, e.g.:\n" + "  sox '" + path +
+                    "' -r 16000 -c 1 out.wav\n" + "  ffmpeg -i '" + path + "' -ar 16000 -ac 1 out.wav";
         drwav_uninit(&wav);
         return false;
     }
@@ -77,8 +73,7 @@ bool load_wav_mono_16k(const std::string &  path,
     }
 
     if (total_frames > kMaxFrames) {
-        out_error = "WAV file is implausibly long ("
-                  + format_size_t(total_frames) + " frames); refusing to load";
+        out_error = "WAV file is implausibly long (" + format_size_t(total_frames) + " frames); refusing to load";
         drwav_uninit(&wav);
         return false;
     }
@@ -89,9 +84,8 @@ bool load_wav_mono_16k(const std::string &  path,
     // size_t on a 32-bit host, or against a malformed header reporting
     // an absurd channel count even though we already gated total_frames.
     if (channels > std::numeric_limits<size_t>::max() / total_frames) {
-        out_error = "WAV interleaved buffer size overflows size_t ("
-                  + format_size_t(total_frames) + " frames * "
-                  + std::to_string(channels) + " channels)";
+        out_error = "WAV interleaved buffer size overflows size_t (" + format_size_t(total_frames) + " frames * " +
+                    std::to_string(channels) + " channels)";
         drwav_uninit(&wav);
         return false;
     }
@@ -102,14 +96,12 @@ bool load_wav_mono_16k(const std::string &  path,
     // format conversions for us (PCM int16/24/32, float32/64, A-law,
     // mu-law).
     std::vector<float> interleaved(interleaved_count);
-    const size_t       got = drwav_read_pcm_frames_f32(
-        &wav, total_frames, interleaved.data());
+    const size_t       got = drwav_read_pcm_frames_f32(&wav, total_frames, interleaved.data());
     drwav_uninit(&wav);
 
     if (got != total_frames) {
-        out_error = "WAV decode short read: expected "
-                  + format_size_t(total_frames) + " frames, got "
-                  + format_size_t(got);
+        out_error =
+            "WAV decode short read: expected " + format_size_t(total_frames) + " frames, got " + format_size_t(got);
         return false;
     }
 
@@ -130,4 +122,4 @@ bool load_wav_mono_16k(const std::string &  path,
     return true;
 }
 
-} // namespace transcribe_cli
+}  // namespace transcribe_cli
diff --git a/examples/common/wav.h b/examples/common/wav.h
index d472de67..363dfdd8 100644
--- a/examples/common/wav.h
+++ b/examples/common/wav.h
@@ -26,8 +26,6 @@ namespace transcribe_cli {
 //
 // Stereo (or higher channel count) input is downmixed to mono by
 // averaging channels. Any sample rate other than 16 kHz is an error.
-bool load_wav_mono_16k(const std::string &  path,
-                       std::vector<float> & out_pcm,
-                       std::string &        out_error);
+bool load_wav_mono_16k(const std::string & path, std::vector<float> & out_pcm, std::string & out_error);
 
-} // namespace transcribe_cli
+}  // namespace transcribe_cli
diff --git a/examples/hello/main.c b/examples/hello/main.c
index cdb55bbc..ff1af44f 100644
--- a/examples/hello/main.c
+++ b/examples/hello/main.c
@@ -33,13 +33,11 @@
 // Reads a WAV into mono float32 samples at its native rate. Returns a
 // malloc'd buffer the caller frees, or NULL on failure. Multi-channel
 // input is downmixed by averaging.
-static float * load_wav_mono(const char * path, int * out_n_samples,
-                             unsigned int * out_rate) {
-    unsigned int channels = 0;
-    unsigned int rate     = 0;
-    drwav_uint64 frames   = 0;
-    float * interleaved = drwav_open_file_and_read_pcm_frames_f32(
-        path, &channels, &rate, &frames, NULL);
+static float * load_wav_mono(const char * path, int * out_n_samples, unsigned int * out_rate) {
+    unsigned int channels    = 0;
+    unsigned int rate        = 0;
+    drwav_uint64 frames      = 0;
+    float *      interleaved = drwav_open_file_and_read_pcm_frames_f32(path, &channels, &rate, &frames, NULL);
     if (interleaved == NULL) {
         return NULL;
     }
@@ -60,6 +58,7 @@ static float * load_wav_mono(const char * path, int * out_n_samples,
     *out_n_samples = (int) frames;
     return mono;
 }
+
 // --------------------------------------------------------------------------
 
 int main(int argc, char ** argv) {
@@ -82,7 +81,8 @@ int main(int argc, char ** argv) {
     if (rate != 16000) {
         fprintf(stderr,
                 "error: audio must be 16 kHz (got %u Hz); resample first, "
-                "e.g. ffmpeg -i in.wav -ar 16000 -ac 1 out.wav\n", rate);
+                "e.g. ffmpeg -i in.wav -ar 16000 -ac 1 out.wav\n",
+                rate);
         free(pcm);
         return 1;
     }
@@ -91,10 +91,9 @@ int main(int argc, char ** argv) {
     //    call. NULL load/session params == library defaults. The returned
     //    session OWNS the model; transcribe_close frees both.
     struct transcribe_session * session = NULL;
-    transcribe_status st = transcribe_open(model_path, NULL, NULL, &session);
+    transcribe_status           st      = transcribe_open(model_path, NULL, NULL, &session);
     if (st != TRANSCRIBE_OK) {
-        fprintf(stderr, "error: transcribe_open: %s\n",
-                transcribe_status_string(st));
+        fprintf(stderr, "error: transcribe_open: %s\n", transcribe_status_string(st));
         free(pcm);
         return 1;
     }
@@ -104,8 +103,7 @@ int main(int argc, char ** argv) {
     //    run or close.
     st = transcribe_run(session, pcm, n_samples, NULL);
     if (st != TRANSCRIBE_OK) {
-        fprintf(stderr, "error: transcribe_run: %s\n",
-                transcribe_status_string(st));
+        fprintf(stderr, "error: transcribe_run: %s\n", transcribe_status_string(st));
         transcribe_close(session);
         free(pcm);
         return 1;
diff --git a/examples/hello_stream/main.c b/examples/hello_stream/main.c
index cdcb0a20..922a99a6 100644
--- a/examples/hello_stream/main.c
+++ b/examples/hello_stream/main.c
@@ -44,13 +44,11 @@
 #include <string.h>
 
 // --- audio loading (NOT part of the transcribe API) -----------------------
-static float * load_wav_mono(const char * path, int * out_n_samples,
-                             unsigned int * out_rate) {
-    unsigned int channels = 0;
-    unsigned int rate     = 0;
-    drwav_uint64 frames   = 0;
-    float * interleaved = drwav_open_file_and_read_pcm_frames_f32(
-        path, &channels, &rate, &frames, NULL);
+static float * load_wav_mono(const char * path, int * out_n_samples, unsigned int * out_rate) {
+    unsigned int channels    = 0;
+    unsigned int rate        = 0;
+    drwav_uint64 frames      = 0;
+    float *      interleaved = drwav_open_file_and_read_pcm_frames_f32(path, &channels, &rate, &frames, NULL);
     if (interleaved == NULL) {
         return NULL;
     }
@@ -71,6 +69,7 @@ static float * load_wav_mono(const char * path, int * out_n_samples,
     *out_n_samples = (int) frames;
     return mono;
 }
+
 // --------------------------------------------------------------------------
 
 // Print the current UI-facing stream text split.
@@ -86,22 +85,18 @@ static float * load_wav_mono(const char * path, int * out_n_samples,
 static void print_partial(struct transcribe_session * session) {
     struct transcribe_stream_text text;
     transcribe_stream_text_init(&text);
-    if (transcribe_stream_get_text(session, &text) != TRANSCRIBE_OK ||
-        text.full_text == NULL || *text.full_text == '\0')
-    {
+    if (transcribe_stream_get_text(session, &text) != TRANSCRIBE_OK || text.full_text == NULL ||
+        *text.full_text == '\0') {
         return;
     }
-    printf("    committed=\"%s\" tentative=\"%s\" raw=\"%s\"\n",
-           text.committed_text ? text.committed_text : "",
-           text.tentative_text ? text.tentative_text : "",
-           text.full_text ? text.full_text : "");
+    printf("    committed=\"%s\" tentative=\"%s\" raw=\"%s\"\n", text.committed_text ? text.committed_text : "",
+           text.tentative_text ? text.tentative_text : "", text.full_text ? text.full_text : "");
     fflush(stdout);
 }
 
 int main(int argc, char ** argv) {
     if (argc < 3 || argc > 4) {
-        fprintf(stderr,
-                "usage: %s model.gguf audio.wav [chunk_ms=500]\n", argv[0]);
+        fprintf(stderr, "usage: %s model.gguf audio.wav [chunk_ms=500]\n", argv[0]);
         return 2;
     }
     const char * model_path = argv[1];
@@ -123,7 +118,8 @@ int main(int argc, char ** argv) {
     if (rate != 16000) {
         fprintf(stderr,
                 "error: audio must be 16 kHz (got %u Hz); resample first, "
-                "e.g. ffmpeg -i in.wav -ar 16000 -ac 1 out.wav\n", rate);
+                "e.g. ffmpeg -i in.wav -ar 16000 -ac 1 out.wav\n",
+                rate);
         free(pcm);
         return 1;
     }
@@ -132,10 +128,9 @@ int main(int argc, char ** argv) {
     //    returns a session that owns its model; transcribe_session_free
     //    later frees both.
     struct transcribe_session * session = NULL;
-    transcribe_status st = transcribe_open(model_path, NULL, NULL, &session);
+    transcribe_status           st      = transcribe_open(model_path, NULL, NULL, &session);
     if (st != TRANSCRIBE_OK) {
-        fprintf(stderr, "error: transcribe_open: %s\n",
-                transcribe_status_string(st));
+        fprintf(stderr, "error: transcribe_open: %s\n", transcribe_status_string(st));
         free(pcm);
         return 1;
     }
@@ -145,10 +140,8 @@ int main(int argc, char ** argv) {
     //    transcribe_stream_begin.
     struct transcribe_capabilities caps;
     transcribe_capabilities_init(&caps);
-    if (transcribe_model_get_capabilities(
-            transcribe_get_model(session), &caps) != TRANSCRIBE_OK ||
-        !caps.supports_streaming)
-    {
+    if (transcribe_model_get_capabilities(transcribe_get_model(session), &caps) != TRANSCRIBE_OK ||
+        !caps.supports_streaming) {
         fprintf(stderr,
                 "error: model does not advertise supports_streaming; "
                 "use a streaming-capable model.\n");
@@ -164,8 +157,7 @@ int main(int argc, char ** argv) {
     //    + the family's init function; this example sticks to defaults.
     st = transcribe_stream_begin(session, NULL, NULL);
     if (st != TRANSCRIBE_OK) {
-        fprintf(stderr, "error: stream_begin: %s\n",
-                transcribe_status_string(st));
+        fprintf(stderr, "error: stream_begin: %s\n", transcribe_status_string(st));
         transcribe_session_free(session);
         free(pcm);
         return 1;
@@ -178,26 +170,24 @@ int main(int argc, char ** argv) {
     //    moved"; transcribe_stream_get_text then reads the UI-facing
     //    committed/tentative split.
     const int chunk_samples = chunk_ms * 16000 / 1000;
-    int pos = 0;
-    int feed_idx = 0;
+    int       pos           = 0;
+    int       feed_idx      = 0;
     while (pos < n_samples) {
         int take = chunk_samples;
-        if (pos + take > n_samples) take = n_samples - pos;
+        if (pos + take > n_samples) {
+            take = n_samples - pos;
+        }
 
         struct transcribe_stream_update upd;
         transcribe_stream_update_init(&upd);
         st = transcribe_stream_feed(session, pcm + pos, take, &upd);
         if (st != TRANSCRIBE_OK) {
-            fprintf(stderr, "error: stream_feed[%d]: %s\n",
-                    feed_idx, transcribe_status_string(st));
+            fprintf(stderr, "error: stream_feed[%d]: %s\n", feed_idx, transcribe_status_string(st));
             break;
         }
 
-        printf("feed[%2d]: input=%lld ms buffered=%lld ms%s\n",
-               feed_idx,
-               (long long) upd.input_received_ms,
-               (long long) upd.buffered_ms,
-               upd.result_changed ? "  (result changed)" : "");
+        printf("feed[%2d]: input=%lld ms buffered=%lld ms%s\n", feed_idx, (long long) upd.input_received_ms,
+               (long long) upd.buffered_ms, upd.result_changed ? "  (result changed)" : "");
         if (upd.result_changed) {
             print_partial(session);
         }
@@ -215,13 +205,10 @@ int main(int argc, char ** argv) {
         transcribe_stream_update_init(&fin);
         st = transcribe_stream_finalize(session, &fin);
         if (st != TRANSCRIBE_OK) {
-            fprintf(stderr, "error: stream_finalize: %s\n",
-                    transcribe_status_string(st));
+            fprintf(stderr, "error: stream_finalize: %s\n", transcribe_status_string(st));
         } else {
-            printf("finalize: revision=%d input=%lld ms committed=%lld ms\n",
-                   fin.revision,
-                   (long long) fin.input_received_ms,
-                   (long long) fin.audio_committed_ms);
+            printf("finalize: revision=%d input=%lld ms committed=%lld ms\n", fin.revision,
+                   (long long) fin.input_received_ms, (long long) fin.audio_committed_ms);
             print_partial(session);
         }
     }
diff --git a/include/transcribe.h b/include/transcribe.h
index 6c9871e7..2a76b6cf 100644
--- a/include/transcribe.h
+++ b/include/transcribe.h
@@ -151,10 +151,10 @@
 
 #define TRANSCRIBE_VERSION_STRINGIZE_(x) #x
 #define TRANSCRIBE_VERSION_STRINGIZE(x)  TRANSCRIBE_VERSION_STRINGIZE_(x)
-#define TRANSCRIBE_VERSION                                    \
-    TRANSCRIBE_VERSION_STRINGIZE(TRANSCRIBE_VERSION_MAJOR) "." \
-    TRANSCRIBE_VERSION_STRINGIZE(TRANSCRIBE_VERSION_MINOR) "." \
-    TRANSCRIBE_VERSION_STRINGIZE(TRANSCRIBE_VERSION_PATCH)
+#define TRANSCRIBE_VERSION                                                                       \
+    TRANSCRIBE_VERSION_STRINGIZE(TRANSCRIBE_VERSION_MAJOR)                                       \
+    "." TRANSCRIBE_VERSION_STRINGIZE(TRANSCRIBE_VERSION_MINOR) "." TRANSCRIBE_VERSION_STRINGIZE( \
+        TRANSCRIBE_VERSION_PATCH)
 
 /* Monotonic integer form (MAJOR*10000 + MINOR*100 + PATCH) for compile-time
  * comparisons, e.g. `#if TRANSCRIBE_VERSION_NUMBER >= 200`. */
@@ -162,22 +162,22 @@
     (TRANSCRIBE_VERSION_MAJOR * 10000 + TRANSCRIBE_VERSION_MINOR * 100 + TRANSCRIBE_VERSION_PATCH)
 
 #ifndef TRANSCRIBE_API
-#  if defined(_WIN32) && !defined(__GNUC__)
-#    if defined(TRANSCRIBE_STATIC)
-       /* Static archive (lib build or static consumer): no dllimport/export.
+#    if defined(_WIN32) && !defined(__GNUC__)
+#        if defined(TRANSCRIBE_STATIC)
+/* Static archive (lib build or static consumer): no dllimport/export.
         * A consumer linking the static transcribe.lib must NOT see dllimport
         * or the linker chases __imp_* thunks the archive never provides
         * (LNK2019). The static `transcribe` CMake target propagates this
         * PUBLIC; non-CMake static consumers define it themselves. */
-#      define TRANSCRIBE_API
-#    elif defined(TRANSCRIBE_BUILD)
-#      define TRANSCRIBE_API __declspec(dllexport)
+#            define TRANSCRIBE_API
+#        elif defined(TRANSCRIBE_BUILD)
+#            define TRANSCRIBE_API __declspec(dllexport)
+#        else
+#            define TRANSCRIBE_API __declspec(dllimport)
+#        endif
 #    else
-#      define TRANSCRIBE_API __declspec(dllimport)
+#        define TRANSCRIBE_API __attribute__((visibility("default")))
 #    endif
-#  else
-#    define TRANSCRIBE_API __attribute__((visibility("default")))
-#  endif
 #endif
 
 #ifdef __cplusplus
@@ -189,19 +189,19 @@ extern "C" {
 /* ----------------------------------------------------------------------- */
 
 typedef enum {
-    TRANSCRIBE_OK                       = 0,
-    TRANSCRIBE_ERR_INVALID_ARG          = 1,
-    TRANSCRIBE_ERR_NOT_IMPLEMENTED      = 2,
-    TRANSCRIBE_ERR_FILE_NOT_FOUND       = 3,
-    TRANSCRIBE_ERR_GGUF                 = 4,
-    TRANSCRIBE_ERR_UNSUPPORTED_ARCH     = 5,
-    TRANSCRIBE_ERR_UNSUPPORTED_VARIANT  = 6,
-    TRANSCRIBE_ERR_OOM                  = 7,
-    TRANSCRIBE_ERR_BACKEND              = 8,
+    TRANSCRIBE_OK                         = 0,
+    TRANSCRIBE_ERR_INVALID_ARG            = 1,
+    TRANSCRIBE_ERR_NOT_IMPLEMENTED        = 2,
+    TRANSCRIBE_ERR_FILE_NOT_FOUND         = 3,
+    TRANSCRIBE_ERR_GGUF                   = 4,
+    TRANSCRIBE_ERR_UNSUPPORTED_ARCH       = 5,
+    TRANSCRIBE_ERR_UNSUPPORTED_VARIANT    = 6,
+    TRANSCRIBE_ERR_OOM                    = 7,
+    TRANSCRIBE_ERR_BACKEND                = 8,
     /* Reserved; not currently returned. */
-    TRANSCRIBE_ERR_SAMPLE_RATE          = 9,
-    TRANSCRIBE_ERR_UNSUPPORTED_LANGUAGE = 10,
-    TRANSCRIBE_ERR_UNSUPPORTED_TASK     = 11,
+    TRANSCRIBE_ERR_SAMPLE_RATE            = 9,
+    TRANSCRIBE_ERR_UNSUPPORTED_LANGUAGE   = 10,
+    TRANSCRIBE_ERR_UNSUPPORTED_TASK       = 11,
     /*
      * Returned by transcribe_run when the caller asks for a
      * timestamp granularity finer than the model can produce.
@@ -219,7 +219,7 @@ typedef enum {
      * readable via the normal result accessors; transcribe_was_aborted
      * distinguishes partial-from-abort from complete.
      */
-    TRANSCRIBE_ERR_ABORTED              = 13,
+    TRANSCRIBE_ERR_ABORTED                = 13,
     /*
      * Returned by every entry point that takes a caller-owned size-
      * aware struct (params, stream params, capabilities out, timings
@@ -228,11 +228,11 @@ typedef enum {
      * INVALID_ARG so bindings can match on "caller forgot to call the
      * transcribe_*_init function" specifically.
      */
-    TRANSCRIBE_ERR_BAD_STRUCT_SIZE      = 14,
+    TRANSCRIBE_ERR_BAD_STRUCT_SIZE        = 14,
     /* Reserved; not currently returned. */
-    TRANSCRIBE_ERR_UNSUPPORTED_PNC      = 15,
+    TRANSCRIBE_ERR_UNSUPPORTED_PNC        = 15,
     /* Reserved; not currently returned. */
-    TRANSCRIBE_ERR_UNSUPPORTED_ITN      = 16,
+    TRANSCRIBE_ERR_UNSUPPORTED_ITN        = 16,
     /*
      * Returned by transcribe_run / transcribe_run_batch when the input
      * audio is longer than the loaded model can process in a single
@@ -259,7 +259,7 @@ typedef enum {
      *
      * See docs/input-limits.md for the full contract.
      */
-    TRANSCRIBE_ERR_INPUT_TOO_LONG       = 17,
+    TRANSCRIBE_ERR_INPUT_TOO_LONG         = 17,
     /*
      * Returned by transcribe_run when the decode stopped because it hit
      * the model's context / generation budget BEFORE the model emitted
@@ -286,7 +286,7 @@ typedef enum {
      * has its own terminal-state machine (see transcribe_stream_*).
      * See docs/input-limits.md for the full contract.
      */
-    TRANSCRIBE_ERR_OUTPUT_TRUNCATED     = 18,
+    TRANSCRIBE_ERR_OUTPUT_TRUNCATED       = 18,
 } transcribe_status;
 
 /*
@@ -387,10 +387,7 @@ typedef enum {
     TRANSCRIBE_LOG_LEVEL_CONT  = 5, /* continue previous line */
 } transcribe_log_level;
 
-typedef void (*transcribe_log_callback)(
-    transcribe_log_level level,
-    const char *         msg,
-    void *               userdata);
+typedef void (*transcribe_log_callback)(transcribe_log_level level, const char * msg, void * userdata);
 
 /*
  * Global log sink. Three states:
@@ -576,10 +573,9 @@ struct transcribe_ext {
  * supported layout). The helper exists so every family rejects malformed
  * input identically.
  */
-TRANSCRIBE_API transcribe_status transcribe_ext_check(
-    const struct transcribe_ext * ext,
-    uint32_t                      expected_kind,
-    uint64_t                      min_size);
+TRANSCRIBE_API transcribe_status transcribe_ext_check(const struct transcribe_ext * ext,
+                                                      uint32_t                      expected_kind,
+                                                      uint64_t                      min_size);
 
 /*
  * Extension slot — the API surface a typed family extension is pointed
@@ -617,10 +613,9 @@ typedef enum {
  * over every known kind. See docs/extension-kinds.md for the registered
  * kinds and their slots.
  */
-TRANSCRIBE_API bool transcribe_model_accepts_ext_kind(
-    const struct transcribe_model * model,
-    transcribe_ext_slot             slot,
-    uint32_t                        kind);
+TRANSCRIBE_API bool transcribe_model_accepts_ext_kind(const struct transcribe_model * model,
+                                                      transcribe_ext_slot             slot,
+                                                      uint32_t                        kind);
 
 /* ----------------------------------------------------------------------- */
 /* Params                                                                  */
@@ -723,8 +718,7 @@ typedef enum {
  *                                  usable modules: nothing could run).
  *   TRANSCRIBE_OK                  otherwise.
  */
-TRANSCRIBE_API transcribe_status transcribe_init_backends(
-    const char * artifact_dir);
+TRANSCRIBE_API transcribe_status transcribe_init_backends(const char * artifact_dir);
 
 /*
  * Package-local default for dynamic-backend builds.
@@ -757,10 +751,10 @@ TRANSCRIBE_API int transcribe_backend_device_count(void);
  * enum.
  */
 typedef enum {
-    TRANSCRIBE_DEVICE_TYPE_CPU   = 0,  /* CPU using system memory */
-    TRANSCRIBE_DEVICE_TYPE_GPU   = 1,  /* backend-reported GPU */
-    TRANSCRIBE_DEVICE_TYPE_IGPU  = 2,  /* backend-reported integrated GPU */
-    TRANSCRIBE_DEVICE_TYPE_ACCEL = 3,  /* host-memory accelerator (BLAS/AMX) */
+    TRANSCRIBE_DEVICE_TYPE_CPU   = 0, /* CPU using system memory */
+    TRANSCRIBE_DEVICE_TYPE_GPU   = 1, /* backend-reported GPU */
+    TRANSCRIBE_DEVICE_TYPE_IGPU  = 2, /* backend-reported integrated GPU */
+    TRANSCRIBE_DEVICE_TYPE_ACCEL = 3, /* host-memory accelerator (BLAS/AMX) */
 } transcribe_device_type;
 
 /*
@@ -799,8 +793,7 @@ struct transcribe_backend_device {
     transcribe_device_type device_type;  /* CPU/GPU/IGPU/ACCEL axis */
 };
 
-TRANSCRIBE_API void transcribe_backend_device_init(
-    struct transcribe_backend_device * p);
+TRANSCRIBE_API void transcribe_backend_device_init(struct transcribe_backend_device * p);
 
 /*
  * Fill *out (initialized via transcribe_backend_device_init) with device
@@ -811,9 +804,7 @@ TRANSCRIBE_API void transcribe_backend_device_init(
  * stable for the life of the process, so the same index always names the
  * same device.
  */
-TRANSCRIBE_API transcribe_status transcribe_get_backend_device(
-    int                                index,
-    struct transcribe_backend_device * out);
+TRANSCRIBE_API transcribe_status transcribe_get_backend_device(int index, struct transcribe_backend_device * out);
 
 /*
  * Whether a backend request can be satisfied by some registered device:
@@ -823,8 +814,7 @@ TRANSCRIBE_API transcribe_status transcribe_get_backend_device(
  * probe a binding uses to turn `backend="vulkan"` on a machine without
  * Vulkan into a clear exception instead of a failed model load.
  */
-TRANSCRIBE_API bool transcribe_backend_available(
-    transcribe_backend_request kind);
+TRANSCRIBE_API bool transcribe_backend_available(transcribe_backend_request kind);
 
 /*
  * Fill *out (initialized via transcribe_backend_device_init) with the
@@ -838,9 +828,8 @@ TRANSCRIBE_API bool transcribe_backend_available(
  * the struct-size check), or TRANSCRIBE_ERR_BACKEND if the model has no
  * resolved compute device.
  */
-TRANSCRIBE_API transcribe_status transcribe_model_get_device(
-    const struct transcribe_model *    model,
-    struct transcribe_backend_device * out);
+TRANSCRIBE_API transcribe_status transcribe_model_get_device(const struct transcribe_model *    model,
+                                                             struct transcribe_backend_device * out);
 
 /*
  * Initialization of caller-owned params structs.
@@ -902,8 +891,7 @@ struct transcribe_model_load_params {
     int                        gpu_device;
 };
 
-TRANSCRIBE_API void transcribe_model_load_params_init(
-    struct transcribe_model_load_params * params);
+TRANSCRIBE_API void transcribe_model_load_params_init(struct transcribe_model_load_params * params);
 
 /*
  * Session init params.
@@ -944,8 +932,7 @@ struct transcribe_session_params {
     int32_t            n_ctx;
 };
 
-TRANSCRIBE_API void transcribe_session_params_init(
-    struct transcribe_session_params * params);
+TRANSCRIBE_API void transcribe_session_params_init(struct transcribe_session_params * params);
 
 /*
  * Per-run params.
@@ -1011,7 +998,7 @@ TRANSCRIBE_API void transcribe_session_params_init(
  *              before pointing `family` at it.
  */
 struct transcribe_run_params {
-    uint64_t                      struct_size;
+    uint64_t struct_size;
 
     transcribe_task               task;
     transcribe_timestamp_kind     timestamps;
@@ -1043,11 +1030,10 @@ struct transcribe_run_params {
      *   as ordinary autoregression). Probe the capability bit if you want
      *   to know whether the field will take effect.
      */
-    int32_t                       spec_k_drafts;
+    int32_t spec_k_drafts;
 };
 
-TRANSCRIBE_API void transcribe_run_params_init(
-    struct transcribe_run_params * params);
+TRANSCRIBE_API void transcribe_run_params_init(struct transcribe_run_params * params);
 
 /* ----------------------------------------------------------------------- */
 /* Capabilities                                                            */
@@ -1090,7 +1076,7 @@ TRANSCRIBE_API void transcribe_run_params_init(
  *     A new feature is +1 enum value with no struct_size churn.
  */
 struct transcribe_capabilities {
-    uint64_t                  struct_size;
+    uint64_t struct_size;
 
     int32_t                   native_sample_rate;
     int                       n_languages;
@@ -1119,9 +1105,9 @@ struct transcribe_capabilities {
      *     latency hints are family-specific and live on the family
      *     stream extension, not on this struct.
      */
-    bool                      supports_language_detect;
-    bool                      supports_translate;
-    bool                      supports_streaming;
+    bool supports_language_detect;
+    bool supports_translate;
+    bool supports_streaming;
 
     /*
      * supports_spec_decode: gates transcribe_run_params::spec_k_drafts.
@@ -1133,7 +1119,7 @@ struct transcribe_capabilities {
      *   strategy; callers can probe this bit if they want to know whether
      *   passing K will actually do anything.
      */
-    bool                      supports_spec_decode;
+    bool supports_spec_decode;
 
     /*
      * Streaming timing hints intentionally do NOT live here. Streaming
@@ -1180,7 +1166,7 @@ struct transcribe_capabilities {
      * does not set it is therefore reported as unbounded. See
      * docs/input-limits.md for the full contract.
      */
-    int64_t                   max_audio_ms;
+    int64_t max_audio_ms;
 
     /*
      * translate_target_languages / n_translate_target_languages: the set
@@ -1199,12 +1185,11 @@ struct transcribe_capabilities {
      * family-level target/pair checks (e.g. canary's pivot pairs) still
      * apply on top.
      */
-    int                       n_translate_target_languages;
-    const char * const *      translate_target_languages;
+    int                  n_translate_target_languages;
+    const char * const * translate_target_languages;
 };
 
-TRANSCRIBE_API void transcribe_capabilities_init(
-    struct transcribe_capabilities * out);
+TRANSCRIBE_API void transcribe_capabilities_init(struct transcribe_capabilities * out);
 
 /*
  * Read model capabilities into caller-owned storage. The caller
@@ -1221,9 +1206,8 @@ TRANSCRIBE_API void transcribe_capabilities_init(
  * model-owned storage and remain valid until transcribe_model_free().
  * The output struct itself is caller-owned.
  */
-TRANSCRIBE_API transcribe_status transcribe_model_get_capabilities(
-    const struct transcribe_model *  model,
-    struct transcribe_capabilities * out_caps);
+TRANSCRIBE_API transcribe_status transcribe_model_get_capabilities(const struct transcribe_model *  model,
+                                                                   struct transcribe_capabilities * out_caps);
 
 /*
  * Per-feature capability probe. Pure yes/no advisories that don't
@@ -1275,9 +1259,7 @@ typedef enum {
     TRANSCRIBE_FEATURE_ITN                  = 5,
 } transcribe_feature;
 
-TRANSCRIBE_API bool transcribe_model_supports(
-    const struct transcribe_model * model,
-    transcribe_feature              feature);
+TRANSCRIBE_API bool transcribe_model_supports(const struct transcribe_model * model, transcribe_feature feature);
 
 /*
  * Stable identifier strings read from GGUF and runtime state.
@@ -1334,8 +1316,7 @@ TRANSCRIBE_API const char * transcribe_model_backend(const struct transcribe_mod
  * arrays such as the token list are not). There is no fallback to the variant
  * slug — for that, use transcribe_model_variant_string().
  */
-TRANSCRIBE_API const char * transcribe_model_meta_val_str(
-    const struct transcribe_model * model, const char * key);
+TRANSCRIBE_API const char * transcribe_model_meta_val_str(const struct transcribe_model * model, const char * key);
 
 /* ----------------------------------------------------------------------- */
 /* Lifecycle                                                               */
@@ -1353,10 +1334,9 @@ TRANSCRIBE_API const char * transcribe_model_meta_val_str(
  * On success, *out_model is set and the caller owns it. On failure,
  * *out_model is set to NULL and a non-OK status is returned.
  */
-TRANSCRIBE_API transcribe_status transcribe_model_load_file(
-    const char *                           path,
-    const struct transcribe_model_load_params * params,
-    struct transcribe_model **             out_model);
+TRANSCRIBE_API transcribe_status transcribe_model_load_file(const char *                                path,
+                                                            const struct transcribe_model_load_params * params,
+                                                            struct transcribe_model **                  out_model);
 
 /*
  * Free a model. Only valid after every session derived from this model
@@ -1374,10 +1354,9 @@ TRANSCRIBE_API void transcribe_model_free(struct transcribe_model * model);
  * params may be NULL for library defaults, or initialize a struct with
  * transcribe_session_params_init(). See transcribe_model_load_file.
  */
-TRANSCRIBE_API transcribe_status transcribe_session_init(
-    struct transcribe_model *                model,
-    const struct transcribe_session_params * params,
-    struct transcribe_session **             out_session);
+TRANSCRIBE_API transcribe_status transcribe_session_init(struct transcribe_model *                model,
+                                                         const struct transcribe_session_params * params,
+                                                         struct transcribe_session **             out_session);
 
 /*
  * Free a session.
@@ -1411,11 +1390,10 @@ TRANSCRIBE_API void transcribe_session_free(struct transcribe_session * session)
  * status transcribe_model_load_file / transcribe_session_init would
  * return; no partial state leaks).
  */
-TRANSCRIBE_API transcribe_status transcribe_open(
-    const char *                                path,
-    const struct transcribe_model_load_params * load_params,
-    const struct transcribe_session_params *    session_params,
-    struct transcribe_session **                out_session);
+TRANSCRIBE_API transcribe_status transcribe_open(const char *                                path,
+                                                 const struct transcribe_model_load_params * load_params,
+                                                 const struct transcribe_session_params *    session_params,
+                                                 struct transcribe_session **                out_session);
 
 /*
  * Deprecated alias for transcribe_session_free. Both honor owns_model and
@@ -1433,8 +1411,7 @@ TRANSCRIBE_API void transcribe_close(struct transcribe_session * session);
  * capabilities query without holding a separate model handle. Returns
  * NULL if session is NULL.
  */
-TRANSCRIBE_API const struct transcribe_model * transcribe_get_model(
-    const struct transcribe_session * session);
+TRANSCRIBE_API const struct transcribe_model * transcribe_get_model(const struct transcribe_session * session);
 
 /* ----------------------------------------------------------------------- */
 /* Run                                                                     */
@@ -1457,11 +1434,10 @@ TRANSCRIBE_API const struct transcribe_model * transcribe_get_model(
  * the accessors below. Calling transcribe_run() again replaces the
  * previous result on the same session.
  */
-TRANSCRIBE_API transcribe_status transcribe_run(
-    struct transcribe_session *      session,
-    const float *                    pcm,
-    int                              n_samples,
-    const struct transcribe_run_params * params);
+TRANSCRIBE_API transcribe_status transcribe_run(struct transcribe_session *          session,
+                                                const float *                        pcm,
+                                                int                                  n_samples,
+                                                const struct transcribe_run_params * params);
 
 /* ----------------------------------------------------------------------- */
 /* Batch run (offline)                                                     */
@@ -1540,12 +1516,11 @@ TRANSCRIBE_API transcribe_status transcribe_run(
  *                                  transcribe_batch_n_results is n (one slot
  *                                  per input utterance).
  */
-TRANSCRIBE_API transcribe_status transcribe_run_batch(
-    struct transcribe_session *          session,
-    const float * const *                pcm,
-    const int *                          n_samples,
-    int                                  n,
-    const struct transcribe_run_params * params);
+TRANSCRIBE_API transcribe_status transcribe_run_batch(struct transcribe_session *          session,
+                                                      const float * const *                pcm,
+                                                      const int *                          n_samples,
+                                                      int                                  n,
+                                                      const struct transcribe_run_params * params);
 
 /* ----------------------------------------------------------------------- */
 /* Cancellation                                                            */
@@ -1583,10 +1558,9 @@ typedef bool (*transcribe_abort_callback)(void * user_data);
  * another thread should do so by flipping state inside the callback's
  * user_data, not by swapping the callback itself.
  */
-TRANSCRIBE_API void transcribe_set_abort_callback(
-    struct transcribe_session *  session,
-    transcribe_abort_callback    cb,
-    void *                       user_data);
+TRANSCRIBE_API void transcribe_set_abort_callback(struct transcribe_session * session,
+                                                  transcribe_abort_callback   cb,
+                                                  void *                      user_data);
 
 /*
  * True if the most recent transcribe_run was aborted by the installed
@@ -1677,8 +1651,7 @@ struct transcribe_session_limits {
     int64_t  max_kv_bytes;
 };
 
-TRANSCRIBE_API void transcribe_session_limits_init(
-    struct transcribe_session_limits * out);
+TRANSCRIBE_API void transcribe_session_limits_init(struct transcribe_session_limits * out);
 
 /*
  * Read the effective limits for a session into caller-owned storage. The
@@ -1692,9 +1665,8 @@ TRANSCRIBE_API void transcribe_session_limits_init(
  *                                  library minimum.
  *   TRANSCRIBE_OK                  otherwise.
  */
-TRANSCRIBE_API transcribe_status transcribe_session_get_limits(
-    const struct transcribe_session *   session,
-    struct transcribe_session_limits *  out);
+TRANSCRIBE_API transcribe_status transcribe_session_get_limits(const struct transcribe_session *  session,
+                                                               struct transcribe_session_limits * out);
 
 /* ----------------------------------------------------------------------- */
 /* Streaming                                                               */
@@ -1829,14 +1801,13 @@ typedef enum {
  *                                it is committed.
  */
 struct transcribe_stream_params {
-    uint64_t                      struct_size;
-    const struct transcribe_ext * family;
+    uint64_t                        struct_size;
+    const struct transcribe_ext *   family;
     transcribe_stream_commit_policy commit_policy;
-    uint32_t                      stable_prefix_agreement_n;
+    uint32_t                        stable_prefix_agreement_n;
 };
 
-TRANSCRIBE_API void transcribe_stream_params_init(
-    struct transcribe_stream_params * params);
+TRANSCRIBE_API void transcribe_stream_params_init(struct transcribe_stream_params * params);
 
 /*
  * Optional per-call change metadata returned by feed/finalize.
@@ -1896,18 +1867,17 @@ TRANSCRIBE_API void transcribe_stream_params_init(
  */
 struct transcribe_stream_update {
     uint64_t struct_size;
-    bool    result_changed;
-    bool    is_final;
-    int32_t revision;
-    int64_t input_received_ms;
-    int64_t audio_committed_ms;
-    int64_t buffered_ms;
-    bool    committed_changed;
-    bool    tentative_changed;
+    bool     result_changed;
+    bool     is_final;
+    int32_t  revision;
+    int64_t  input_received_ms;
+    int64_t  audio_committed_ms;
+    int64_t  buffered_ms;
+    bool     committed_changed;
+    bool     tentative_changed;
 };
 
-TRANSCRIBE_API void transcribe_stream_update_init(
-    struct transcribe_stream_update * out);
+TRANSCRIBE_API void transcribe_stream_update_init(struct transcribe_stream_update * out);
 
 /*
  * UI-facing stream text snapshot.
@@ -1949,7 +1919,7 @@ TRANSCRIBE_API void transcribe_stream_update_init(
  * transcribe_session_free on the same session.
  */
 struct transcribe_stream_text {
-    uint64_t struct_size;
+    uint64_t     struct_size;
     const char * full_text;
     uint64_t     full_text_bytes;
     const char * committed_text;
@@ -1959,12 +1929,10 @@ struct transcribe_stream_text {
     uint64_t     raw_tentative_start_bytes;
 };
 
-TRANSCRIBE_API void transcribe_stream_text_init(
-    struct transcribe_stream_text * out);
+TRANSCRIBE_API void transcribe_stream_text_init(struct transcribe_stream_text * out);
 
-TRANSCRIBE_API transcribe_status transcribe_stream_get_text(
-    const struct transcribe_session * session,
-    struct transcribe_stream_text *   out);
+TRANSCRIBE_API transcribe_status transcribe_stream_get_text(const struct transcribe_session * session,
+                                                            struct transcribe_stream_text *   out);
 
 /*
  * Begin a streaming run on session.
@@ -2056,10 +2024,9 @@ TRANSCRIBE_API transcribe_status transcribe_stream_get_text(
  * structs and every pointer inside them the moment begin returns, while
  * the stream stays ACTIVE. Nothing handed to begin needs to outlive it.
  */
-TRANSCRIBE_API transcribe_status transcribe_stream_begin(
-    struct transcribe_session *              session,
-    const struct transcribe_run_params *         run_params,
-    const struct transcribe_stream_params *  stream_params);
+TRANSCRIBE_API transcribe_status transcribe_stream_begin(struct transcribe_session *             session,
+                                                         const struct transcribe_run_params *    run_params,
+                                                         const struct transcribe_stream_params * stream_params);
 
 /*
  * Feed PCM into the active stream. 16 kHz mono float32, same as
@@ -2083,11 +2050,10 @@ TRANSCRIBE_API transcribe_status transcribe_stream_begin(
  * is a terminal status; transcribe_was_aborted distinguishes it from
  * other failures.
  */
-TRANSCRIBE_API transcribe_status transcribe_stream_feed(
-    struct transcribe_session *        session,
-    const float *                      pcm,
-    int                                n_samples,
-    struct transcribe_stream_update *  update);
+TRANSCRIBE_API transcribe_status transcribe_stream_feed(struct transcribe_session *       session,
+                                                        const float *                     pcm,
+                                                        int                               n_samples,
+                                                        struct transcribe_stream_update * update);
 
 /*
  * Signal end of input. Flushes buffered audio, satisfies right-
@@ -2100,9 +2066,8 @@ TRANSCRIBE_API transcribe_status transcribe_stream_feed(
  * Returns TRANSCRIBE_ERR_INVALID_ARG when session is NULL or state is
  * not ACTIVE.
  */
-TRANSCRIBE_API transcribe_status transcribe_stream_finalize(
-    struct transcribe_session *        session,
-    struct transcribe_stream_update *  update);
+TRANSCRIBE_API transcribe_status transcribe_stream_finalize(struct transcribe_session *       session,
+                                                            struct transcribe_stream_update * update);
 
 /*
  * Abandon the current stream without finalizing.
@@ -2119,15 +2084,13 @@ TRANSCRIBE_API transcribe_status transcribe_stream_finalize(
  *
  * No-op if session is NULL.
  */
-TRANSCRIBE_API void transcribe_stream_reset(
-    struct transcribe_session * session);
+TRANSCRIBE_API void transcribe_stream_reset(struct transcribe_session * session);
 
 /*
  * Current stream lifecycle state. Returns TRANSCRIBE_STREAM_IDLE if
  * session is NULL.
  */
-TRANSCRIBE_API enum transcribe_stream_state
-    transcribe_stream_get_state(const struct transcribe_session * session);
+TRANSCRIBE_API enum transcribe_stream_state transcribe_stream_get_state(const struct transcribe_session * session);
 
 /*
  * Monotonic snapshot revision counter. Advances whenever any observable
@@ -2141,8 +2104,7 @@ TRANSCRIBE_API enum transcribe_stream_state
  * by itself mean the visible text changed; it means "something about
  * the snapshot moved, re-read the accessors."
  */
-TRANSCRIBE_API int transcribe_stream_revision(
-    const struct transcribe_session * session);
+TRANSCRIBE_API int transcribe_stream_revision(const struct transcribe_session * session);
 
 /*
  * Low-level raw row boundary hints. In older streaming APIs these were
@@ -2154,12 +2116,9 @@ TRANSCRIBE_API int transcribe_stream_revision(
  *
  * Return 0 if session is NULL.
  */
-TRANSCRIBE_API int transcribe_stream_n_committed_segments(
-    const struct transcribe_session * session);
-TRANSCRIBE_API int transcribe_stream_n_committed_words(
-    const struct transcribe_session * session);
-TRANSCRIBE_API int transcribe_stream_n_committed_tokens(
-    const struct transcribe_session * session);
+TRANSCRIBE_API int transcribe_stream_n_committed_segments(const struct transcribe_session * session);
+TRANSCRIBE_API int transcribe_stream_n_committed_words(const struct transcribe_session * session);
+TRANSCRIBE_API int transcribe_stream_n_committed_tokens(const struct transcribe_session * session);
 
 /*
  * Last terminal status of the stream. Preserves the failing status
@@ -2170,8 +2129,7 @@ TRANSCRIBE_API int transcribe_stream_n_committed_tokens(
  * Returns TRANSCRIBE_OK if session is NULL or no terminal status has
  * been recorded on the current stream.
  */
-TRANSCRIBE_API transcribe_status transcribe_stream_last_status(
-    const struct transcribe_session * session);
+TRANSCRIBE_API transcribe_status transcribe_stream_last_status(const struct transcribe_session * session);
 
 /* ----------------------------------------------------------------------- */
 /* Tokenization                                                            */
@@ -2203,11 +2161,10 @@ TRANSCRIBE_API transcribe_status transcribe_stream_last_status(
  *   - Parakeet     (SentencePiece; currently returns INT_MIN)
  *   - Cohere ASR   (SentencePiece; currently returns INT_MIN)
  */
-TRANSCRIBE_API int transcribe_tokenize(
-    const struct transcribe_model * model,
-    const char *                    text,
-    int32_t *                       tokens,
-    size_t                          n_max);
+TRANSCRIBE_API int transcribe_tokenize(const struct transcribe_model * model,
+                                       const char *                    text,
+                                       int32_t *                       tokens,
+                                       size_t                          n_max);
 
 /* ----------------------------------------------------------------------- */
 /* Timings                                                                 */
@@ -2236,10 +2193,10 @@ TRANSCRIBE_API int transcribe_tokenize(
  */
 struct transcribe_timings {
     uint64_t struct_size;
-    float  load_ms;
-    float  mel_ms;
-    float  encode_ms;
-    float  decode_ms;
+    float    load_ms;
+    float    mel_ms;
+    float    encode_ms;
+    float    decode_ms;
 };
 
 TRANSCRIBE_API void transcribe_timings_init(struct transcribe_timings * out);
@@ -2255,35 +2212,32 @@ TRANSCRIBE_API void transcribe_timings_init(struct transcribe_timings * out);
  *   TRANSCRIBE_ERR_BAD_STRUCT_SIZE out_timings->struct_size is 0 or
  *                                  smaller than the library's minimum.
  */
-TRANSCRIBE_API transcribe_status transcribe_get_timings(
-    const struct transcribe_session * session,
-    struct transcribe_timings *       out_timings);
+TRANSCRIBE_API transcribe_status transcribe_get_timings(const struct transcribe_session * session,
+                                                        struct transcribe_timings *       out_timings);
 
 /*
  * Pretty-print the current timings to the registered log callback at
  * INFO level (or stderr if no callback is installed). No-op if session
  * is NULL.
  */
-TRANSCRIBE_API void
-transcribe_print_timings(const struct transcribe_session * session);
+TRANSCRIBE_API void transcribe_print_timings(const struct transcribe_session * session);
 
 /*
  * Reset the per-run timing accumulators (mel_ms, encode_ms,
  * decode_ms) to 0. Does NOT touch load_ms — that's a model-scoped
  * fact. No-op if session is NULL.
  */
-TRANSCRIBE_API void
-transcribe_reset_timings(struct transcribe_session * session);
+TRANSCRIBE_API void transcribe_reset_timings(struct transcribe_session * session);
 
 /* ----------------------------------------------------------------------- */
 /* Result accessors - top level                                            */
 /* ----------------------------------------------------------------------- */
 
-TRANSCRIBE_API const char *               transcribe_full_text(const struct transcribe_session * session);
-TRANSCRIBE_API transcribe_timestamp_kind  transcribe_returned_timestamp_kind(const struct transcribe_session * session);
-TRANSCRIBE_API int                        transcribe_n_segments(const struct transcribe_session * session);
-TRANSCRIBE_API int                        transcribe_n_words(const struct transcribe_session * session);
-TRANSCRIBE_API int                        transcribe_n_tokens(const struct transcribe_session * session);
+TRANSCRIBE_API const char *              transcribe_full_text(const struct transcribe_session * session);
+TRANSCRIBE_API transcribe_timestamp_kind transcribe_returned_timestamp_kind(const struct transcribe_session * session);
+TRANSCRIBE_API int                       transcribe_n_segments(const struct transcribe_session * session);
+TRANSCRIBE_API int                       transcribe_n_words(const struct transcribe_session * session);
+TRANSCRIBE_API int                       transcribe_n_tokens(const struct transcribe_session * session);
 
 /*
  * The language the model itself predicted on the most recent run, as a
@@ -2303,7 +2257,7 @@ TRANSCRIBE_API int                        transcribe_n_tokens(const struct trans
  * streaming mode every transcribe_stream_feed / _finalize call may
  * invalidate it.
  */
-TRANSCRIBE_API const char *               transcribe_detected_language(const struct transcribe_session * session);
+TRANSCRIBE_API const char * transcribe_detected_language(const struct transcribe_session * session);
 
 /* ----------------------------------------------------------------------- */
 /* Result accessors - per-item rows                                        */
@@ -2347,7 +2301,7 @@ struct transcribe_segment {
     int          n_words;
     int          first_token;
     int          n_tokens;
-    const char * text;        /* session-owned; see lifetime note above */
+    const char * text; /* session-owned; see lifetime note above */
 };
 
 TRANSCRIBE_API void transcribe_segment_init(struct transcribe_segment * out);
@@ -2359,7 +2313,7 @@ struct transcribe_word {
     int          seg_index;
     int          first_token;
     int          n_tokens;
-    const char * text;        /* session-owned; see lifetime note above */
+    const char * text; /* session-owned; see lifetime note above */
 };
 
 TRANSCRIBE_API void transcribe_word_init(struct transcribe_word * out);
@@ -2383,7 +2337,7 @@ struct transcribe_token {
     int64_t      t1_ms;
     int          seg_index;
     int          word_index;
-    const char * text;        /* session-owned; see lifetime note above */
+    const char * text; /* session-owned; see lifetime note above */
 };
 
 TRANSCRIBE_API void transcribe_token_init(struct transcribe_token * out);
@@ -2402,20 +2356,17 @@ TRANSCRIBE_API void transcribe_token_init(struct transcribe_token * out);
  *                                  zero-initialized by INIT (text NULL,
  *                                  scalars 0).
  */
-TRANSCRIBE_API transcribe_status transcribe_get_segment(
-    const struct transcribe_session * session,
-    int                               i,
-    struct transcribe_segment *       out);
+TRANSCRIBE_API transcribe_status transcribe_get_segment(const struct transcribe_session * session,
+                                                        int                               i,
+                                                        struct transcribe_segment *       out);
 
-TRANSCRIBE_API transcribe_status transcribe_get_word(
-    const struct transcribe_session * session,
-    int                               i,
-    struct transcribe_word *          out);
+TRANSCRIBE_API transcribe_status transcribe_get_word(const struct transcribe_session * session,
+                                                     int                               i,
+                                                     struct transcribe_word *          out);
 
-TRANSCRIBE_API transcribe_status transcribe_get_token(
-    const struct transcribe_session * session,
-    int                               i,
-    struct transcribe_token *         out);
+TRANSCRIBE_API transcribe_status transcribe_get_token(const struct transcribe_session * session,
+                                                      int                               i,
+                                                      struct transcribe_token *         out);
 
 /* ----------------------------------------------------------------------- */
 /* Batch result accessors                                                  */
@@ -2463,8 +2414,7 @@ TRANSCRIBE_API transcribe_status transcribe_get_token(
  * fault other than abort (OOM, backend error) the count is unspecified;
  * the non-OK top-level return is the signal in that case.
  */
-TRANSCRIBE_API int transcribe_batch_n_results(
-    const struct transcribe_session * session);
+TRANSCRIBE_API int transcribe_batch_n_results(const struct transcribe_session * session);
 
 /*
  * Per-utterance terminal status. TRANSCRIBE_OK when utterance i produced a
@@ -2473,56 +2423,40 @@ TRANSCRIBE_API int transcribe_batch_n_results(
  * Returns TRANSCRIBE_ERR_INVALID_ARG if session is NULL or i is out of
  * range.
  */
-TRANSCRIBE_API transcribe_status transcribe_batch_status(
-    const struct transcribe_session * session,
-    int                               i);
+TRANSCRIBE_API transcribe_status transcribe_batch_status(const struct transcribe_session * session, int i);
 
-TRANSCRIBE_API const char * transcribe_batch_full_text(
-    const struct transcribe_session * session,
-    int                               i);
+TRANSCRIBE_API const char * transcribe_batch_full_text(const struct transcribe_session * session, int i);
 
-TRANSCRIBE_API transcribe_timestamp_kind transcribe_batch_returned_timestamp_kind(
-    const struct transcribe_session * session,
-    int                               i);
+TRANSCRIBE_API transcribe_timestamp_kind
+transcribe_batch_returned_timestamp_kind(const struct transcribe_session * session, int i);
 
-TRANSCRIBE_API const char * transcribe_batch_detected_language(
-    const struct transcribe_session * session,
-    int                               i);
+TRANSCRIBE_API const char * transcribe_batch_detected_language(const struct transcribe_session * session, int i);
 
-TRANSCRIBE_API int transcribe_batch_n_segments(
-    const struct transcribe_session * session,
-    int                               i);
+TRANSCRIBE_API int transcribe_batch_n_segments(const struct transcribe_session * session, int i);
 
-TRANSCRIBE_API int transcribe_batch_n_words(
-    const struct transcribe_session * session,
-    int                               i);
+TRANSCRIBE_API int transcribe_batch_n_words(const struct transcribe_session * session, int i);
 
-TRANSCRIBE_API int transcribe_batch_n_tokens(
-    const struct transcribe_session * session,
-    int                               i);
+TRANSCRIBE_API int transcribe_batch_n_tokens(const struct transcribe_session * session, int i);
 
 /*
  * Copy out row `j` of utterance `i`. The struct is initialized exactly as
  * for transcribe_get_segment / _word / _token (caller calls the matching
  * _init first); the only difference is the utterance index `i`.
  */
-TRANSCRIBE_API transcribe_status transcribe_batch_get_segment(
-    const struct transcribe_session * session,
-    int                               i,
-    int                               j,
-    struct transcribe_segment *       out);
+TRANSCRIBE_API transcribe_status transcribe_batch_get_segment(const struct transcribe_session * session,
+                                                              int                               i,
+                                                              int                               j,
+                                                              struct transcribe_segment *       out);
 
-TRANSCRIBE_API transcribe_status transcribe_batch_get_word(
-    const struct transcribe_session * session,
-    int                               i,
-    int                               j,
-    struct transcribe_word *          out);
+TRANSCRIBE_API transcribe_status transcribe_batch_get_word(const struct transcribe_session * session,
+                                                           int                               i,
+                                                           int                               j,
+                                                           struct transcribe_word *          out);
 
-TRANSCRIBE_API transcribe_status transcribe_batch_get_token(
-    const struct transcribe_session * session,
-    int                               i,
-    int                               j,
-    struct transcribe_token *         out);
+TRANSCRIBE_API transcribe_status transcribe_batch_get_token(const struct transcribe_session * session,
+                                                            int                               i,
+                                                            int                               j,
+                                                            struct transcribe_token *         out);
 
 /*
  * Per-utterance timings for a batched run. Mirrors transcribe_get_timings but
@@ -2537,10 +2471,9 @@ TRANSCRIBE_API transcribe_status transcribe_batch_get_token(
  * Returns TRANSCRIBE_ERR_INVALID_ARG on NULL args or out-of-range i,
  * TRANSCRIBE_ERR_BAD_STRUCT_SIZE on an uninitialized out struct.
  */
-TRANSCRIBE_API transcribe_status transcribe_batch_get_timings(
-    const struct transcribe_session * session,
-    int                               i,
-    struct transcribe_timings *       out);
+TRANSCRIBE_API transcribe_status transcribe_batch_get_timings(const struct transcribe_session * session,
+                                                              int                               i,
+                                                              struct transcribe_timings *       out);
 
 #ifdef __cplusplus
 } /* extern "C" */
diff --git a/include/transcribe/parakeet.h b/include/transcribe/parakeet.h
index 3625073d..b19cf1d9 100644
--- a/include/transcribe/parakeet.h
+++ b/include/transcribe/parakeet.h
@@ -25,9 +25,9 @@ extern "C" {
 #endif
 
 /* 'PKST' little-endian = 0x54534B50 */
-#define TRANSCRIBE_EXT_KIND_PARAKEET_STREAM           0x54534B50u
+#define TRANSCRIBE_EXT_KIND_PARAKEET_STREAM          0x54534B50u
 /* 'PKBS' little-endian = 0x53424B50 */
-#define TRANSCRIBE_EXT_KIND_PARAKEET_BUFFERED_STREAM  0x53424B50u
+#define TRANSCRIBE_EXT_KIND_PARAKEET_BUFFERED_STREAM 0x53424B50u
 
 /*
  * Cache-aware streaming knob (nemotron-speech-streaming-en-0.6b).
@@ -64,8 +64,7 @@ struct transcribe_parakeet_stream_ext {
 };
 
 /* Fills ext.size/kind and att_context_right = -1 (model default). */
-TRANSCRIBE_API void transcribe_parakeet_stream_ext_init(
-    struct transcribe_parakeet_stream_ext * ext);
+TRANSCRIBE_API void transcribe_parakeet_stream_ext_init(struct transcribe_parakeet_stream_ext * ext);
 
 /*
  * Chunked-attention (buffered) streaming knob (parakeet-unified-en-0.6b).
@@ -104,8 +103,7 @@ struct transcribe_parakeet_buffered_stream_ext {
 };
 
 /* Fills ext.size/kind and left/chunk/right_ms = -1 (model default). */
-TRANSCRIBE_API void transcribe_parakeet_buffered_stream_ext_init(
-    struct transcribe_parakeet_buffered_stream_ext * ext);
+TRANSCRIBE_API void transcribe_parakeet_buffered_stream_ext_init(struct transcribe_parakeet_buffered_stream_ext * ext);
 
 #ifdef __cplusplus
 } /* extern "C" */
diff --git a/include/transcribe/voxtral_realtime.h b/include/transcribe/voxtral_realtime.h
index dcbb6b4d..42becdaf 100644
--- a/include/transcribe/voxtral_realtime.h
+++ b/include/transcribe/voxtral_realtime.h
@@ -70,8 +70,7 @@ struct transcribe_voxtral_realtime_stream_ext {
  * Fills ext.size/kind and num_delay_tokens = -1 (model default),
  * min_decode_interval_ms = -1 (family default).
  */
-TRANSCRIBE_API void transcribe_voxtral_realtime_stream_ext_init(
-    struct transcribe_voxtral_realtime_stream_ext * ext);
+TRANSCRIBE_API void transcribe_voxtral_realtime_stream_ext_init(struct transcribe_voxtral_realtime_stream_ext * ext);
 
 #ifdef __cplusplus
 } /* extern "C" */
diff --git a/include/transcribe/whisper.h b/include/transcribe/whisper.h
index 9ed37a36..f40d0d66 100644
--- a/include/transcribe/whisper.h
+++ b/include/transcribe/whisper.h
@@ -45,8 +45,8 @@ extern "C" {
  *   Check shape "X > thold"  →  disable with +INF (_THOLD_DISABLED).
  *   Check shape "X < thold"  →  disable with -INF (_LOGPROB_DISABLED).
  */
-#define TRANSCRIBE_WHISPER_THOLD_DISABLED   ((float) INFINITY)   /* +INF */
-#define TRANSCRIBE_WHISPER_LOGPROB_DISABLED ((float) -INFINITY)  /* -INF */
+#define TRANSCRIBE_WHISPER_THOLD_DISABLED   ((float) INFINITY)  /* +INF */
+#define TRANSCRIBE_WHISPER_LOGPROB_DISABLED ((float) -INFINITY) /* -INF */
 
 /*
  * How an initial prompt composes with condition_on_prev_tokens on
@@ -119,21 +119,21 @@ struct transcribe_whisper_run_ext {
      * disables for the next chunk when the prior chunk was accepted at
      * temperature >= 0.5 (matches HF ":1090-1093").
      */
-    bool            condition_on_prev_tokens;
+    bool condition_on_prev_tokens;
 
     /* Cap for carried prev tokens; default 223 = max_target_positions/2 - 1. */
-    int32_t         max_prev_context_tokens;
+    int32_t max_prev_context_tokens;
 
     /*
      * Sampling + temperature fallback. Default behavior matches
      * Whisper's own recipe, not HF generate()'s library-default.
      * Use the _DISABLED sentinels to turn off individual thresholds.
      */
-    float           temperature;             /* first-tier; default 0.0 */
-    float           temperature_inc;         /* default 0.2             */
-    float           compression_ratio_thold; /* default 2.4             */
-    float           logprob_thold;           /* default -1.0            */
-    float           no_speech_thold;         /* default 0.6             */
+    float temperature;             /* first-tier; default 0.0 */
+    float temperature_inc;         /* default 0.2             */
+    float compression_ratio_thold; /* default 2.4             */
+    float logprob_thold;           /* default -1.0            */
+    float no_speech_thold;         /* default 0.6             */
 
     /*
      * Seed for the sampler at temperature > 0. 0 = nondeterministic
@@ -142,15 +142,14 @@ struct transcribe_whisper_run_ext {
      * Ignored when temperature == 0.0 (greedy decode is deterministic
      * by construction).
      */
-    uint32_t        seed;
+    uint32_t seed;
 
     /* Seconds. Caps the first emitted timestamp; default 1.0. */
-    float           max_initial_timestamp;
+    float max_initial_timestamp;
 };
 
 /* Fills ext.size/kind and the Whisper decoding recipe defaults. */
-TRANSCRIBE_API void transcribe_whisper_run_ext_init(
-    struct transcribe_whisper_run_ext * ext);
+TRANSCRIBE_API void transcribe_whisper_run_ext_init(struct transcribe_whisper_run_ext * ext);
 
 /* ----------------------------------------------------------------------- */
 /* Whisper decoding trace                                                  */
@@ -176,7 +175,7 @@ struct transcribe_whisper_chunk_trace {
     uint64_t struct_size;
     int64_t  t0_ms;
     int64_t  t1_ms;
-    float    temperature_used;    /* the tier that was accepted */
+    float    temperature_used; /* the tier that was accepted */
     float    compression_ratio;
     float    avg_logprob;
     float    no_speech_prob;
@@ -184,15 +183,13 @@ struct transcribe_whisper_chunk_trace {
     int32_t  n_fallbacks;         /* tiers tried before accept (0 = tier 0 accepted) */
 };
 
-TRANSCRIBE_API void transcribe_whisper_chunk_trace_init(
-    struct transcribe_whisper_chunk_trace * out);
+TRANSCRIBE_API void transcribe_whisper_chunk_trace_init(struct transcribe_whisper_chunk_trace * out);
 
 /*
  * Number of chunk traces captured on the most recent successful run.
  * Returns 0 before any run or on non-Whisper contexts.
  */
-TRANSCRIBE_API int transcribe_get_whisper_chunk_count(
-    const struct transcribe_session * session);
+TRANSCRIBE_API int transcribe_get_whisper_chunk_count(const struct transcribe_session * session);
 
 /*
  * Read the trace at index [0, count) into caller-owned storage.
@@ -209,10 +206,9 @@ TRANSCRIBE_API int transcribe_get_whisper_chunk_count(
  *                                  left as zero-initialized by the init
  *                                  function.
  */
-TRANSCRIBE_API transcribe_status transcribe_get_whisper_chunk_trace(
-    const struct transcribe_session *       session,
-    int                                     i,
-    struct transcribe_whisper_chunk_trace * out_trace);
+TRANSCRIBE_API transcribe_status transcribe_get_whisper_chunk_trace(const struct transcribe_session *       session,
+                                                                    int                                     i,
+                                                                    struct transcribe_whisper_chunk_trace * out_trace);
 
 #ifdef __cplusplus
 } /* extern "C" */
diff --git a/scripts/ci/clang-format.sh b/scripts/ci/clang-format.sh
new file mode 100755
index 00000000..8cdf0add
--- /dev/null
+++ b/scripts/ci/clang-format.sh
@@ -0,0 +1,101 @@
+#!/usr/bin/env bash
+# clang-format.sh - canonical formatter for transcribe.cpp's own C/C++.
+#
+# Single source of truth for three things, so local dev and CI can never drift:
+#   1. the pinned clang-format version (fetched via uvx, not the system binary);
+#   2. which files are "ours" vs vendored / verbatim-upstream;
+#   3. the exact check the CI gate runs.
+#
+# Usage:
+#   scripts/ci/clang-format.sh [--fix]            format our tree in place (default)
+#   scripts/ci/clang-format.sh --check            fail if our whole tree is unformatted
+#   scripts/ci/clang-format.sh --check-diff [REF] fail only on files changed vs REF
+#                                                 (default origin/main)
+set -euo pipefail
+
+# Pinned clang-format. Bump here and reformat the tree in the SAME commit.
+# Fetched through uvx so the result never depends on a locally installed binary.
+CF_VERSION="22.1.5"
+
+# Paths we never format: vendored upstream trees, and files copied verbatim from
+# upstream (kept byte-identical so future re-syncs stay clean).
+EXCLUDE_RE='^(ggml/|src/third_party/|src/transcribe-unicode-data\.cpp$)'
+
+cd "$(git rev-parse --show-toplevel)"
+
+CF=(uvx "clang-format@${CF_VERSION}")
+EXTS=('*.c' '*.cc' '*.cpp' '*.cxx' '*.h' '*.hh' '*.hpp' '*.hxx')
+
+# Our tracked C/C++, vendored/verbatim paths removed.
+ours_all() {
+    git ls-files -- "${EXTS[@]}" | grep -vE "$EXCLUDE_RE" || true
+}
+
+# Same, restricted to files added/copied/modified/renamed vs a ref's merge base.
+ours_changed() {
+    local base
+    base="$(git merge-base "$1" HEAD)"
+    git diff --name-only --diff-filter=ACMR "$base" -- "${EXTS[@]}" \
+        | grep -vE "$EXCLUDE_RE" || true
+}
+
+# Read a newline list from stdin into the global SELECTED array (bash 3.2 safe).
+SELECTED=()
+collect() {
+    SELECTED=()
+    local line
+    while IFS= read -r line; do
+        [ -n "$line" ] && SELECTED+=("$line")
+    done
+}
+
+check() {
+    if [ "${#SELECTED[@]}" -eq 0 ]; then
+        echo "clang-format: no files to check."
+        return 0
+    fi
+    echo "clang-format ${CF_VERSION}: checking ${#SELECTED[@]} file(s)."
+    "${CF[@]}" --dry-run --Werror "${SELECTED[@]}"
+}
+
+fix() {
+    if [ "${#SELECTED[@]}" -eq 0 ]; then
+        echo "clang-format: no files to format."
+        return 0
+    fi
+    echo "clang-format ${CF_VERSION}: formatting ${#SELECTED[@]} file(s)."
+    # clang-format -i is not always idempotent: trailing-comment alignment can
+    # need a second pass to settle. Iterate until the result already satisfies
+    # --check, so what we write can never fail the CI gate.
+    local pass
+    for pass in 1 2 3; do
+        "${CF[@]}" -i "${SELECTED[@]}"
+        if "${CF[@]}" --dry-run --Werror "${SELECTED[@]}" >/dev/null 2>&1; then
+            return 0
+        fi
+    done
+    echo "error: clang-format did not converge after 3 passes." >&2
+    return 1
+}
+
+case "${1:---fix}" in
+    --fix)
+        collect < <(ours_all)
+        fix
+        ;;
+    --check)
+        collect < <(ours_all)
+        check
+        ;;
+    --check-diff)
+        collect < <(ours_changed "${2:-origin/main}")
+        check
+        ;;
+    -h | --help)
+        echo "usage: $0 [--fix | --check | --check-diff [REF]]"
+        ;;
+    *)
+        echo "unknown option: $1" >&2
+        exit 2
+        ;;
+esac
diff --git a/src/arch/canary/canary.h b/src/arch/canary/canary.h
index 3fd4dba8..558fe85c 100644
--- a/src/arch/canary/canary.h
+++ b/src/arch/canary/canary.h
@@ -6,16 +6,15 @@
 
 #pragma once
 
+#include "ggml-backend.h"
+#include "ggml.h"
 #include "transcribe-backend.h"
-#include "transcribe-session.h"
 #include "transcribe-mel.h"
 #include "transcribe-model.h"
+#include "transcribe-session.h"
 #include "transcribe-tokenizer.h"
 #include "weights.h"
 
-#include "ggml.h"
-#include "ggml-backend.h"
-
 #include <cstdint>
 #include <optional>
 #include <string>
@@ -39,18 +38,18 @@ void apply_family_invariants(transcribe_model & model);
 // ---------------------------------------------------------------------------
 
 struct CanaryKvCache {
-    ggml_tensor * self_k = nullptr;
-    ggml_tensor * self_v = nullptr;
+    ggml_tensor * self_k  = nullptr;
+    ggml_tensor * self_v  = nullptr;
     ggml_tensor * cross_k = nullptr;
     ggml_tensor * cross_v = nullptr;
 
-    ggml_context * ctx = nullptr;
+    ggml_context *        ctx    = nullptr;
     ggml_backend_buffer_t buffer = nullptr;
 
     int n_ctx = 0;
     int n     = 0;
     int head  = 0;
-    int T_enc = 0;   // T_enc_max for a batched cache (shorter utts padded)
+    int T_enc = 0;  // T_enc_max for a batched cache (shorter utts padded)
 
     // Utterance batch width. 1 for single-shot; > 1 for the offline batched
     // decoder. Self slab (layer, b) at (b + n_batch*layer)*n_ctx*hidden;
@@ -68,13 +67,13 @@ struct CanaryKvCache {
             ggml_free(ctx);
             ctx = nullptr;
         }
-        self_k = nullptr;
-        self_v = nullptr;
-        cross_k = nullptr;
-        cross_v = nullptr;
-        n = 0;
-        head = 0;
-        n_batch = 1;
+        self_k          = nullptr;
+        self_v          = nullptr;
+        cross_k         = nullptr;
+        cross_v         = nullptr;
+        n               = 0;
+        head            = 0;
+        n_batch         = 1;
         cross_populated = false;
     }
 };
@@ -99,21 +98,21 @@ bool kv_cache_init_batched(CanaryKvCache & cache,
                            ggml_type       kv_type);
 
 struct CanaryModel final : public transcribe_model {
-    Tokenizer       tok;
-    CanaryHParams   hparams;
-    CanaryWeights   weights;
-    ggml_context *  ctx_meta = nullptr;
+    Tokenizer      tok;
+    CanaryHParams  hparams;
+    CanaryWeights  weights;
+    ggml_context * ctx_meta = nullptr;
 
     transcribe::BackendPlan plan;
     ggml_backend_buffer_t   backend_buffer = nullptr;
 
     // Fused BN parameters (same as parakeet/cohere).
-    ggml_context *          bn_fused_ctx    = nullptr;
-    ggml_backend_buffer_t   bn_fused_buffer = nullptr;
+    ggml_context *        bn_fused_ctx    = nullptr;
+    ggml_backend_buffer_t bn_fused_buffer = nullptr;
 
     // CPU-only F16 -> F32 promotion buffer for conformer 1x1 pointwise convs.
-    ggml_context *          conv_pw_f32_ctx    = nullptr;
-    ggml_backend_buffer_t   conv_pw_f32_buffer = nullptr;
+    ggml_context *        conv_pw_f32_ctx    = nullptr;
+    ggml_backend_buffer_t conv_pw_f32_buffer = nullptr;
 
     std::optional<transcribe::MelFrontend> mel;
 
@@ -124,9 +123,9 @@ struct CanaryModel final : public transcribe_model {
 };
 
 struct CanarySession final : public transcribe_session {
-    ggml_context *        compute_ctx = nullptr;
-    ggml_backend_sched_t  sched       = nullptr;
-    ggml_tensor *         encoder_out = nullptr;
+    ggml_context *       compute_ctx = nullptr;
+    ggml_backend_sched_t sched       = nullptr;
+    ggml_tensor *        encoder_out = nullptr;
 
     CanaryKvCache kv_cache;
 
@@ -135,7 +134,6 @@ struct CanarySession final : public transcribe_session {
     std::vector<float> pos_div_term;
     std::vector<float> enc_host;
 
-
     // Per-stage flash-attention controls. ggml's Metal flash kernel lacks a
     // path for some encoder rel-pos MHSA dk values (96 for 180m-flash, 128
     // otherwise), so encoder flash defaults off on Metal; decoder defaults on.
@@ -146,4 +144,4 @@ struct CanarySession final : public transcribe_session {
     ~CanarySession() override;
 };
 
-} // namespace transcribe::canary
+}  // namespace transcribe::canary
diff --git a/src/arch/canary/capabilities.cpp b/src/arch/canary/capabilities.cpp
index b7ef0698..338ceafe 100644
--- a/src/arch/canary/capabilities.cpp
+++ b/src/arch/canary/capabilities.cpp
@@ -26,7 +26,7 @@ void apply_family_invariants(transcribe_model & model) {
     // unset and a non-DEFAULT itn against canary triggers the
     // advisory WARN.
     transcribe::set_feature(&model, TRANSCRIBE_FEATURE_CANCELLATION, true);
-    transcribe::set_feature(&model, TRANSCRIBE_FEATURE_PNC,          true);
+    transcribe::set_feature(&model, TRANSCRIBE_FEATURE_PNC, true);
 }
 
-} // namespace transcribe::canary
+}  // namespace transcribe::canary
diff --git a/src/arch/canary/decoder.cpp b/src/arch/canary/decoder.cpp
index 7de56080..6683cdee 100644
--- a/src/arch/canary/decoder.cpp
+++ b/src/arch/canary/decoder.cpp
@@ -5,12 +5,10 @@
 #include "decoder.h"
 
 #include "canary.h"
-#include "weights.h"
-
+#include "ggml.h"
 #include "transcribe-debug.h"
 #include "transcribe-log.h"
-
-#include "ggml.h"
+#include "weights.h"
 
 #include <cmath>
 #include <cstdio>
@@ -23,103 +21,107 @@ namespace {
 constexpr float kLayerNormEps = 1e-5f;
 
 ggml_tensor * named(ggml_tensor * t, const char * name) {
-    if (t != nullptr) ggml_set_name(t, name);
+    if (t != nullptr) {
+        ggml_set_name(t, name);
+    }
     return t;
 }
 
-ggml_tensor * layer_norm(ggml_context * ctx,
-                         ggml_tensor *  x,
-                         ggml_tensor *  gamma,
-                         ggml_tensor *  beta)
-{
+ggml_tensor * layer_norm(ggml_context * ctx, ggml_tensor * x, ggml_tensor * gamma, ggml_tensor * beta) {
     ggml_tensor * y = ggml_norm(ctx, x, kLayerNormEps);
-    y = ggml_mul(ctx, y, gamma);
-    if (beta != nullptr) y = ggml_add(ctx, y, beta);
+    y               = ggml_mul(ctx, y, gamma);
+    if (beta != nullptr) {
+        y = ggml_add(ctx, y, beta);
+    }
     return y;
 }
 
 // Self-attention with KV cache. Mirrors cohere's mha_self_cached.
-ggml_tensor * mha_self_cached(
-    ggml_context * ctx,
-    ggml_cgraph *  gf,
-    ggml_tensor *  x,
-    CanaryKvCache & kv_cache,
-    ggml_tensor *  mask,
-    ggml_tensor *  q_w, ggml_tensor * q_b,
-    ggml_tensor *  k_w, ggml_tensor * k_b,
-    ggml_tensor *  v_w, ggml_tensor * v_b,
-    ggml_tensor *  out_w, ggml_tensor * out_b,
-    int            n_heads,
-    int            hidden,
-    int            il,
-    int            n_past,
-    int            n_tokens,
-    bool           use_flash)
-{
-    const int head_dim = hidden / n_heads;
-    const float scale  = 1.0f / std::sqrt(static_cast<float>(head_dim));
-    const int n_ctx    = kv_cache.n_ctx;
-    const int n_kv     = n_past + n_tokens;
+ggml_tensor * mha_self_cached(ggml_context *  ctx,
+                              ggml_cgraph *   gf,
+                              ggml_tensor *   x,
+                              CanaryKvCache & kv_cache,
+                              ggml_tensor *   mask,
+                              ggml_tensor *   q_w,
+                              ggml_tensor *   q_b,
+                              ggml_tensor *   k_w,
+                              ggml_tensor *   k_b,
+                              ggml_tensor *   v_w,
+                              ggml_tensor *   v_b,
+                              ggml_tensor *   out_w,
+                              ggml_tensor *   out_b,
+                              int             n_heads,
+                              int             hidden,
+                              int             il,
+                              int             n_past,
+                              int             n_tokens,
+                              bool            use_flash) {
+    const int   head_dim = hidden / n_heads;
+    const float scale    = 1.0f / std::sqrt(static_cast<float>(head_dim));
+    const int   n_ctx    = kv_cache.n_ctx;
+    const int   n_kv     = n_past + n_tokens;
 
     ggml_tensor * Qcur = ggml_mul_mat(ctx, q_w, x);
-    if (q_b != nullptr) Qcur = ggml_add(ctx, Qcur, q_b);
+    if (q_b != nullptr) {
+        Qcur = ggml_add(ctx, Qcur, q_b);
+    }
 
     ggml_tensor * Kcur = ggml_mul_mat(ctx, k_w, x);
-    if (k_b != nullptr) Kcur = ggml_add(ctx, Kcur, k_b);
+    if (k_b != nullptr) {
+        Kcur = ggml_add(ctx, Kcur, k_b);
+    }
 
     ggml_tensor * Vcur = ggml_mul_mat(ctx, v_w, x);
-    if (v_b != nullptr) Vcur = ggml_add(ctx, Vcur, v_b);
+    if (v_b != nullptr) {
+        Vcur = ggml_add(ctx, Vcur, v_b);
+    }
 
     ggml_tensor * Q = ggml_reshape_3d(ctx, Qcur, head_dim, n_heads, n_tokens);
-    Q = ggml_permute(ctx, Q, 0, 2, 1, 3);
+    Q               = ggml_permute(ctx, Q, 0, 2, 1, 3);
 
     {
-        ggml_tensor * k_dst = ggml_view_1d(ctx, kv_cache.self_k,
-            static_cast<int64_t>(n_tokens) * hidden,
-            ggml_element_size(kv_cache.self_k) * static_cast<size_t>(
-                static_cast<int64_t>(il) * n_ctx * hidden +
-                static_cast<int64_t>(n_past) * hidden));
-
-        ggml_tensor * v_dst = ggml_view_1d(ctx, kv_cache.self_v,
-            static_cast<int64_t>(n_tokens) * hidden,
-            ggml_element_size(kv_cache.self_v) * static_cast<size_t>(
-                static_cast<int64_t>(il) * n_ctx * hidden +
-                static_cast<int64_t>(n_past) * hidden));
+        ggml_tensor * k_dst = ggml_view_1d(
+            ctx, kv_cache.self_k, static_cast<int64_t>(n_tokens) * hidden,
+            ggml_element_size(kv_cache.self_k) *
+                static_cast<size_t>(static_cast<int64_t>(il) * n_ctx * hidden + static_cast<int64_t>(n_past) * hidden));
+
+        ggml_tensor * v_dst = ggml_view_1d(
+            ctx, kv_cache.self_v, static_cast<int64_t>(n_tokens) * hidden,
+            ggml_element_size(kv_cache.self_v) *
+                static_cast<size_t>(static_cast<int64_t>(il) * n_ctx * hidden + static_cast<int64_t>(n_past) * hidden));
 
         ggml_build_forward_expand(gf, ggml_cpy(ctx, Kcur, k_dst));
         ggml_build_forward_expand(gf, ggml_cpy(ctx, Vcur, v_dst));
     }
 
-    ggml_tensor * K = ggml_view_3d(ctx, kv_cache.self_k,
-        head_dim, n_kv, n_heads,
-        ggml_element_size(kv_cache.self_k) * hidden,
+    ggml_tensor * K = ggml_view_3d(
+        ctx, kv_cache.self_k, head_dim, n_kv, n_heads, ggml_element_size(kv_cache.self_k) * hidden,
         ggml_element_size(kv_cache.self_k) * head_dim,
-        ggml_element_size(kv_cache.self_k) * static_cast<size_t>(
-            static_cast<int64_t>(il) * n_ctx * hidden));
+        ggml_element_size(kv_cache.self_k) * static_cast<size_t>(static_cast<int64_t>(il) * n_ctx * hidden));
 
-    ggml_tensor * V = ggml_view_3d(ctx, kv_cache.self_v,
-        head_dim, n_kv, n_heads,
-        ggml_element_size(kv_cache.self_v) * hidden,
+    ggml_tensor * V = ggml_view_3d(
+        ctx, kv_cache.self_v, head_dim, n_kv, n_heads, ggml_element_size(kv_cache.self_v) * hidden,
         ggml_element_size(kv_cache.self_v) * head_dim,
-        ggml_element_size(kv_cache.self_v) * static_cast<size_t>(
-            static_cast<int64_t>(il) * n_ctx * hidden));
+        ggml_element_size(kv_cache.self_v) * static_cast<size_t>(static_cast<int64_t>(il) * n_ctx * hidden));
 
     ggml_tensor * o;
     if (use_flash) {
         o = ggml_flash_attn_ext(ctx, Q, K, V, mask, scale, 0.0f, 0.0f);
         o = ggml_reshape_2d(ctx, o, hidden, n_tokens);
     } else {
-        ggml_tensor * kq = ggml_mul_mat(ctx, K, Q);
+        ggml_tensor * kq      = ggml_mul_mat(ctx, K, Q);
         ggml_tensor * kq_soft = ggml_soft_max_ext(ctx, kq, mask, scale, 0.0f);
-        ggml_tensor * v_t = ggml_cont(ctx, ggml_permute(ctx, V, 1, 0, 2, 3));
-        o = ggml_mul_mat(ctx, v_t, kq_soft);
-        o = ggml_permute(ctx, o, 0, 2, 1, 3);
-        o = ggml_cont(ctx, o);
-        o = ggml_reshape_2d(ctx, o, hidden, n_tokens);
+        ggml_tensor * v_t     = ggml_cont(ctx, ggml_permute(ctx, V, 1, 0, 2, 3));
+        o                     = ggml_mul_mat(ctx, v_t, kq_soft);
+        o                     = ggml_permute(ctx, o, 0, 2, 1, 3);
+        o                     = ggml_cont(ctx, o);
+        o                     = ggml_reshape_2d(ctx, o, hidden, n_tokens);
     }
 
     o = ggml_mul_mat(ctx, out_w, o);
-    if (out_b != nullptr) o = ggml_add(ctx, o, out_b);
+    if (out_b != nullptr) {
+        o = ggml_add(ctx, o, out_b);
+    }
     return o;
 }
 
@@ -127,182 +129,180 @@ ggml_tensor * mha_self_cached(
 // go through ggml_set_rows at runtime row index `kv_idx`; reads span
 // the full [0, max_n_kv) window with `mask` gating valid positions.
 // n_tokens is implicitly 1.
-ggml_tensor * mha_self_step(
-    ggml_context * ctx,
-    ggml_cgraph *  gf,
-    ggml_tensor *  x,
-    CanaryKvCache & kv_cache,
-    ggml_tensor *  mask,
-    ggml_tensor *  kv_idx,
-    ggml_tensor *  q_w, ggml_tensor * q_b,
-    ggml_tensor *  k_w, ggml_tensor * k_b,
-    ggml_tensor *  v_w, ggml_tensor * v_b,
-    ggml_tensor *  out_w, ggml_tensor * out_b,
-    int            n_heads,
-    int            hidden,
-    int            il,
-    int            max_n_kv,
-    bool           use_flash)
-{
-    const int head_dim = hidden / n_heads;
-    const float scale  = 1.0f / std::sqrt(static_cast<float>(head_dim));
-    const int n_ctx    = kv_cache.n_ctx;
+ggml_tensor * mha_self_step(ggml_context *  ctx,
+                            ggml_cgraph *   gf,
+                            ggml_tensor *   x,
+                            CanaryKvCache & kv_cache,
+                            ggml_tensor *   mask,
+                            ggml_tensor *   kv_idx,
+                            ggml_tensor *   q_w,
+                            ggml_tensor *   q_b,
+                            ggml_tensor *   k_w,
+                            ggml_tensor *   k_b,
+                            ggml_tensor *   v_w,
+                            ggml_tensor *   v_b,
+                            ggml_tensor *   out_w,
+                            ggml_tensor *   out_b,
+                            int             n_heads,
+                            int             hidden,
+                            int             il,
+                            int             max_n_kv,
+                            bool            use_flash) {
+    const int   head_dim = hidden / n_heads;
+    const float scale    = 1.0f / std::sqrt(static_cast<float>(head_dim));
+    const int   n_ctx    = kv_cache.n_ctx;
 
     ggml_tensor * Qcur = ggml_mul_mat(ctx, q_w, x);
-    if (q_b != nullptr) Qcur = ggml_add(ctx, Qcur, q_b);
+    if (q_b != nullptr) {
+        Qcur = ggml_add(ctx, Qcur, q_b);
+    }
 
     ggml_tensor * Kcur = ggml_mul_mat(ctx, k_w, x);
-    if (k_b != nullptr) Kcur = ggml_add(ctx, Kcur, k_b);
+    if (k_b != nullptr) {
+        Kcur = ggml_add(ctx, Kcur, k_b);
+    }
 
     ggml_tensor * Vcur = ggml_mul_mat(ctx, v_w, x);
-    if (v_b != nullptr) Vcur = ggml_add(ctx, Vcur, v_b);
+    if (v_b != nullptr) {
+        Vcur = ggml_add(ctx, Vcur, v_b);
+    }
 
     ggml_tensor * Q = ggml_reshape_3d(ctx, Qcur, head_dim, n_heads, /*n_tokens=*/1);
-    Q = ggml_permute(ctx, Q, 0, 2, 1, 3);
+    Q               = ggml_permute(ctx, Q, 0, 2, 1, 3);
 
     // KV cache write via ggml_set_rows. Static topology — only kv_idx's
     // value changes per step. Per-layer view spans [hidden, n_ctx], and
     // we write a single [hidden, 1] row at the kv_idx position.
     {
-        const size_t k_elem = ggml_element_size(kv_cache.self_k);
-        const size_t v_elem = ggml_element_size(kv_cache.self_v);
-        const size_t layer_off_k = k_elem * static_cast<size_t>(
-            static_cast<int64_t>(il) * n_ctx * hidden);
-        const size_t layer_off_v = v_elem * static_cast<size_t>(
-            static_cast<int64_t>(il) * n_ctx * hidden);
-
-        ggml_tensor * k_layer = ggml_view_2d(
-            ctx, kv_cache.self_k,
-            hidden, n_ctx,
-            k_elem * hidden, layer_off_k);
-        ggml_tensor * v_layer = ggml_view_2d(
-            ctx, kv_cache.self_v,
-            hidden, n_ctx,
-            v_elem * hidden, layer_off_v);
+        const size_t k_elem      = ggml_element_size(kv_cache.self_k);
+        const size_t v_elem      = ggml_element_size(kv_cache.self_v);
+        const size_t layer_off_k = k_elem * static_cast<size_t>(static_cast<int64_t>(il) * n_ctx * hidden);
+        const size_t layer_off_v = v_elem * static_cast<size_t>(static_cast<int64_t>(il) * n_ctx * hidden);
+
+        ggml_tensor * k_layer = ggml_view_2d(ctx, kv_cache.self_k, hidden, n_ctx, k_elem * hidden, layer_off_k);
+        ggml_tensor * v_layer = ggml_view_2d(ctx, kv_cache.self_v, hidden, n_ctx, v_elem * hidden, layer_off_v);
 
         ggml_tensor * K_row = ggml_reshape_2d(ctx, Kcur, hidden, 1);
         ggml_tensor * V_row = ggml_reshape_2d(ctx, Vcur, hidden, 1);
 
-        ggml_build_forward_expand(
-            gf, ggml_set_rows(ctx, k_layer, K_row, kv_idx));
-        ggml_build_forward_expand(
-            gf, ggml_set_rows(ctx, v_layer, V_row, kv_idx));
+        ggml_build_forward_expand(gf, ggml_set_rows(ctx, k_layer, K_row, kv_idx));
+        ggml_build_forward_expand(gf, ggml_set_rows(ctx, v_layer, V_row, kv_idx));
     }
 
     // Static read across [0, max_n_kv); mask zeros valid positions and
     // -inf's the rest, so flash-attn ignores empty/future slots. Costs
     // some bandwidth at low n_past — caller picks max_n_kv to bound it.
-    ggml_tensor * K = ggml_view_3d(ctx, kv_cache.self_k,
-        head_dim, max_n_kv, n_heads,
-        ggml_element_size(kv_cache.self_k) * hidden,
+    ggml_tensor * K = ggml_view_3d(
+        ctx, kv_cache.self_k, head_dim, max_n_kv, n_heads, ggml_element_size(kv_cache.self_k) * hidden,
         ggml_element_size(kv_cache.self_k) * head_dim,
-        ggml_element_size(kv_cache.self_k) * static_cast<size_t>(
-            static_cast<int64_t>(il) * n_ctx * hidden));
+        ggml_element_size(kv_cache.self_k) * static_cast<size_t>(static_cast<int64_t>(il) * n_ctx * hidden));
 
-    ggml_tensor * V = ggml_view_3d(ctx, kv_cache.self_v,
-        head_dim, max_n_kv, n_heads,
-        ggml_element_size(kv_cache.self_v) * hidden,
+    ggml_tensor * V = ggml_view_3d(
+        ctx, kv_cache.self_v, head_dim, max_n_kv, n_heads, ggml_element_size(kv_cache.self_v) * hidden,
         ggml_element_size(kv_cache.self_v) * head_dim,
-        ggml_element_size(kv_cache.self_v) * static_cast<size_t>(
-            static_cast<int64_t>(il) * n_ctx * hidden));
+        ggml_element_size(kv_cache.self_v) * static_cast<size_t>(static_cast<int64_t>(il) * n_ctx * hidden));
 
     ggml_tensor * o;
     if (use_flash) {
         o = ggml_flash_attn_ext(ctx, Q, K, V, mask, scale, 0.0f, 0.0f);
         o = ggml_reshape_2d(ctx, o, hidden, 1);
     } else {
-        ggml_tensor * kq = ggml_mul_mat(ctx, K, Q);
+        ggml_tensor * kq      = ggml_mul_mat(ctx, K, Q);
         ggml_tensor * kq_soft = ggml_soft_max_ext(ctx, kq, mask, scale, 0.0f);
-        ggml_tensor * v_t = ggml_cont(ctx, ggml_permute(ctx, V, 1, 0, 2, 3));
-        o = ggml_mul_mat(ctx, v_t, kq_soft);
-        o = ggml_permute(ctx, o, 0, 2, 1, 3);
-        o = ggml_cont(ctx, o);
-        o = ggml_reshape_2d(ctx, o, hidden, 1);
+        ggml_tensor * v_t     = ggml_cont(ctx, ggml_permute(ctx, V, 1, 0, 2, 3));
+        o                     = ggml_mul_mat(ctx, v_t, kq_soft);
+        o                     = ggml_permute(ctx, o, 0, 2, 1, 3);
+        o                     = ggml_cont(ctx, o);
+        o                     = ggml_reshape_2d(ctx, o, hidden, 1);
     }
 
     o = ggml_mul_mat(ctx, out_w, o);
-    if (out_b != nullptr) o = ggml_add(ctx, o, out_b);
+    if (out_b != nullptr) {
+        o = ggml_add(ctx, o, out_b);
+    }
     return o;
 }
 
 // Cross-attention reading from pre-populated KV cache.
-ggml_tensor * mha_cross_cached(
-    ggml_context * ctx,
-    ggml_tensor *  x,
-    CanaryKvCache & kv_cache,
-    ggml_tensor *  q_w, ggml_tensor * q_b,
-    ggml_tensor *  out_w, ggml_tensor * out_b,
-    int            n_heads,
-    int            hidden,
-    int            il,
-    int            T_enc,
-    bool           use_flash)
-{
-    const int head_dim = hidden / n_heads;
-    const float scale  = 1.0f / std::sqrt(static_cast<float>(head_dim));
+ggml_tensor * mha_cross_cached(ggml_context *  ctx,
+                               ggml_tensor *   x,
+                               CanaryKvCache & kv_cache,
+                               ggml_tensor *   q_w,
+                               ggml_tensor *   q_b,
+                               ggml_tensor *   out_w,
+                               ggml_tensor *   out_b,
+                               int             n_heads,
+                               int             hidden,
+                               int             il,
+                               int             T_enc,
+                               bool            use_flash) {
+    const int     head_dim = hidden / n_heads;
+    const float   scale    = 1.0f / std::sqrt(static_cast<float>(head_dim));
     const int64_t n_tokens = x->ne[1];
 
     ggml_tensor * Qcur = ggml_mul_mat(ctx, q_w, x);
-    if (q_b != nullptr) Qcur = ggml_add(ctx, Qcur, q_b);
+    if (q_b != nullptr) {
+        Qcur = ggml_add(ctx, Qcur, q_b);
+    }
 
     ggml_tensor * Q = ggml_reshape_3d(ctx, Qcur, head_dim, n_heads, n_tokens);
-    Q = ggml_permute(ctx, Q, 0, 2, 1, 3);
+    Q               = ggml_permute(ctx, Q, 0, 2, 1, 3);
 
-    ggml_tensor * K = ggml_view_3d(ctx, kv_cache.cross_k,
-        head_dim, T_enc, n_heads,
-        ggml_element_size(kv_cache.cross_k) * hidden,
+    ggml_tensor * K = ggml_view_3d(
+        ctx, kv_cache.cross_k, head_dim, T_enc, n_heads, ggml_element_size(kv_cache.cross_k) * hidden,
         ggml_element_size(kv_cache.cross_k) * head_dim,
-        ggml_element_size(kv_cache.cross_k) * static_cast<size_t>(
-            static_cast<int64_t>(il) * T_enc * hidden));
+        ggml_element_size(kv_cache.cross_k) * static_cast<size_t>(static_cast<int64_t>(il) * T_enc * hidden));
 
-    ggml_tensor * V = ggml_view_3d(ctx, kv_cache.cross_v,
-        head_dim, T_enc, n_heads,
-        ggml_element_size(kv_cache.cross_v) * hidden,
+    ggml_tensor * V = ggml_view_3d(
+        ctx, kv_cache.cross_v, head_dim, T_enc, n_heads, ggml_element_size(kv_cache.cross_v) * hidden,
         ggml_element_size(kv_cache.cross_v) * head_dim,
-        ggml_element_size(kv_cache.cross_v) * static_cast<size_t>(
-            static_cast<int64_t>(il) * T_enc * hidden));
+        ggml_element_size(kv_cache.cross_v) * static_cast<size_t>(static_cast<int64_t>(il) * T_enc * hidden));
 
     ggml_tensor * o;
     if (use_flash) {
         o = ggml_flash_attn_ext(ctx, Q, K, V, nullptr, scale, 0.0f, 0.0f);
         o = ggml_reshape_2d(ctx, o, hidden, n_tokens);
     } else {
-        ggml_tensor * kq = ggml_mul_mat(ctx, K, Q);
+        ggml_tensor * kq      = ggml_mul_mat(ctx, K, Q);
         ggml_tensor * kq_soft = ggml_soft_max_ext(ctx, kq, nullptr, scale, 0.0f);
-        ggml_tensor * v_t = ggml_cont(ctx, ggml_permute(ctx, V, 1, 0, 2, 3));
-        o = ggml_mul_mat(ctx, v_t, kq_soft);
-        o = ggml_permute(ctx, o, 0, 2, 1, 3);
-        o = ggml_cont(ctx, o);
-        o = ggml_reshape_2d(ctx, o, hidden, n_tokens);
+        ggml_tensor * v_t     = ggml_cont(ctx, ggml_permute(ctx, V, 1, 0, 2, 3));
+        o                     = ggml_mul_mat(ctx, v_t, kq_soft);
+        o                     = ggml_permute(ctx, o, 0, 2, 1, 3);
+        o                     = ggml_cont(ctx, o);
+        o                     = ggml_reshape_2d(ctx, o, hidden, n_tokens);
     }
 
     o = ggml_mul_mat(ctx, out_w, o);
-    if (out_b != nullptr) o = ggml_add(ctx, o, out_b);
+    if (out_b != nullptr) {
+        o = ggml_add(ctx, o, out_b);
+    }
     return o;
 }
 
 // Layers we attach per-sublayer dump points to: {0, n_layers/2, n_layers-1}
 // (deduped when the set collapses, n_layers <= 2).
 bool is_dump_layer(int i, int n_layers) {
-    if (n_layers <= 0) return false;
-    if (i == 0 || i == n_layers - 1) return true;
+    if (n_layers <= 0) {
+        return false;
+    }
+    if (i == 0 || i == n_layers - 1) {
+        return true;
+    }
     return i == n_layers / 2;
 }
 
-} // namespace
+}  // namespace
 
-DecoderBuild build_cross_kv_graph(ggml_context *         ctx,
-                                  const CanaryWeights &  w,
-                                  const CanaryHParams &  hp,
-                                  CanaryKvCache &        kv_cache,
-                                  int                    T_enc)
-{
-    DecoderBuild db {};
+DecoderBuild build_cross_kv_graph(ggml_context *        ctx,
+                                  const CanaryWeights & w,
+                                  const CanaryHParams & hp,
+                                  CanaryKvCache &       kv_cache,
+                                  int                   T_enc) {
+    DecoderBuild db{};
 
     if (ctx == nullptr || T_enc <= 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "canary cross_kv: invalid arg (ctx=%p, T_enc=%d)",
-                     static_cast<void *>(ctx), T_enc);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "canary cross_kv: invalid arg (ctx=%p, T_enc=%d)", static_cast<void *>(ctx),
+                T_enc);
         return db;
     }
 
@@ -322,20 +322,22 @@ DecoderBuild build_cross_kv_graph(ggml_context *         ctx,
         const auto & blk = w.dec_blocks[il];
 
         ggml_tensor * Kcross = ggml_mul_mat(ctx, blk.cross_k_w, db.encoder_out_in);
-        if (blk.cross_k_b != nullptr) Kcross = ggml_add(ctx, Kcross, blk.cross_k_b);
+        if (blk.cross_k_b != nullptr) {
+            Kcross = ggml_add(ctx, Kcross, blk.cross_k_b);
+        }
 
         ggml_tensor * Vcross = ggml_mul_mat(ctx, blk.cross_v_w, db.encoder_out_in);
-        if (blk.cross_v_b != nullptr) Vcross = ggml_add(ctx, Vcross, blk.cross_v_b);
+        if (blk.cross_v_b != nullptr) {
+            Vcross = ggml_add(ctx, Vcross, blk.cross_v_b);
+        }
 
-        ggml_tensor * k_dst = ggml_view_1d(ctx, kv_cache.cross_k,
-            static_cast<int64_t>(T_enc) * hidden,
-            ggml_element_size(kv_cache.cross_k) * static_cast<size_t>(
-                static_cast<int64_t>(il) * T_enc * hidden));
+        ggml_tensor * k_dst = ggml_view_1d(
+            ctx, kv_cache.cross_k, static_cast<int64_t>(T_enc) * hidden,
+            ggml_element_size(kv_cache.cross_k) * static_cast<size_t>(static_cast<int64_t>(il) * T_enc * hidden));
 
-        ggml_tensor * v_dst = ggml_view_1d(ctx, kv_cache.cross_v,
-            static_cast<int64_t>(T_enc) * hidden,
-            ggml_element_size(kv_cache.cross_v) * static_cast<size_t>(
-                static_cast<int64_t>(il) * T_enc * hidden));
+        ggml_tensor * v_dst = ggml_view_1d(
+            ctx, kv_cache.cross_v, static_cast<int64_t>(T_enc) * hidden,
+            ggml_element_size(kv_cache.cross_v) * static_cast<size_t>(static_cast<int64_t>(il) * T_enc * hidden));
 
         ggml_build_forward_expand(db.graph, ggml_cpy(ctx, Kcross, k_dst));
         ggml_build_forward_expand(db.graph, ggml_cpy(ctx, Vcross, v_dst));
@@ -344,23 +346,22 @@ DecoderBuild build_cross_kv_graph(ggml_context *         ctx,
     return db;
 }
 
-DecoderBuild build_decoder_graph_kv(ggml_context *         ctx,
-                                    const CanaryWeights &  w,
-                                    const CanaryHParams &  hp,
-                                    CanaryKvCache &        kv_cache,
-                                    int                    n_tokens,
-                                    int                    n_past,
-                                    int                    T_enc,
-                                    bool                   skip_log_softmax,
-                                    bool                   use_flash)
-{
-    DecoderBuild db {};
+DecoderBuild build_decoder_graph_kv(ggml_context *        ctx,
+                                    const CanaryWeights & w,
+                                    const CanaryHParams & hp,
+                                    CanaryKvCache &       kv_cache,
+                                    int                   n_tokens,
+                                    int                   n_past,
+                                    int                   T_enc,
+                                    bool                  skip_log_softmax,
+                                    bool                  use_flash) {
+    DecoderBuild db{};
 
     if (ctx == nullptr || n_tokens <= 0 || T_enc <= 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "canary decoder_kv: invalid arg "
-                     "(ctx=%p, n_tokens=%d, T_enc=%d)",
-                     static_cast<void *>(ctx), n_tokens, T_enc);
+                "canary decoder_kv: invalid arg "
+                "(ctx=%p, n_tokens=%d, T_enc=%d)",
+                static_cast<void *>(ctx), n_tokens, T_enc);
         return db;
     }
 
@@ -377,19 +378,19 @@ DecoderBuild build_decoder_graph_kv(ggml_context *         ctx,
     ggml_set_input(db.pos_ids_in);
 
     ggml_tensor * tok_emb = ggml_get_rows(ctx, w.dec_embed.token_w, db.token_ids_in);
-    tok_emb = named(tok_emb, "dec.token_emb");
+    tok_emb               = named(tok_emb, "dec.token_emb");
     ggml_set_output(tok_emb);
     db.dumps.token_emb = tok_emb;
 
     ggml_tensor * pos_emb = ggml_get_rows(ctx, w.dec_embed.pos_enc, db.pos_ids_in);
-    pos_emb = named(pos_emb, "dec.pos_emb");
+    pos_emb               = named(pos_emb, "dec.pos_emb");
     ggml_set_output(pos_emb);
     db.dumps.pos_emb = pos_emb;
 
     // Embedding layer norm: NeMo applies it AFTER tok+pos sum.
     ggml_tensor * x = ggml_add(ctx, tok_emb, pos_emb);
-    x = layer_norm(ctx, x, w.dec_embed.norm_w, w.dec_embed.norm_b);
-    x = named(x, "dec.embed_norm");
+    x               = layer_norm(ctx, x, w.dec_embed.norm_w, w.dec_embed.norm_b);
+    x               = named(x, "dec.embed_norm");
     ggml_set_output(x);
     db.dumps.embed_norm = x;
 
@@ -409,22 +410,17 @@ DecoderBuild build_decoder_graph_kv(ggml_context *         ctx,
     }
 
     for (int i = 0; i < hp.dec_n_layers; ++i) {
-        const auto & blk = w.dec_blocks[i];
-        const bool dump_this = is_dump_layer(i, hp.dec_n_layers) && i < 64;
+        const auto & blk       = w.dec_blocks[i];
+        const bool   dump_this = is_dump_layer(i, hp.dec_n_layers) && i < 64;
 
         // norm1 + self-attention. NeMo's forward_hook captures the sublayer
         // output BEFORE the residual add, so we dump self_out, not x.
         {
             ggml_tensor * x_norm = layer_norm(ctx, x, blk.norm1_w, blk.norm1_b);
-            ggml_tensor * self_out = mha_self_cached(
-                ctx, db.graph, x_norm, kv_cache, causal_mask,
-                blk.self_q_w, blk.self_q_b,
-                blk.self_k_w, blk.self_k_b,
-                blk.self_v_w, blk.self_v_b,
-                blk.self_o_w, blk.self_o_b,
-                n_heads, static_cast<int>(hidden),
-                i, n_past, n_tokens,
-                use_flash);
+            ggml_tensor * self_out =
+                mha_self_cached(ctx, db.graph, x_norm, kv_cache, causal_mask, blk.self_q_w, blk.self_q_b, blk.self_k_w,
+                                blk.self_k_b, blk.self_v_w, blk.self_v_b, blk.self_o_w, blk.self_o_b, n_heads,
+                                static_cast<int>(hidden), i, n_past, n_tokens, use_flash);
             if (dump_this) {
                 char bname[64];
                 std::snprintf(bname, sizeof(bname), "dec.layer.%d.self_attn.out", i);
@@ -438,13 +434,9 @@ DecoderBuild build_decoder_graph_kv(ggml_context *         ctx,
         // norm2 + cross-attention (dump before residual, as above).
         {
             ggml_tensor * x_norm = layer_norm(ctx, x, blk.norm2_w, blk.norm2_b);
-            ggml_tensor * cross_out = mha_cross_cached(
-                ctx, x_norm, kv_cache,
-                blk.cross_q_w, blk.cross_q_b,
-                blk.cross_o_w, blk.cross_o_b,
-                n_heads, static_cast<int>(hidden),
-                i, T_enc,
-                use_flash);
+            ggml_tensor * cross_out =
+                mha_cross_cached(ctx, x_norm, kv_cache, blk.cross_q_w, blk.cross_q_b, blk.cross_o_w, blk.cross_o_b,
+                                 n_heads, static_cast<int>(hidden), i, T_enc, use_flash);
             if (dump_this) {
                 char bname[64];
                 std::snprintf(bname, sizeof(bname), "dec.layer.%d.cross_attn.out", i);
@@ -458,15 +450,19 @@ DecoderBuild build_decoder_graph_kv(ggml_context *         ctx,
         // norm3 + FFN (dump before residual, as above).
         {
             ggml_tensor * x_norm = layer_norm(ctx, x, blk.norm3_w, blk.norm3_b);
-            ggml_tensor * ff = ggml_mul_mat(ctx, blk.ffn_up_w, x_norm);
-            if (blk.ffn_up_b != nullptr) ff = ggml_add(ctx, ff, blk.ffn_up_b);
+            ggml_tensor * ff     = ggml_mul_mat(ctx, blk.ffn_up_w, x_norm);
+            if (blk.ffn_up_b != nullptr) {
+                ff = ggml_add(ctx, ff, blk.ffn_up_b);
+            }
             if (hp.dec_activation == "relu") {
                 ff = ggml_relu(ctx, ff);
             } else {
                 ff = ggml_silu(ctx, ff);
             }
             ff = ggml_mul_mat(ctx, blk.ffn_down_w, ff);
-            if (blk.ffn_down_b != nullptr) ff = ggml_add(ctx, ff, blk.ffn_down_b);
+            if (blk.ffn_down_b != nullptr) {
+                ff = ggml_add(ctx, ff, blk.ffn_down_b);
+            }
             if (dump_this) {
                 char bname[64];
                 std::snprintf(bname, sizeof(bname), "dec.layer.%d.ffn.out", i);
@@ -479,8 +475,8 @@ DecoderBuild build_decoder_graph_kv(ggml_context *         ctx,
     }
 
     // Final LayerNorm (NeMo applies this after the last block).
-    x = layer_norm(ctx, x, w.dec_final.norm_w, w.dec_final.norm_b);
-    x = named(x, "dec.out_before_head");
+    x                        = layer_norm(ctx, x, w.dec_final.norm_w, w.dec_final.norm_b);
+    x                        = named(x, "dec.out_before_head");
     db.dumps.out_before_head = x;
 
     // Untied LM head.
@@ -496,7 +492,7 @@ DecoderBuild build_decoder_graph_kv(ggml_context *         ctx,
     if (!skip_log_softmax) {
         logits = ggml_log(ctx, ggml_soft_max(ctx, logits));
     }
-    logits = named(logits, "dec.logits");
+    logits          = named(logits, "dec.logits");
     db.dumps.logits = logits;
 
     db.out = logits;
@@ -505,11 +501,10 @@ DecoderBuild build_decoder_graph_kv(ggml_context *         ctx,
     if (skip_log_softmax) {
         ggml_tensor * last_logits = logits;
         if (n_tokens > 1) {
-            const int64_t vocab = logits->ne[0];
+            const int64_t vocab     = logits->ne[0];
             const size_t  row_bytes = ggml_element_size(logits) * vocab;
-            last_logits = ggml_view_2d(ctx, logits, vocab, /*n=*/1,
-                                       row_bytes, row_bytes * (n_tokens - 1));
-            last_logits = ggml_cont(ctx, last_logits);
+            last_logits             = ggml_view_2d(ctx, logits, vocab, /*n=*/1, row_bytes, row_bytes * (n_tokens - 1));
+            last_logits             = ggml_cont(ctx, last_logits);
         }
         db.argmax_out = ggml_argmax(ctx, last_logits);
         ggml_set_name(db.argmax_out, "dec.argmax");
@@ -528,21 +523,17 @@ StepBuild build_step_graph(ggml_context *        ctx,
                            CanaryKvCache &       kv_cache,
                            int                   max_n_kv,
                            int                   T_enc,
-                           bool                  use_flash)
-{
-    StepBuild sb {};
+                           bool                  use_flash) {
+    StepBuild sb{};
     sb.max_n_kv = max_n_kv;
 
     if (ctx == nullptr || max_n_kv <= 0 || T_enc <= 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "canary step: invalid arg (max_n_kv=%d, T_enc=%d)",
-                     max_n_kv, T_enc);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "canary step: invalid arg (max_n_kv=%d, T_enc=%d)", max_n_kv, T_enc);
         return sb;
     }
     if (max_n_kv > kv_cache.n_ctx) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "canary step: max_n_kv=%d exceeds kv_cache.n_ctx=%d",
-                     max_n_kv, kv_cache.n_ctx);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "canary step: max_n_kv=%d exceeds kv_cache.n_ctx=%d", max_n_kv,
+                kv_cache.n_ctx);
         return sb;
     }
 
@@ -573,50 +564,45 @@ StepBuild build_step_graph(ggml_context *        ctx,
 
     ggml_tensor * tok_emb = ggml_get_rows(ctx, w.dec_embed.token_w, sb.token_id_in);
     ggml_tensor * pos_emb = ggml_get_rows(ctx, w.dec_embed.pos_enc, sb.pos_id_in);
-    ggml_tensor * x = ggml_add(ctx, tok_emb, pos_emb);
-    x = layer_norm(ctx, x, w.dec_embed.norm_w, w.dec_embed.norm_b);
+    ggml_tensor * x       = ggml_add(ctx, tok_emb, pos_emb);
+    x                     = layer_norm(ctx, x, w.dec_embed.norm_w, w.dec_embed.norm_b);
 
     for (int i = 0; i < hp.dec_n_layers; ++i) {
         const auto & blk = w.dec_blocks[i];
 
         {
             ggml_tensor * x_norm = layer_norm(ctx, x, blk.norm1_w, blk.norm1_b);
-            ggml_tensor * self_out = mha_self_step(
-                ctx, sb.graph, x_norm, kv_cache, sb.mask_in, sb.kv_idx_in,
-                blk.self_q_w, blk.self_q_b,
-                blk.self_k_w, blk.self_k_b,
-                blk.self_v_w, blk.self_v_b,
-                blk.self_o_w, blk.self_o_b,
-                n_heads, static_cast<int>(hidden),
-                i, max_n_kv,
-                use_flash);
+            ggml_tensor * self_out =
+                mha_self_step(ctx, sb.graph, x_norm, kv_cache, sb.mask_in, sb.kv_idx_in, blk.self_q_w, blk.self_q_b,
+                              blk.self_k_w, blk.self_k_b, blk.self_v_w, blk.self_v_b, blk.self_o_w, blk.self_o_b,
+                              n_heads, static_cast<int>(hidden), i, max_n_kv, use_flash);
             x = ggml_add(ctx, x, self_out);
         }
 
         // norm2 + cross-attention. cross_k/v are pre-populated full T_enc.
         {
             ggml_tensor * x_norm = layer_norm(ctx, x, blk.norm2_w, blk.norm2_b);
-            ggml_tensor * cross_out = mha_cross_cached(
-                ctx, x_norm, kv_cache,
-                blk.cross_q_w, blk.cross_q_b,
-                blk.cross_o_w, blk.cross_o_b,
-                n_heads, static_cast<int>(hidden),
-                i, T_enc,
-                use_flash);
+            ggml_tensor * cross_out =
+                mha_cross_cached(ctx, x_norm, kv_cache, blk.cross_q_w, blk.cross_q_b, blk.cross_o_w, blk.cross_o_b,
+                                 n_heads, static_cast<int>(hidden), i, T_enc, use_flash);
             x = ggml_add(ctx, x, cross_out);
         }
 
         {
             ggml_tensor * x_norm = layer_norm(ctx, x, blk.norm3_w, blk.norm3_b);
-            ggml_tensor * ff = ggml_mul_mat(ctx, blk.ffn_up_w, x_norm);
-            if (blk.ffn_up_b != nullptr) ff = ggml_add(ctx, ff, blk.ffn_up_b);
+            ggml_tensor * ff     = ggml_mul_mat(ctx, blk.ffn_up_w, x_norm);
+            if (blk.ffn_up_b != nullptr) {
+                ff = ggml_add(ctx, ff, blk.ffn_up_b);
+            }
             if (hp.dec_activation == "relu") {
                 ff = ggml_relu(ctx, ff);
             } else {
                 ff = ggml_silu(ctx, ff);
             }
             ff = ggml_mul_mat(ctx, blk.ffn_down_w, ff);
-            if (blk.ffn_down_b != nullptr) ff = ggml_add(ctx, ff, blk.ffn_down_b);
+            if (blk.ffn_down_b != nullptr) {
+                ff = ggml_add(ctx, ff, blk.ffn_down_b);
+            }
             x = ggml_add(ctx, x, ff);
         }
     }
@@ -643,108 +629,132 @@ StepBuild build_step_graph(ggml_context *        ctx,
 namespace {
 
 // Batched self-attention step. x: [hidden, B] (one token per utterance).
-ggml_tensor * mha_self_step_batched(
-    ggml_context * ctx, ggml_cgraph * gf,
-    ggml_tensor * x, CanaryKvCache & kv_cache,
-    ggml_tensor * mask, ggml_tensor * kv_idx,
-    ggml_tensor * q_w, ggml_tensor * q_b,
-    ggml_tensor * k_w, ggml_tensor * k_b,
-    ggml_tensor * v_w, ggml_tensor * v_b,
-    ggml_tensor * out_w, ggml_tensor * out_b,
-    int n_heads, int hidden, int il, int max_n_kv, int B)
-{
-    const int head_dim = hidden / n_heads;
-    const float scale  = 1.0f / std::sqrt(static_cast<float>(head_dim));
-    const int64_t n_ctx = kv_cache.n_ctx;
-    const size_t k_elem = ggml_element_size(kv_cache.self_k);
-    const size_t v_elem = ggml_element_size(kv_cache.self_v);
+ggml_tensor * mha_self_step_batched(ggml_context *  ctx,
+                                    ggml_cgraph *   gf,
+                                    ggml_tensor *   x,
+                                    CanaryKvCache & kv_cache,
+                                    ggml_tensor *   mask,
+                                    ggml_tensor *   kv_idx,
+                                    ggml_tensor *   q_w,
+                                    ggml_tensor *   q_b,
+                                    ggml_tensor *   k_w,
+                                    ggml_tensor *   k_b,
+                                    ggml_tensor *   v_w,
+                                    ggml_tensor *   v_b,
+                                    ggml_tensor *   out_w,
+                                    ggml_tensor *   out_b,
+                                    int             n_heads,
+                                    int             hidden,
+                                    int             il,
+                                    int             max_n_kv,
+                                    int             B) {
+    const int     head_dim = hidden / n_heads;
+    const float   scale    = 1.0f / std::sqrt(static_cast<float>(head_dim));
+    const int64_t n_ctx    = kv_cache.n_ctx;
+    const size_t  k_elem   = ggml_element_size(kv_cache.self_k);
+    const size_t  v_elem   = ggml_element_size(kv_cache.self_v);
 
     ggml_tensor * Qcur = ggml_mul_mat(ctx, q_w, x);
-    if (q_b != nullptr) Qcur = ggml_add(ctx, Qcur, q_b);
+    if (q_b != nullptr) {
+        Qcur = ggml_add(ctx, Qcur, q_b);
+    }
     ggml_tensor * Kcur = ggml_mul_mat(ctx, k_w, x);
-    if (k_b != nullptr) Kcur = ggml_add(ctx, Kcur, k_b);
+    if (k_b != nullptr) {
+        Kcur = ggml_add(ctx, Kcur, k_b);
+    }
     ggml_tensor * Vcur = ggml_mul_mat(ctx, v_w, x);
-    if (v_b != nullptr) Vcur = ggml_add(ctx, Vcur, v_b);
+    if (v_b != nullptr) {
+        Vcur = ggml_add(ctx, Vcur, v_b);
+    }
 
     ggml_tensor * Q = ggml_reshape_3d(ctx, Qcur, head_dim, n_heads, B);
 
     {
-        const size_t off_k = k_elem * static_cast<size_t>(il) * n_ctx * hidden * B;
-        const size_t off_v = v_elem * static_cast<size_t>(il) * n_ctx * hidden * B;
-        ggml_tensor * k_layer = ggml_view_3d(ctx, kv_cache.self_k,
-            hidden, n_ctx, B, k_elem * hidden, k_elem * hidden * n_ctx, off_k);
-        ggml_tensor * v_layer = ggml_view_3d(ctx, kv_cache.self_v,
-            hidden, n_ctx, B, v_elem * hidden, v_elem * hidden * n_ctx, off_v);
+        const size_t  off_k = k_elem * static_cast<size_t>(il) * n_ctx * hidden * B;
+        const size_t  off_v = v_elem * static_cast<size_t>(il) * n_ctx * hidden * B;
+        ggml_tensor * k_layer =
+            ggml_view_3d(ctx, kv_cache.self_k, hidden, n_ctx, B, k_elem * hidden, k_elem * hidden * n_ctx, off_k);
+        ggml_tensor * v_layer =
+            ggml_view_3d(ctx, kv_cache.self_v, hidden, n_ctx, B, v_elem * hidden, v_elem * hidden * n_ctx, off_v);
         ggml_tensor * K_row = ggml_reshape_3d(ctx, Kcur, hidden, 1, B);
         ggml_tensor * V_row = ggml_reshape_3d(ctx, Vcur, hidden, 1, B);
         ggml_build_forward_expand(gf, ggml_set_rows(ctx, k_layer, K_row, kv_idx));
         ggml_build_forward_expand(gf, ggml_set_rows(ctx, v_layer, V_row, kv_idx));
     }
 
-    const size_t off_k = k_elem * static_cast<size_t>(il) * n_ctx * hidden * B;
-    const size_t off_v = v_elem * static_cast<size_t>(il) * n_ctx * hidden * B;
-    ggml_tensor * K = ggml_view_4d(ctx, kv_cache.self_k,
-        head_dim, max_n_kv, n_heads, B,
-        k_elem * hidden, k_elem * head_dim, k_elem * hidden * n_ctx, off_k);
-    ggml_tensor * V = ggml_view_4d(ctx, kv_cache.self_v,
-        head_dim, max_n_kv, n_heads, B,
-        v_elem * hidden, v_elem * head_dim, v_elem * hidden * n_ctx, off_v);
+    const size_t  off_k = k_elem * static_cast<size_t>(il) * n_ctx * hidden * B;
+    const size_t  off_v = v_elem * static_cast<size_t>(il) * n_ctx * hidden * B;
+    ggml_tensor * K     = ggml_view_4d(ctx, kv_cache.self_k, head_dim, max_n_kv, n_heads, B, k_elem * hidden,
+                                       k_elem * head_dim, k_elem * hidden * n_ctx, off_k);
+    ggml_tensor * V     = ggml_view_4d(ctx, kv_cache.self_v, head_dim, max_n_kv, n_heads, B, v_elem * hidden,
+                                       v_elem * head_dim, v_elem * hidden * n_ctx, off_v);
 
     ggml_tensor * Q_att = ggml_cont(ctx, ggml_permute(ctx, Q, 0, 2, 3, 1));
-    ggml_tensor * o = ggml_flash_attn_ext(ctx, Q_att, K, V, mask, scale, 0.0f, 0.0f);
-    o = ggml_reshape_2d(ctx, o, hidden, B);
+    ggml_tensor * o     = ggml_flash_attn_ext(ctx, Q_att, K, V, mask, scale, 0.0f, 0.0f);
+    o                   = ggml_reshape_2d(ctx, o, hidden, B);
 
     o = ggml_mul_mat(ctx, out_w, o);
-    if (out_b != nullptr) o = ggml_add(ctx, o, out_b);
+    if (out_b != nullptr) {
+        o = ggml_add(ctx, o, out_b);
+    }
     return o;
 }
 
 // Batched cross-attention step. x: [hidden, B]; cross slab [hidden, T_enc_max, B].
-ggml_tensor * mha_cross_step_batched(
-    ggml_context * ctx, ggml_tensor * x, CanaryKvCache & kv_cache,
-    ggml_tensor * cross_mask,
-    ggml_tensor * q_w, ggml_tensor * q_b,
-    ggml_tensor * out_w, ggml_tensor * out_b,
-    int n_heads, int hidden, int il, int T_enc_max, int B)
-{
-    const int head_dim = hidden / n_heads;
-    const float scale  = 1.0f / std::sqrt(static_cast<float>(head_dim));
-    const size_t k_elem = ggml_element_size(kv_cache.cross_k);
-    const size_t v_elem = ggml_element_size(kv_cache.cross_v);
+ggml_tensor * mha_cross_step_batched(ggml_context *  ctx,
+                                     ggml_tensor *   x,
+                                     CanaryKvCache & kv_cache,
+                                     ggml_tensor *   cross_mask,
+                                     ggml_tensor *   q_w,
+                                     ggml_tensor *   q_b,
+                                     ggml_tensor *   out_w,
+                                     ggml_tensor *   out_b,
+                                     int             n_heads,
+                                     int             hidden,
+                                     int             il,
+                                     int             T_enc_max,
+                                     int             B) {
+    const int    head_dim = hidden / n_heads;
+    const float  scale    = 1.0f / std::sqrt(static_cast<float>(head_dim));
+    const size_t k_elem   = ggml_element_size(kv_cache.cross_k);
+    const size_t v_elem   = ggml_element_size(kv_cache.cross_v);
 
     ggml_tensor * Qcur = ggml_mul_mat(ctx, q_w, x);
-    if (q_b != nullptr) Qcur = ggml_add(ctx, Qcur, q_b);
-    ggml_tensor * Q = ggml_reshape_3d(ctx, Qcur, head_dim, n_heads, B);
+    if (q_b != nullptr) {
+        Qcur = ggml_add(ctx, Qcur, q_b);
+    }
+    ggml_tensor * Q     = ggml_reshape_3d(ctx, Qcur, head_dim, n_heads, B);
     ggml_tensor * Q_att = ggml_cont(ctx, ggml_permute(ctx, Q, 0, 2, 3, 1));
 
-    const size_t off_k = k_elem * static_cast<size_t>(il) * T_enc_max * hidden * B;
-    const size_t off_v = v_elem * static_cast<size_t>(il) * T_enc_max * hidden * B;
-    ggml_tensor * K = ggml_view_4d(ctx, kv_cache.cross_k,
-        head_dim, T_enc_max, n_heads, B,
-        k_elem * hidden, k_elem * head_dim, k_elem * hidden * T_enc_max, off_k);
-    ggml_tensor * V = ggml_view_4d(ctx, kv_cache.cross_v,
-        head_dim, T_enc_max, n_heads, B,
-        v_elem * hidden, v_elem * head_dim, v_elem * hidden * T_enc_max, off_v);
+    const size_t  off_k = k_elem * static_cast<size_t>(il) * T_enc_max * hidden * B;
+    const size_t  off_v = v_elem * static_cast<size_t>(il) * T_enc_max * hidden * B;
+    ggml_tensor * K     = ggml_view_4d(ctx, kv_cache.cross_k, head_dim, T_enc_max, n_heads, B, k_elem * hidden,
+                                       k_elem * head_dim, k_elem * hidden * T_enc_max, off_k);
+    ggml_tensor * V     = ggml_view_4d(ctx, kv_cache.cross_v, head_dim, T_enc_max, n_heads, B, v_elem * hidden,
+                                       v_elem * head_dim, v_elem * hidden * T_enc_max, off_v);
 
     ggml_tensor * o = ggml_flash_attn_ext(ctx, Q_att, K, V, cross_mask, scale, 0.0f, 0.0f);
-    o = ggml_reshape_2d(ctx, o, hidden, B);
+    o               = ggml_reshape_2d(ctx, o, hidden, B);
 
     o = ggml_mul_mat(ctx, out_w, o);
-    if (out_b != nullptr) o = ggml_add(ctx, o, out_b);
+    if (out_b != nullptr) {
+        o = ggml_add(ctx, o, out_b);
+    }
     return o;
 }
 
-} // namespace
+}  // namespace
 
-DecoderBuild build_cross_kv_graph_batched(ggml_context *         ctx,
-                                          const CanaryWeights &  w,
-                                          const CanaryHParams &  hp,
-                                          CanaryKvCache &        kv_cache,
-                                          int                    T_enc_max,
-                                          int                    n_batch)
-{
-    DecoderBuild db {};
-    if (ctx == nullptr || T_enc_max <= 0 || n_batch <= 0) return db;
+DecoderBuild build_cross_kv_graph_batched(ggml_context *        ctx,
+                                          const CanaryWeights & w,
+                                          const CanaryHParams & hp,
+                                          CanaryKvCache &       kv_cache,
+                                          int                   T_enc_max,
+                                          int                   n_batch) {
+    DecoderBuild db{};
+    if (ctx == nullptr || T_enc_max <= 0 || n_batch <= 0) {
+        return db;
+    }
 
     const int64_t hidden = hp.dec_d_model;
     const int     B      = n_batch;
@@ -754,7 +764,9 @@ DecoderBuild build_cross_kv_graph_batched(ggml_context *         ctx,
     ggml_set_input(db.encoder_out_in);
 
     db.graph = ggml_new_graph_custom(ctx, 8192, false);
-    if (db.graph == nullptr) return db;
+    if (db.graph == nullptr) {
+        return db;
+    }
 
     const size_t k_elem = ggml_element_size(kv_cache.cross_k);
     const size_t v_elem = ggml_element_size(kv_cache.cross_v);
@@ -763,16 +775,20 @@ DecoderBuild build_cross_kv_graph_batched(ggml_context *         ctx,
         const auto & blk = w.dec_blocks[il];
 
         ggml_tensor * Kc = ggml_mul_mat(ctx, blk.cross_k_w, db.encoder_out_in);
-        if (blk.cross_k_b != nullptr) Kc = ggml_add(ctx, Kc, blk.cross_k_b);
+        if (blk.cross_k_b != nullptr) {
+            Kc = ggml_add(ctx, Kc, blk.cross_k_b);
+        }
         ggml_tensor * Vc = ggml_mul_mat(ctx, blk.cross_v_w, db.encoder_out_in);
-        if (blk.cross_v_b != nullptr) Vc = ggml_add(ctx, Vc, blk.cross_v_b);
-
-        const size_t off_k = k_elem * static_cast<size_t>(il) * T_enc_max * hidden * B;
-        const size_t off_v = v_elem * static_cast<size_t>(il) * T_enc_max * hidden * B;
-        ggml_tensor * k_dst = ggml_view_3d(ctx, kv_cache.cross_k,
-            hidden, T_enc_max, B, k_elem * hidden, k_elem * hidden * T_enc_max, off_k);
-        ggml_tensor * v_dst = ggml_view_3d(ctx, kv_cache.cross_v,
-            hidden, T_enc_max, B, v_elem * hidden, v_elem * hidden * T_enc_max, off_v);
+        if (blk.cross_v_b != nullptr) {
+            Vc = ggml_add(ctx, Vc, blk.cross_v_b);
+        }
+
+        const size_t  off_k = k_elem * static_cast<size_t>(il) * T_enc_max * hidden * B;
+        const size_t  off_v = v_elem * static_cast<size_t>(il) * T_enc_max * hidden * B;
+        ggml_tensor * k_dst = ggml_view_3d(ctx, kv_cache.cross_k, hidden, T_enc_max, B, k_elem * hidden,
+                                           k_elem * hidden * T_enc_max, off_k);
+        ggml_tensor * v_dst = ggml_view_3d(ctx, kv_cache.cross_v, hidden, T_enc_max, B, v_elem * hidden,
+                                           v_elem * hidden * T_enc_max, off_v);
         ggml_build_forward_expand(db.graph, ggml_cpy(ctx, Kc, k_dst));
         ggml_build_forward_expand(db.graph, ggml_cpy(ctx, Vc, v_dst));
     }
@@ -786,12 +802,13 @@ StepBuildBatched build_step_graph_batched(ggml_context *        ctx,
                                           int                   max_n_kv,
                                           int                   T_enc_max,
                                           int                   n_batch,
-                                          bool                  use_flash)
-{
-    StepBuildBatched sb {};
+                                          bool                  use_flash) {
+    StepBuildBatched sb{};
     sb.max_n_kv = max_n_kv;
     sb.n_batch  = n_batch;
-    if (ctx == nullptr || max_n_kv <= 0 || T_enc_max <= 0 || n_batch <= 0) return sb;
+    if (ctx == nullptr || max_n_kv <= 0 || T_enc_max <= 0 || n_batch <= 0) {
+        return sb;
+    }
     if (!use_flash) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "canary step(batched): requires flash path");
         return sb;
@@ -802,57 +819,68 @@ StepBuildBatched build_step_graph_batched(ggml_context *        ctx,
     const int     B       = n_batch;
 
     sb.token_ids_in = ggml_new_tensor_1d(ctx, GGML_TYPE_I32, B);
-    ggml_set_name(sb.token_ids_in, "step.token_ids"); ggml_set_input(sb.token_ids_in);
+    ggml_set_name(sb.token_ids_in, "step.token_ids");
+    ggml_set_input(sb.token_ids_in);
     sb.pos_ids_in = ggml_new_tensor_1d(ctx, GGML_TYPE_I32, B);
-    ggml_set_name(sb.pos_ids_in, "step.pos_ids"); ggml_set_input(sb.pos_ids_in);
+    ggml_set_name(sb.pos_ids_in, "step.pos_ids");
+    ggml_set_input(sb.pos_ids_in);
     sb.kv_idx_in = ggml_new_tensor_2d(ctx, GGML_TYPE_I64, 1, B);
-    ggml_set_name(sb.kv_idx_in, "step.kv_idx"); ggml_set_input(sb.kv_idx_in);
+    ggml_set_name(sb.kv_idx_in, "step.kv_idx");
+    ggml_set_input(sb.kv_idx_in);
     sb.self_mask_in = ggml_new_tensor_4d(ctx, GGML_TYPE_F16, max_n_kv, 1, 1, B);
-    ggml_set_name(sb.self_mask_in, "step.self_mask"); ggml_set_input(sb.self_mask_in);
+    ggml_set_name(sb.self_mask_in, "step.self_mask");
+    ggml_set_input(sb.self_mask_in);
     sb.cross_mask_in = ggml_new_tensor_4d(ctx, GGML_TYPE_F16, T_enc_max, 1, 1, B);
-    ggml_set_name(sb.cross_mask_in, "step.cross_mask"); ggml_set_input(sb.cross_mask_in);
+    ggml_set_name(sb.cross_mask_in, "step.cross_mask");
+    ggml_set_input(sb.cross_mask_in);
 
     sb.graph = ggml_new_graph_custom(ctx, 16384, false);
-    if (sb.graph == nullptr) return sb;
+    if (sb.graph == nullptr) {
+        return sb;
+    }
 
     ggml_tensor * tok_emb = ggml_get_rows(ctx, w.dec_embed.token_w, sb.token_ids_in);
     ggml_tensor * pos_emb = ggml_get_rows(ctx, w.dec_embed.pos_enc, sb.pos_ids_in);
-    ggml_tensor * x = ggml_add(ctx, tok_emb, pos_emb);
-    x = layer_norm(ctx, x, w.dec_embed.norm_w, w.dec_embed.norm_b);
+    ggml_tensor * x       = ggml_add(ctx, tok_emb, pos_emb);
+    x                     = layer_norm(ctx, x, w.dec_embed.norm_w, w.dec_embed.norm_b);
 
     for (int i = 0; i < hp.dec_n_layers; ++i) {
         const auto & blk = w.dec_blocks[i];
         {
             ggml_tensor * xn = layer_norm(ctx, x, blk.norm1_w, blk.norm1_b);
-            ggml_tensor * so = mha_self_step_batched(
-                ctx, sb.graph, xn, kv_cache, sb.self_mask_in, sb.kv_idx_in,
-                blk.self_q_w, blk.self_q_b, blk.self_k_w, blk.self_k_b,
-                blk.self_v_w, blk.self_v_b, blk.self_o_w, blk.self_o_b,
-                n_heads, static_cast<int>(hidden), i, max_n_kv, B);
+            ggml_tensor * so =
+                mha_self_step_batched(ctx, sb.graph, xn, kv_cache, sb.self_mask_in, sb.kv_idx_in, blk.self_q_w,
+                                      blk.self_q_b, blk.self_k_w, blk.self_k_b, blk.self_v_w, blk.self_v_b,
+                                      blk.self_o_w, blk.self_o_b, n_heads, static_cast<int>(hidden), i, max_n_kv, B);
             x = ggml_add(ctx, x, so);
         }
         {
             ggml_tensor * xn = layer_norm(ctx, x, blk.norm2_w, blk.norm2_b);
-            ggml_tensor * co = mha_cross_step_batched(
-                ctx, xn, kv_cache, sb.cross_mask_in,
-                blk.cross_q_w, blk.cross_q_b, blk.cross_o_w, blk.cross_o_b,
-                n_heads, static_cast<int>(hidden), i, T_enc_max, B);
+            ggml_tensor * co =
+                mha_cross_step_batched(ctx, xn, kv_cache, sb.cross_mask_in, blk.cross_q_w, blk.cross_q_b, blk.cross_o_w,
+                                       blk.cross_o_b, n_heads, static_cast<int>(hidden), i, T_enc_max, B);
             x = ggml_add(ctx, x, co);
         }
         {
             ggml_tensor * xn = layer_norm(ctx, x, blk.norm3_w, blk.norm3_b);
             ggml_tensor * ff = ggml_mul_mat(ctx, blk.ffn_up_w, xn);
-            if (blk.ffn_up_b != nullptr) ff = ggml_add(ctx, ff, blk.ffn_up_b);
+            if (blk.ffn_up_b != nullptr) {
+                ff = ggml_add(ctx, ff, blk.ffn_up_b);
+            }
             ff = (hp.dec_activation == "relu") ? ggml_relu(ctx, ff) : ggml_silu(ctx, ff);
             ff = ggml_mul_mat(ctx, blk.ffn_down_w, ff);
-            if (blk.ffn_down_b != nullptr) ff = ggml_add(ctx, ff, blk.ffn_down_b);
+            if (blk.ffn_down_b != nullptr) {
+                ff = ggml_add(ctx, ff, blk.ffn_down_b);
+            }
             x = ggml_add(ctx, x, ff);
         }
     }
 
-    x = layer_norm(ctx, x, w.dec_final.norm_w, w.dec_final.norm_b);
+    x                    = layer_norm(ctx, x, w.dec_final.norm_w, w.dec_final.norm_b);
     ggml_tensor * logits = ggml_mul_mat(ctx, w.head.weight, x);
-    if (w.head.bias != nullptr) logits = ggml_add(ctx, logits, w.head.bias);
+    if (w.head.bias != nullptr) {
+        logits = ggml_add(ctx, logits, w.head.bias);
+    }
 
     sb.argmax_out = ggml_argmax(ctx, logits);  // [B]
     ggml_set_name(sb.argmax_out, "step.argmax");
@@ -861,4 +889,4 @@ StepBuildBatched build_step_graph_batched(ggml_context *        ctx,
     return sb;
 }
 
-} // namespace transcribe::canary
+}  // namespace transcribe::canary
diff --git a/src/arch/canary/decoder.h b/src/arch/canary/decoder.h
index 52880b68..b0ff3539 100644
--- a/src/arch/canary/decoder.h
+++ b/src/arch/canary/decoder.h
@@ -25,9 +25,9 @@ struct DecoderDumps {
     // For canary's per-sublayer dumps: indexed by layer, three slots each.
     // Slot 0 = post self_attn residual, slot 1 = post cross_attn residual,
     // slot 2 = post ffn residual (i.e. block out).
-    ggml_tensor * sub_self [64] = {};
-    ggml_tensor * sub_cross[64] = {};
-    ggml_tensor * sub_ffn  [64] = {};
+    ggml_tensor * sub_self[64]    = {};
+    ggml_tensor * sub_cross[64]   = {};
+    ggml_tensor * sub_ffn[64]     = {};
     ggml_tensor * out_before_head = nullptr;
     ggml_tensor * logits_raw      = nullptr;  // pre-softmax
     ggml_tensor * logits          = nullptr;  // post-softmax (when log_softmax fires)
@@ -41,18 +41,18 @@ struct DecoderBuild {
     ggml_tensor * out        = nullptr;  // logits [vocab, seq]
     ggml_tensor * argmax_out = nullptr;  // [seq] i32 when skip_log_softmax
 
-    DecoderDumps  dumps {};
+    DecoderDumps  dumps{};
     ggml_cgraph * graph = nullptr;
 };
 
 // Build a graph that computes cross-attention K/V for all decoder
 // layers from the encoder output, writing them into the cross-attn
 // KV cache.
-DecoderBuild build_cross_kv_graph(ggml_context *         ctx,
-                                  const CanaryWeights &  w,
-                                  const CanaryHParams &  hp,
-                                  CanaryKvCache &        kv_cache,
-                                  int                    T_enc);
+DecoderBuild build_cross_kv_graph(ggml_context *        ctx,
+                                  const CanaryWeights & w,
+                                  const CanaryHParams & hp,
+                                  CanaryKvCache &       kv_cache,
+                                  int                   T_enc);
 
 // Build a decoder graph that uses the KV cache. Works for both prompt
 // pass (n_tokens > 1, n_past == 0) and step pass (n_tokens == 1).
@@ -60,15 +60,15 @@ DecoderBuild build_cross_kv_graph(ggml_context *         ctx,
 // skip_log_softmax: when true, skip the log-softmax tail and add a GPU
 // argmax over the last new-token position (saves a vocab-wide softmax
 // per step). The pre-softmax logits remain available via dumps.logits_raw.
-DecoderBuild build_decoder_graph_kv(ggml_context *         ctx,
-                                    const CanaryWeights &  w,
-                                    const CanaryHParams &  hp,
-                                    CanaryKvCache &        kv_cache,
-                                    int                    n_tokens,
-                                    int                    n_past,
-                                    int                    T_enc,
-                                    bool                   skip_log_softmax = false,
-                                    bool                   use_flash        = true);
+DecoderBuild build_decoder_graph_kv(ggml_context *        ctx,
+                                    const CanaryWeights & w,
+                                    const CanaryHParams & hp,
+                                    CanaryKvCache &       kv_cache,
+                                    int                   n_tokens,
+                                    int                   n_past,
+                                    int                   T_enc,
+                                    bool                  skip_log_softmax = false,
+                                    bool                  use_flash        = true);
 
 // Static-topology single-token decoder graph. Built once per utterance
 // after the prompt pass and reused for every step in the autoregressive
@@ -107,12 +107,12 @@ StepBuild build_step_graph(ggml_context *        ctx,
 // (each utterance right-padded); per-layer K/V written to the batched cross
 // cache slab (layer, b). Padded frames produce bias-only K/V discarded by
 // the cross-pad mask at attention time.
-DecoderBuild build_cross_kv_graph_batched(ggml_context *         ctx,
-                                          const CanaryWeights &  w,
-                                          const CanaryHParams &  hp,
-                                          CanaryKvCache &        kv_cache,
-                                          int                    T_enc_max,
-                                          int                    n_batch);
+DecoderBuild build_cross_kv_graph_batched(ggml_context *        ctx,
+                                          const CanaryWeights & w,
+                                          const CanaryHParams & hp,
+                                          CanaryKvCache &       kv_cache,
+                                          int                   T_enc_max,
+                                          int                   n_batch);
 
 // Static-topology batched single-step graph for B utterances, reused for
 // the prompt feed and generation. Self-attn writes self-KV at kv_idx[b] and
@@ -139,4 +139,4 @@ StepBuildBatched build_step_graph_batched(ggml_context *        ctx,
                                           int                   n_batch,
                                           bool                  use_flash = true);
 
-} // namespace transcribe::canary
+}  // namespace transcribe::canary
diff --git a/src/arch/canary/encoder.cpp b/src/arch/canary/encoder.cpp
index 9385b00b..744c7194 100644
--- a/src/arch/canary/encoder.cpp
+++ b/src/arch/canary/encoder.cpp
@@ -5,13 +5,11 @@
 
 #include "encoder.h"
 
-#include "weights.h"
-
 #include "conformer/conformer.h"
+#include "ggml.h"
 #include "transcribe-debug.h"
 #include "transcribe-log.h"
-
-#include "ggml.h"
+#include "weights.h"
 
 #include <cstdio>
 #include <cstdlib>
@@ -26,19 +24,24 @@ namespace conf = transcribe::conformer;
 // Direct dw on every backend for the in-block site; im2col for pre-encode
 // (canary's encoder geometry matches parakeet's at the dw site).
 bool detect_direct_dw_in_block(const char * /*backend*/) {
-    return conf::resolve_conv_direct("TRANSCRIBE_CONV_DIRECT_DW",
-                                     "TRANSCRIBE_CONV_NO_DIRECT_DW",
+    return conf::resolve_conv_direct("TRANSCRIBE_CONV_DIRECT_DW", "TRANSCRIBE_CONV_NO_DIRECT_DW",
                                      /*backend_default=*/true);
 }
 
 conf::PreEncodeView to_view(const CanaryPreEncode & pe) {
     conf::PreEncodeView v;
-    v.conv0_w = pe.conv0_w; v.conv0_b = pe.conv0_b;
-    v.conv2_w = pe.conv2_w; v.conv2_b = pe.conv2_b;
-    v.conv3_w = pe.conv3_w; v.conv3_b = pe.conv3_b;
-    v.conv5_w = pe.conv5_w; v.conv5_b = pe.conv5_b;
-    v.conv6_w = pe.conv6_w; v.conv6_b = pe.conv6_b;
-    v.out_w   = pe.out_w;   v.out_b   = pe.out_b;
+    v.conv0_w = pe.conv0_w;
+    v.conv0_b = pe.conv0_b;
+    v.conv2_w = pe.conv2_w;
+    v.conv2_b = pe.conv2_b;
+    v.conv3_w = pe.conv3_w;
+    v.conv3_b = pe.conv3_b;
+    v.conv5_w = pe.conv5_w;
+    v.conv5_b = pe.conv5_b;
+    v.conv6_w = pe.conv6_w;
+    v.conv6_b = pe.conv6_b;
+    v.out_w   = pe.out_w;
+    v.out_b   = pe.out_b;
     return v;
 }
 
@@ -47,84 +50,95 @@ conf::BlockView to_view(const CanaryBlock & b) {
 
     v.norm_ff1_w = b.norm_ff1_w;
     v.norm_ff1_b = b.norm_ff1_b;
-    v.ff1_lin1_w = b.ff1_lin1_w; v.ff1_lin1_b = b.ff1_lin1_b;
-    v.ff1_lin2_w = b.ff1_lin2_w; v.ff1_lin2_b = b.ff1_lin2_b;
+    v.ff1_lin1_w = b.ff1_lin1_w;
+    v.ff1_lin1_b = b.ff1_lin1_b;
+    v.ff1_lin2_w = b.ff1_lin2_w;
+    v.ff1_lin2_b = b.ff1_lin2_b;
 
     v.norm_attn_w = b.norm_attn_w;
     v.norm_attn_b = b.norm_attn_b;
-    v.attn_q_w    = b.attn_q_w;   v.attn_q_b   = b.attn_q_b;
-    v.attn_k_w    = b.attn_k_w;   v.attn_k_b   = b.attn_k_b;
-    v.attn_v_w    = b.attn_v_w;   v.attn_v_b   = b.attn_v_b;
-    v.attn_out_w  = b.attn_out_w; v.attn_out_b = b.attn_out_b;
+    v.attn_q_w    = b.attn_q_w;
+    v.attn_q_b    = b.attn_q_b;
+    v.attn_k_w    = b.attn_k_w;
+    v.attn_k_b    = b.attn_k_b;
+    v.attn_v_w    = b.attn_v_w;
+    v.attn_v_b    = b.attn_v_b;
+    v.attn_out_w  = b.attn_out_w;
+    v.attn_out_b  = b.attn_out_b;
     v.attn_pos_w  = b.attn_pos_w;
     v.attn_pos_u  = b.attn_pos_u;
     v.attn_pos_v  = b.attn_pos_v;
 
     v.norm_conv_w         = b.norm_conv_w;
     v.norm_conv_b         = b.norm_conv_b;
-    v.conv_pw1_w          = b.conv_pw1_w; v.conv_pw1_b = b.conv_pw1_b;
-    v.conv_dw_w           = b.conv_dw_w;  v.conv_dw_b  = b.conv_dw_b;
-    v.conv_pw2_w          = b.conv_pw2_w; v.conv_pw2_b = b.conv_pw2_b;
+    v.conv_pw1_w          = b.conv_pw1_w;
+    v.conv_pw1_b          = b.conv_pw1_b;
+    v.conv_dw_w           = b.conv_dw_w;
+    v.conv_dw_b           = b.conv_dw_b;
+    v.conv_pw2_w          = b.conv_pw2_w;
+    v.conv_pw2_b          = b.conv_pw2_b;
     v.conv_bn_fused_scale = b.conv_bn_fused_scale;
     v.conv_bn_fused_bias  = b.conv_bn_fused_bias;
 
     v.norm_ff2_w = b.norm_ff2_w;
     v.norm_ff2_b = b.norm_ff2_b;
-    v.ff2_lin1_w = b.ff2_lin1_w; v.ff2_lin1_b = b.ff2_lin1_b;
-    v.ff2_lin2_w = b.ff2_lin2_w; v.ff2_lin2_b = b.ff2_lin2_b;
+    v.ff2_lin1_w = b.ff2_lin1_w;
+    v.ff2_lin1_b = b.ff2_lin1_b;
+    v.ff2_lin2_w = b.ff2_lin2_w;
+    v.ff2_lin2_b = b.ff2_lin2_b;
 
     v.norm_out_w = b.norm_out_w;
     v.norm_out_b = b.norm_out_b;
     return v;
 }
 
-} // namespace
-
-EncoderBuild build_encoder_graph(ggml_context *         ctx,
-                                 const CanaryWeights &  w,
-                                 const CanaryHParams &  hp,
-                                 int                    n_mel_frames,
-                                 ggml_type              kv_type,
-                                 bool                   use_flash,
-                                 const char *           backend_name)
-{
-    conf::ConvPolicy policy {};
+}  // namespace
+
+EncoderBuild build_encoder_graph(ggml_context *        ctx,
+                                 const CanaryWeights & w,
+                                 const CanaryHParams & hp,
+                                 int                   n_mel_frames,
+                                 ggml_type             kv_type,
+                                 bool                  use_flash,
+                                 const char *          backend_name) {
+    conf::ConvPolicy policy{};
     policy.direct_pw               = conf::detect_direct_pw(backend_name);
     const bool direct_dw           = detect_direct_dw_in_block(backend_name);
     policy.direct_dw_in_block      = direct_dw;
     policy.direct_dw_in_pre_encode = false;  // parakeet-style: im2col here
 
-    EncoderBuild eb {};
+    EncoderBuild eb{};
 
     if (ctx == nullptr || n_mel_frames <= 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "canary encoder: invalid arg (ctx=%p, n_mel_frames=%d)",
-                     static_cast<void *>(ctx), n_mel_frames);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "canary encoder: invalid arg (ctx=%p, n_mel_frames=%d)",
+                static_cast<void *>(ctx), n_mel_frames);
         return eb;
     }
 
     if (hp.enc_subsampling_factor != 8 || hp.fe_num_mels != 128) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "canary encoder: unsupported geometry "
-                     "subsampling_factor=%d num_mels=%d (only 8/128 implemented)",
-                     hp.enc_subsampling_factor, hp.fe_num_mels);
+                "canary encoder: unsupported geometry "
+                "subsampling_factor=%d num_mels=%d (only 8/128 implemented)",
+                hp.enc_subsampling_factor, hp.fe_num_mels);
         return eb;
     }
 
     // Mel input.
-    eb.mel_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32,
-                                   n_mel_frames, hp.fe_num_mels);
-    if (eb.mel_in == nullptr) return eb;
+    eb.mel_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, n_mel_frames, hp.fe_num_mels);
+    if (eb.mel_in == nullptr) {
+        return eb;
+    }
     ggml_set_name(eb.mel_in, "mel.in");
     ggml_set_input(eb.mel_in);
     eb.dumps.mel_in = eb.mel_in;
 
     // Pre-encode.
-    ggml_tensor * x = conf::build_pre_encode(ctx, to_view(w.pre_encode),
-                                             eb.mel_in, policy,
+    ggml_tensor * x = conf::build_pre_encode(ctx, to_view(w.pre_encode), eb.mel_in, policy,
                                              /*name_prefix=*/"enc.pre_encode",
                                              /*error_tag=*/"canary");
-    if (x == nullptr) return eb;
+    if (x == nullptr) {
+        return eb;
+    }
     eb.dumps.pre_encode_out = x;
     transcribe::debug::mark_tensor_for_dump(x);
 
@@ -133,13 +147,12 @@ EncoderBuild build_encoder_graph(ggml_context *         ctx,
         const int64_t T_enc = x->ne[1];
 
         const int64_t pos_len = 2 * T_enc - 1;
-        eb.pos_emb_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32,
-                                           hp.enc_d_model, pos_len);
+        eb.pos_emb_in         = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, hp.enc_d_model, pos_len);
         ggml_set_name(eb.pos_emb_in, "pos_emb.in");
         ggml_set_input(eb.pos_emb_in);
         eb.dumps.pos_emb = eb.pos_emb_in;
 
-        conf::BlockParams bparams {};
+        conf::BlockParams bparams{};
         bparams.d_model     = hp.enc_d_model;
         bparams.n_head      = hp.enc_n_heads;
         bparams.conv_kernel = hp.enc_conv_kernel;
@@ -149,9 +162,8 @@ EncoderBuild build_encoder_graph(ggml_context *         ctx,
 
         // Block 0.
         {
-            x = conf::build_conformer_block(ctx, x, eb.pos_emb_in,
-                                            to_view(w.blocks[0]), bparams);
-            x = conf::named(x, "enc.block.0.out");
+            x                   = conf::build_conformer_block(ctx, x, eb.pos_emb_in, to_view(w.blocks[0]), bparams);
+            x                   = conf::named(x, "enc.block.0.out");
             eb.dumps.block0_out = x;
             transcribe::debug::mark_tensor_for_dump(x);
         }
@@ -161,19 +173,18 @@ EncoderBuild build_encoder_graph(ggml_context *         ctx,
 
         // Blocks 1..N-1.
         for (size_t i = 1; i < w.blocks.size(); ++i) {
-            x = conf::build_conformer_block(ctx, x, eb.pos_emb_in,
-                                            to_view(w.blocks[i]), bparams);
+            x = conf::build_conformer_block(ctx, x, eb.pos_emb_in, to_view(w.blocks[i]), bparams);
             if (i == static_cast<size_t>(mid_idx)) {
                 char bname[64];
                 std::snprintf(bname, sizeof(bname), "enc.block.%zu.out", i);
-                x = conf::named(x, bname);
+                x                      = conf::named(x, bname);
                 eb.dumps.block_mid_out = x;
                 transcribe::debug::mark_tensor_for_dump(x);
             }
             if (i == w.blocks.size() - 1) {
                 char bname[64];
                 std::snprintf(bname, sizeof(bname), "enc.block.%zu.out", i);
-                x = conf::named(x, bname);
+                x                       = conf::named(x, bname);
                 eb.dumps.block_last_out = x;
                 transcribe::debug::mark_tensor_for_dump(x);
             }
@@ -197,7 +208,7 @@ EncoderBuild build_encoder_graph(ggml_context *         ctx,
     }
 
     eb.dumps.final_out = x;
-    x = conf::named(x, "enc.final");
+    x                  = conf::named(x, "enc.final");
     transcribe::debug::mark_tensor_for_dump(x);
 
     eb.out = x;
@@ -213,4 +224,4 @@ EncoderBuild build_encoder_graph(ggml_context *         ctx,
     return eb;
 }
 
-} // namespace transcribe::canary
+}  // namespace transcribe::canary
diff --git a/src/arch/canary/encoder.h b/src/arch/canary/encoder.h
index a72834d2..c19e8cd9 100644
--- a/src/arch/canary/encoder.h
+++ b/src/arch/canary/encoder.h
@@ -17,30 +17,30 @@ struct CanaryHParams;
 struct CanaryWeights;
 
 struct EncoderDumps {
-    ggml_tensor * mel_in           = nullptr;
-    ggml_tensor * pre_encode_out   = nullptr;
-    ggml_tensor * pos_emb          = nullptr;
-    ggml_tensor * block0_out       = nullptr;
-    ggml_tensor * block_mid_out    = nullptr;  // block n_layers/2
-    ggml_tensor * block_last_out   = nullptr;  // block n_layers-1
-    ggml_tensor * native_out       = nullptr;  // pre-projection (dump as enc.native)
-    ggml_tensor * final_out        = nullptr;  // post-projection (dump as enc.final)
+    ggml_tensor * mel_in         = nullptr;
+    ggml_tensor * pre_encode_out = nullptr;
+    ggml_tensor * pos_emb        = nullptr;
+    ggml_tensor * block0_out     = nullptr;
+    ggml_tensor * block_mid_out  = nullptr;  // block n_layers/2
+    ggml_tensor * block_last_out = nullptr;  // block n_layers-1
+    ggml_tensor * native_out     = nullptr;  // pre-projection (dump as enc.native)
+    ggml_tensor * final_out      = nullptr;  // post-projection (dump as enc.final)
 };
 
 struct EncoderBuild {
     ggml_tensor * mel_in     = nullptr;
     ggml_tensor * pos_emb_in = nullptr;
     ggml_tensor * out        = nullptr;  // post-projection if proj exists, else native
-    EncoderDumps  dumps {};
-    ggml_cgraph * graph      = nullptr;
+    EncoderDumps  dumps{};
+    ggml_cgraph * graph = nullptr;
 };
 
-EncoderBuild build_encoder_graph(ggml_context *         compute_ctx,
-                                 const CanaryWeights &  weights,
-                                 const CanaryHParams &  hp,
-                                 int                    n_mel_frames,
-                                 ggml_type              kv_type      = GGML_TYPE_COUNT,
-                                 bool                   use_flash    = true,
-                                 const char *           backend_name = "");
+EncoderBuild build_encoder_graph(ggml_context *        compute_ctx,
+                                 const CanaryWeights & weights,
+                                 const CanaryHParams & hp,
+                                 int                   n_mel_frames,
+                                 ggml_type             kv_type      = GGML_TYPE_COUNT,
+                                 bool                  use_flash    = true,
+                                 const char *          backend_name = "");
 
-} // namespace transcribe::canary
+}  // namespace transcribe::canary
diff --git a/src/arch/canary/model.cpp b/src/arch/canary/model.cpp
index f1848605..072c3373 100644
--- a/src/arch/canary/model.cpp
+++ b/src/arch/canary/model.cpp
@@ -5,11 +5,12 @@
 // Transformer decoder, driven by a 4/5-slot multitask prompt.
 
 #include "canary.h"
-
 #include "decoder.h"
 #include "encoder.h"
-#include "weights.h"
-
+#include "ggml-alloc.h"
+#include "ggml-backend.h"
+#include "ggml.h"
+#include "gguf.h"
 #include "transcribe-arch.h"
 #include "transcribe-batch-util.h"
 #include "transcribe-debug.h"
@@ -20,11 +21,7 @@
 #include "transcribe-log.h"
 #include "transcribe-mel.h"
 #include "transcribe-meta.h"
-
-#include "ggml.h"
-#include "ggml-alloc.h"
-#include "ggml-backend.h"
-#include "gguf.h"
+#include "weights.h"
 
 #include <algorithm>
 #include <cmath>
@@ -43,7 +40,7 @@ namespace transcribe::canary {
 
 extern const Arch arch;
 
-static_assert(std::is_base_of_v<transcribe_model,   CanaryModel>);
+static_assert(std::is_base_of_v<transcribe_model, CanaryModel>);
 static_assert(std::is_base_of_v<transcribe_session, CanarySession>);
 
 CanarySession::~CanarySession() {
@@ -65,17 +62,15 @@ bool kv_cache_init(CanaryKvCache & cache,
                    int             T_enc,
                    int             n_state,
                    int             n_layer,
-                   ggml_type       kv_type)
-{
+                   ggml_type       kv_type) {
     if (kv_type != GGML_TYPE_F16 && kv_type != GGML_TYPE_F32) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "canary kv_cache: unsupported kv_type=%d",
-                     static_cast<int>(kv_type));
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "canary kv_cache: unsupported kv_type=%d", static_cast<int>(kv_type));
         return false;
     }
 
     const size_t ctx_size = 4 * ggml_tensor_overhead() + 256;
 
-    ggml_init_params params {};
+    ggml_init_params params{};
     params.mem_size   = ctx_size;
     params.mem_buffer = nullptr;
     params.no_alloc   = true;
@@ -94,8 +89,8 @@ bool kv_cache_init(CanaryKvCache & cache,
     cache.cross_k = ggml_new_tensor_1d(cache.ctx, kv_type, cross_elements);
     cache.cross_v = ggml_new_tensor_1d(cache.ctx, kv_type, cross_elements);
 
-    ggml_set_name(cache.self_k,  "kv_self_k");
-    ggml_set_name(cache.self_v,  "kv_self_v");
+    ggml_set_name(cache.self_k, "kv_self_k");
+    ggml_set_name(cache.self_v, "kv_self_v");
     ggml_set_name(cache.cross_k, "kv_cross_k");
     ggml_set_name(cache.cross_v, "kv_cross_v");
 
@@ -116,14 +111,12 @@ bool kv_cache_init(CanaryKvCache & cache,
     cache.cross_populated = false;
 
     const size_t total_bytes =
-        ggml_nbytes(cache.self_k) + ggml_nbytes(cache.self_v) +
-        ggml_nbytes(cache.cross_k) + ggml_nbytes(cache.cross_v);
+        ggml_nbytes(cache.self_k) + ggml_nbytes(cache.self_v) + ggml_nbytes(cache.cross_k) + ggml_nbytes(cache.cross_v);
     log_msg(TRANSCRIBE_LOG_LEVEL_INFO,
-                 "canary kv_cache: allocated %.1f MB (%s) "
-                 "(self: %d session x %d layers, cross: %d T_enc x %d layers)",
-                 static_cast<double>(total_bytes) / (1024.0 * 1024.0),
-                 ggml_type_name(kv_type),
-                 n_ctx, n_layer, T_enc, n_layer);
+            "canary kv_cache: allocated %.1f MB (%s) "
+            "(self: %d session x %d layers, cross: %d T_enc x %d layers)",
+            static_cast<double>(total_bytes) / (1024.0 * 1024.0), ggml_type_name(kv_type), n_ctx, n_layer, T_enc,
+            n_layer);
 
     return true;
 }
@@ -135,11 +128,11 @@ bool kv_cache_init_batched(CanaryKvCache & cache,
                            int             n_state,
                            int             n_layer,
                            int             n_batch,
-                           ggml_type       kv_type)
-{
+                           ggml_type       kv_type) {
     if (n_batch <= 1) {
-        if (!kv_cache_init(cache, backend, n_ctx, T_enc, n_state, n_layer, kv_type))
+        if (!kv_cache_init(cache, backend, n_ctx, T_enc, n_state, n_layer, kv_type)) {
             return false;
+        }
         cache.n_batch = 1;
         return true;
     }
@@ -147,32 +140,40 @@ bool kv_cache_init_batched(CanaryKvCache & cache,
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "canary kv_cache(batched): unsupported kv_type");
         return false;
     }
-    const size_t ctx_size = 4 * ggml_tensor_overhead() + 256;
-    ggml_init_params params {};
-    params.mem_size = ctx_size; params.mem_buffer = nullptr; params.no_alloc = true;
-    cache.ctx = ggml_init(params);
-    if (cache.ctx == nullptr) return false;
+    const size_t     ctx_size = 4 * ggml_tensor_overhead() + 256;
+    ggml_init_params params{};
+    params.mem_size   = ctx_size;
+    params.mem_buffer = nullptr;
+    params.no_alloc   = true;
+    cache.ctx         = ggml_init(params);
+    if (cache.ctx == nullptr) {
+        return false;
+    }
 
-    const int64_t self_elements =
-        static_cast<int64_t>(n_state) * n_layer * n_ctx * n_batch;
-    const int64_t cross_elements =
-        static_cast<int64_t>(n_state) * n_layer * T_enc * n_batch;
-    cache.self_k  = ggml_new_tensor_1d(cache.ctx, kv_type, self_elements);
-    cache.self_v  = ggml_new_tensor_1d(cache.ctx, kv_type, self_elements);
-    cache.cross_k = ggml_new_tensor_1d(cache.ctx, kv_type, cross_elements);
-    cache.cross_v = ggml_new_tensor_1d(cache.ctx, kv_type, cross_elements);
-    ggml_set_name(cache.self_k,  "kv_self_k");
-    ggml_set_name(cache.self_v,  "kv_self_v");
+    const int64_t self_elements  = static_cast<int64_t>(n_state) * n_layer * n_ctx * n_batch;
+    const int64_t cross_elements = static_cast<int64_t>(n_state) * n_layer * T_enc * n_batch;
+    cache.self_k                 = ggml_new_tensor_1d(cache.ctx, kv_type, self_elements);
+    cache.self_v                 = ggml_new_tensor_1d(cache.ctx, kv_type, self_elements);
+    cache.cross_k                = ggml_new_tensor_1d(cache.ctx, kv_type, cross_elements);
+    cache.cross_v                = ggml_new_tensor_1d(cache.ctx, kv_type, cross_elements);
+    ggml_set_name(cache.self_k, "kv_self_k");
+    ggml_set_name(cache.self_v, "kv_self_v");
     ggml_set_name(cache.cross_k, "kv_cross_k");
     ggml_set_name(cache.cross_v, "kv_cross_v");
 
     cache.buffer = ggml_backend_alloc_ctx_tensors(cache.ctx, backend);
     if (cache.buffer == nullptr) {
-        ggml_free(cache.ctx); cache.ctx = nullptr; return false;
+        ggml_free(cache.ctx);
+        cache.ctx = nullptr;
+        return false;
     }
     ggml_backend_buffer_clear(cache.buffer, 0);
-    cache.n_ctx = n_ctx; cache.T_enc = T_enc; cache.n = 0; cache.head = 0;
-    cache.n_batch = n_batch; cache.cross_populated = false;
+    cache.n_ctx           = n_ctx;
+    cache.T_enc           = T_enc;
+    cache.n               = 0;
+    cache.head            = 0;
+    cache.n_batch         = n_batch;
+    cache.cross_populated = false;
     return true;
 }
 
@@ -201,9 +202,7 @@ CanaryModel::~CanaryModel() {
         ggml_backend_buffer_free(backend_buffer);
         backend_buffer = nullptr;
     }
-    for (auto it = plan.scheduler_list.rbegin();
-         it != plan.scheduler_list.rend(); ++it)
-    {
+    for (auto it = plan.scheduler_list.rbegin(); it != plan.scheduler_list.rend(); ++it) {
         ggml_backend_free(*it);
     }
     plan.scheduler_list.clear();
@@ -257,12 +256,11 @@ int canary_predict_t_enc(int mel_n_frames, int subsampling_factor) {
 // at T_enc == enc_pos_emb_max_len. Returns 0 (unknown) if any rate hparam
 // is missing, so a misconfigured model is never advertised with a wrong number.
 int64_t canary_max_audio_ms(const CanaryHParams & hp) {
-    if (hp.enc_pos_emb_max_len <= 0 || hp.enc_subsampling_factor <= 0 ||
-        hp.fe_hop_length <= 0 || hp.fe_sample_rate <= 0) {
+    if (hp.enc_pos_emb_max_len <= 0 || hp.enc_subsampling_factor <= 0 || hp.fe_hop_length <= 0 ||
+        hp.fe_sample_rate <= 0) {
         return 0;
     }
-    const int64_t mel_frames =
-        static_cast<int64_t>(hp.enc_pos_emb_max_len) * hp.enc_subsampling_factor;
+    const int64_t mel_frames = static_cast<int64_t>(hp.enc_pos_emb_max_len) * hp.enc_subsampling_factor;
     return mel_frames * hp.fe_hop_length * 1000 / hp.fe_sample_rate;
 }
 
@@ -280,44 +278,49 @@ int canary_context_ceiling(int32_t n_ctx_knob, const CanaryHParams & hp) {
 // parakeet/cohere — see those files for the math.
 transcribe_status fuse_batch_norm(CanaryModel & m) {
     const size_t n_blocks = m.weights.blocks.size();
-    if (n_blocks == 0) return TRANSCRIBE_OK;
+    if (n_blocks == 0) {
+        return TRANSCRIBE_OK;
+    }
 
-    const int64_t d = m.hparams.enc_d_model;
+    const int64_t d            = m.hparams.enc_d_model;
     const size_t  tensor_bytes = static_cast<size_t>(d) * sizeof(float);
 
-    const size_t ctx_size = n_blocks * 2 * ggml_tensor_overhead() + 256;
-    ggml_init_params params = {ctx_size, nullptr, true};
-    m.bn_fused_ctx = ggml_init(params);
-    if (m.bn_fused_ctx == nullptr) return TRANSCRIBE_ERR_BACKEND;
+    const size_t     ctx_size = n_blocks * 2 * ggml_tensor_overhead() + 256;
+    ggml_init_params params   = { ctx_size, nullptr, true };
+    m.bn_fused_ctx            = ggml_init(params);
+    if (m.bn_fused_ctx == nullptr) {
+        return TRANSCRIBE_ERR_BACKEND;
+    }
 
     for (size_t i = 0; i < n_blocks; ++i) {
-        auto & b = m.weights.blocks[i];
+        auto & b              = m.weights.blocks[i];
         b.conv_bn_fused_scale = ggml_new_tensor_1d(m.bn_fused_ctx, GGML_TYPE_F32, d);
         b.conv_bn_fused_bias  = ggml_new_tensor_1d(m.bn_fused_ctx, GGML_TYPE_F32, d);
     }
 
-    m.bn_fused_buffer = ggml_backend_alloc_ctx_tensors(
-        m.bn_fused_ctx, m.plan.scheduler_list.back());
-    if (m.bn_fused_buffer == nullptr) return TRANSCRIBE_ERR_BACKEND;
+    m.bn_fused_buffer = ggml_backend_alloc_ctx_tensors(m.bn_fused_ctx, m.plan.scheduler_list.back());
+    if (m.bn_fused_buffer == nullptr) {
+        return TRANSCRIBE_ERR_BACKEND;
+    }
 
     std::vector<float> bn_w(d), bn_b(d), rm(d), rv(d);
     std::vector<float> fused_s(d), fused_b(d);
 
     for (size_t i = 0; i < n_blocks; ++i) {
         auto & b = m.weights.blocks[i];
-        ggml_backend_tensor_get(b.conv_bn_w,  bn_w.data(), 0, tensor_bytes);
-        ggml_backend_tensor_get(b.conv_bn_b,  bn_b.data(), 0, tensor_bytes);
-        ggml_backend_tensor_get(b.conv_bn_rm, rm.data(),   0, tensor_bytes);
-        ggml_backend_tensor_get(b.conv_bn_rv, rv.data(),   0, tensor_bytes);
+        ggml_backend_tensor_get(b.conv_bn_w, bn_w.data(), 0, tensor_bytes);
+        ggml_backend_tensor_get(b.conv_bn_b, bn_b.data(), 0, tensor_bytes);
+        ggml_backend_tensor_get(b.conv_bn_rm, rm.data(), 0, tensor_bytes);
+        ggml_backend_tensor_get(b.conv_bn_rv, rv.data(), 0, tensor_bytes);
 
         for (int64_t c = 0; c < d; ++c) {
             const float s = bn_w[c] / std::sqrt(rv[c] + kBnEps);
-            fused_s[c] = s;
-            fused_b[c] = bn_b[c] - rm[c] * s;
+            fused_s[c]    = s;
+            fused_b[c]    = bn_b[c] - rm[c] * s;
         }
 
         ggml_backend_tensor_set(b.conv_bn_fused_scale, fused_s.data(), 0, tensor_bytes);
-        ggml_backend_tensor_set(b.conv_bn_fused_bias,  fused_b.data(), 0, tensor_bytes);
+        ggml_backend_tensor_set(b.conv_bn_fused_bias, fused_b.data(), 0, tensor_bytes);
     }
 
     return TRANSCRIBE_OK;
@@ -330,34 +333,26 @@ transcribe_status promote_conv_pw_to_f32_on_cpu(CanaryModel & m) {
     slots.reserve(m.weights.blocks.size() * 2);
     for (auto & b : m.weights.blocks) {
         if (b.conv_pw1_w != nullptr && b.conv_pw1_w->type == GGML_TYPE_F16) {
-            slots.push_back({&b.conv_pw1_w, b.conv_pw1_w});
+            slots.push_back({ &b.conv_pw1_w, b.conv_pw1_w });
         }
         if (b.conv_pw2_w != nullptr && b.conv_pw2_w->type == GGML_TYPE_F16) {
-            slots.push_back({&b.conv_pw2_w, b.conv_pw2_w});
+            slots.push_back({ &b.conv_pw2_w, b.conv_pw2_w });
         }
     }
-    return load_common::promote_conv_pw_f16_to_f32_on_cpu(
-        m.plan, slots, "canary",
-        &m.conv_pw_f32_ctx, &m.conv_pw_f32_buffer);
+    return load_common::promote_conv_pw_f16_to_f32_on_cpu(m.plan, slots, "canary", &m.conv_pw_f32_ctx,
+                                                          &m.conv_pw_f32_buffer);
 }
 
 constexpr const char k_default_variant[] = "canary";
 
-extern transcribe_status load        (Loader &, const transcribe_model_load_params *,
-                                      transcribe_model **);
-extern transcribe_status init_context(transcribe_model *, const transcribe_session_params *,
-                                      transcribe_session **);
-extern transcribe_status run         (transcribe_session *, const float *, int,
-                                      const transcribe_run_params *);
-
-transcribe_status load(
-    Loader &                          loader,
-    const transcribe_model_load_params *   params,
-    transcribe_model **               out_model)
-{
+extern transcribe_status load(Loader &, const transcribe_model_load_params *, transcribe_model **);
+extern transcribe_status init_context(transcribe_model *, const transcribe_session_params *, transcribe_session **);
+extern transcribe_status run(transcribe_session *, const float *, int, const transcribe_run_params *);
+
+transcribe_status load(Loader & loader, const transcribe_model_load_params * params, transcribe_model ** out_model) {
     const int64_t t_load_start = ggml_time_us();
 
-    auto m = std::make_unique<CanaryModel>();
+    auto m       = std::make_unique<CanaryModel>();
     m->arch      = &arch;
     m->t_load_us = 0;
 
@@ -372,15 +367,11 @@ transcribe_status load(
     m->caps.n_languages = 0;
     m->caps.languages   = nullptr;
 
-    if (const transcribe_status st = read_capability_kv(loader.gguf(), m->caps);
-        st != TRANSCRIBE_OK)
-    {
+    if (const transcribe_status st = read_capability_kv(loader.gguf(), m->caps); st != TRANSCRIBE_OK) {
         return st;
     }
 
-    if (const transcribe_status st = read_languages_kv(loader.gguf(), *m);
-        st != TRANSCRIBE_OK)
-    {
+    if (const transcribe_status st = read_languages_kv(loader.gguf(), *m); st != TRANSCRIBE_OK) {
         return st;
     }
 
@@ -388,9 +379,7 @@ transcribe_status load(
         return st;
     }
 
-    if (const transcribe_status st = read_canary_hparams(loader.gguf(), m->hparams);
-        st != TRANSCRIBE_OK)
-    {
+    if (const transcribe_status st = read_canary_hparams(loader.gguf(), m->hparams); st != TRANSCRIBE_OK) {
         return st;
     }
 
@@ -403,22 +392,20 @@ transcribe_status load(
     // effective_max_audio_ms to the encoder bound regardless of n_ctx; the
     // decoder self-KV (which n_ctx does lower) only bounds transcript length.
     if (m->hparams.dec_max_position > 0) {
-        m->limits.has_context_cap = true;
-        m->limits.audio_from_caps = true;
-        m->limits.model_max_ctx   = m->hparams.dec_max_position;
-        m->limits.gen_reserve     = 512;  // run()'s max-new-tokens cap
+        m->limits.has_context_cap        = true;
+        m->limits.audio_from_caps        = true;
+        m->limits.model_max_ctx          = m->hparams.dec_max_position;
+        m->limits.gen_reserve            = 512;  // run()'s max-new-tokens cap
         // Whisper-style decoder self-KV: dec_d_model per layer, K and V, no GQA.
-        m->limits.kv_elems_per_ctx_token =
-            (int64_t) m->hparams.dec_d_model * m->hparams.dec_n_layers * 2;
+        m->limits.kv_elems_per_ctx_token = (int64_t) m->hparams.dec_d_model * m->hparams.dec_n_layers * 2;
     }
 
     // Cross-check tokenizer and KV-declared vocab sizes match.
     {
         const int tok_vocab = m->tok.n_tokens();
         if (tok_vocab > 0 && tok_vocab != m->hparams.dec_vocab_size) {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "canary: tokenizer vocab (%d) != stt.canary.decoder.vocab_size (%d)",
-                         tok_vocab, m->hparams.dec_vocab_size);
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "canary: tokenizer vocab (%d) != stt.canary.decoder.vocab_size (%d)",
+                    tok_vocab, m->hparams.dec_vocab_size);
             return TRANSCRIBE_ERR_GGUF;
         }
     }
@@ -431,14 +418,14 @@ transcribe_status load(
     }
     if (m->hparams.eos_token_id < 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "canary: GGUF tokenizer has no eos_token_id and no "
-                     "stt.canary.special.endoftext_id — regenerate GGUF");
+                "canary: GGUF tokenizer has no eos_token_id and no "
+                "stt.canary.special.endoftext_id — regenerate GGUF");
         return TRANSCRIBE_ERR_GGUF;
     }
 
     // Mel frontend.
     {
-        transcribe::MelConfig cfg {};
+        transcribe::MelConfig cfg{};
         cfg.sample_rate  = m->hparams.fe_sample_rate;
         cfg.num_mels     = m->hparams.fe_num_mels;
         cfg.n_fft        = m->hparams.fe_n_fft;
@@ -457,21 +444,16 @@ transcribe_status load(
         {
             using R = load_common::ReadF32Result;
 
-            const size_t fb_elems = static_cast<size_t>(cfg.num_mels)
-                                  * static_cast<size_t>(cfg.n_fft / 2 + 1);
-            const auto fb_rc = load_common::read_f32_tensor_checked(
-                loader.gguf(), loader.path(),
-                "frontend.mel_filterbank", fb_elems,
-                "canary", cfg.filterbank);
+            const size_t fb_elems = static_cast<size_t>(cfg.num_mels) * static_cast<size_t>(cfg.n_fft / 2 + 1);
+            const auto   fb_rc    = load_common::read_f32_tensor_checked(
+                loader.gguf(), loader.path(), "frontend.mel_filterbank", fb_elems, "canary", cfg.filterbank);
             if (fb_rc != R::Ok && fb_rc != R::Absent) {
                 return TRANSCRIBE_ERR_GGUF;
             }
 
             const size_t win_elems = static_cast<size_t>(cfg.win_length);
-            const auto win_rc = load_common::read_f32_tensor_checked(
-                loader.gguf(), loader.path(),
-                "frontend.window", win_elems,
-                "canary", cfg.window);
+            const auto   win_rc = load_common::read_f32_tensor_checked(loader.gguf(), loader.path(), "frontend.window",
+                                                                       win_elems, "canary", cfg.window);
             if (win_rc != R::Ok && win_rc != R::Absent) {
                 return TRANSCRIBE_ERR_GGUF;
             }
@@ -480,53 +462,44 @@ transcribe_status load(
         m->mel.emplace(cfg);
     }
 
-    gguf_init_params init_params {};
+    gguf_init_params init_params{};
     init_params.no_alloc = true;
     init_params.ctx      = &m->ctx_meta;
 
-    gguf_context * gguf_data = gguf_init_from_file(loader.path().c_str(),
-                                                   init_params);
+    gguf_context * gguf_data = gguf_init_from_file(loader.path().c_str(), init_params);
     if (gguf_data == nullptr) {
         return TRANSCRIBE_ERR_GGUF;
     }
 
-    if (const transcribe_status st =
-            build_canary_weights(m->ctx_meta, m->hparams, m->weights);
-        st != TRANSCRIBE_OK)
-    {
+    if (const transcribe_status st = build_canary_weights(m->ctx_meta, m->hparams, m->weights); st != TRANSCRIBE_OK) {
         gguf_free(gguf_data);
         return st;
     }
 
-    const transcribe_backend_request backend_req =
-        (params != nullptr) ? params->backend : TRANSCRIBE_BACKEND_AUTO;
+    const transcribe_backend_request backend_req = (params != nullptr) ? params->backend : TRANSCRIBE_BACKEND_AUTO;
 
     if (const transcribe_status st = transcribe::load_common::init_backends(
             backend_req, (params != nullptr) ? params->gpu_device : 0, "canary", m->plan);
-        st != TRANSCRIBE_OK)
-    {
+        st != TRANSCRIBE_OK) {
         gguf_free(gguf_data);
         return st;
     }
 
-    m->backend = ggml_backend_name(m->plan.primary);
+    m->backend         = ggml_backend_name(m->plan.primary);
     m->primary_backend = m->plan.primary;
 
-    ggml_backend_buffer_t weights_buffer =
-        ggml_backend_alloc_ctx_tensors(m->ctx_meta, m->plan.primary);
+    ggml_backend_buffer_t weights_buffer = ggml_backend_alloc_ctx_tensors(m->ctx_meta, m->plan.primary);
     if (weights_buffer == nullptr) {
         gguf_free(gguf_data);
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "canary: ggml_backend_alloc_ctx_tensors failed");
         return TRANSCRIBE_ERR_GGUF;
     }
     m->backend_buffer = weights_buffer;
-    ggml_backend_buffer_set_usage(weights_buffer,
-                                  GGML_BACKEND_BUFFER_USAGE_WEIGHTS);
+    ggml_backend_buffer_set_usage(weights_buffer, GGML_BACKEND_BUFFER_USAGE_WEIGHTS);
 
-    if (const transcribe_status st = transcribe::load_common::stream_tensor_data(
-            loader.path(), gguf_data, m->ctx_meta, "canary");
-        st != TRANSCRIBE_OK)
-    {
+    if (const transcribe_status st =
+            transcribe::load_common::stream_tensor_data(loader.path(), gguf_data, m->ctx_meta, "canary");
+        st != TRANSCRIBE_OK) {
         gguf_free(gguf_data);
         return st;
     }
@@ -536,27 +509,23 @@ transcribe_status load(
     if (const transcribe_status st = fuse_batch_norm(*m); st != TRANSCRIBE_OK) {
         return st;
     }
-    if (const transcribe_status st = promote_conv_pw_to_f32_on_cpu(*m);
-        st != TRANSCRIBE_OK)
-    {
+    if (const transcribe_status st = promote_conv_pw_to_f32_on_cpu(*m); st != TRANSCRIBE_OK) {
         return st;
     }
 
     m->t_load_us = ggml_time_us() - t_load_start;
-    *out_model = m.release();
+    *out_model   = m.release();
     return TRANSCRIBE_OK;
 }
 
-transcribe_status init_context(
-    transcribe_model *                model,
-    const transcribe_session_params * params,
-    transcribe_session **             out_ctx)
-{
+transcribe_status init_context(transcribe_model *                model,
+                               const transcribe_session_params * params,
+                               transcribe_session **             out_ctx) {
     if (model->arch != &arch) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
 
-    auto cc = std::make_unique<CanarySession>();
+    auto cc       = std::make_unique<CanarySession>();
     cc->model     = model;
     cc->n_threads = params->n_threads;
     cc->kv_type   = params->kv_type;
@@ -564,15 +533,13 @@ transcribe_status init_context(
     // self-KV ceiling only; it does not affect the encoder input limit.
     cc->n_ctx     = transcribe_session_params_n_ctx(params);
 
-    auto * cm = static_cast<CanaryModel *>(model);
-    const bool is_metal =
-        (cm->plan.primary_kind == transcribe::BackendKind::Metal);
+    auto *     cm       = static_cast<CanaryModel *>(model);
+    const bool is_metal = (cm->plan.primary_kind == transcribe::BackendKind::Metal);
 
     cc->encoder_use_flash = !is_metal;
     cc->decoder_use_flash = true;
 
-    transcribe::flash::apply_env_overrides(
-        cc->encoder_use_flash, cc->decoder_use_flash);
+    transcribe::flash::apply_env_overrides(cc->encoder_use_flash, cc->decoder_use_flash);
 
     *out_ctx = cc.release();
     return TRANSCRIBE_OK;
@@ -589,8 +556,7 @@ std::vector<int32_t> build_prompt_canary(const CanaryHParams & hp,
                                          int                   src_lang_id,
                                          int                   tgt_lang_id,
                                          const char *          task,
-                                         bool                  pnc)
-{
+                                         bool                  pnc) {
     std::vector<int32_t> ids;
     ids.reserve(8);
 
@@ -600,10 +566,8 @@ std::vector<int32_t> build_prompt_canary(const CanaryHParams & hp,
     ids.push_back(hp.startoftranscript_id);
     ids.push_back(src_lang_id);
 
-    const bool is_translate =
-        (task != nullptr && std::strcmp(task, "translate") == 0) ||
-        (src_lang_id != tgt_lang_id);
-    int task_id = -1;
+    const bool is_translate = (task != nullptr && std::strcmp(task, "translate") == 0) || (src_lang_id != tgt_lang_id);
+    int        task_id      = -1;
     if (is_translate && hp.translate_id >= 0) {
         task_id = hp.translate_id;
     } else if (hp.transcribe_id >= 0) {
@@ -615,7 +579,9 @@ std::vector<int32_t> build_prompt_canary(const CanaryHParams & hp,
     ids.push_back(tgt_lang_id);
 
     const int pnc_slot = pnc ? hp.pnc_id : hp.nopnc_id;
-    if (pnc_slot < 0) return {};
+    if (pnc_slot < 0) {
+        return {};
+    }
     ids.push_back(pnc_slot);
     return ids;
 }
@@ -624,9 +590,8 @@ std::vector<int32_t> build_prompt_canary2(const CanaryModel &   cm,
                                           const CanaryHParams & hp,
                                           int                   src_lang_id,
                                           int                   tgt_lang_id,
-                                          const char *          /*task*/,
-                                          bool                  pnc)
-{
+                                          const char * /*task*/,
+                                          bool pnc) {
     // canary2 prompt template:
     //   <|startofcontext|> [decodercontext] <|startoftranscript|>
     //   <|emo:?|> <|src_lang|> <|tgt_lang|> <|pnc|> <|itn|> <|timestamp|> <|diarize|>
@@ -634,23 +599,25 @@ std::vector<int32_t> build_prompt_canary2(const CanaryModel &   cm,
     std::vector<int32_t> ids;
     ids.reserve(9);
 
-    if (hp.startofcontext_id < 0 || hp.startoftranscript_id < 0 ||
-        src_lang_id < 0 || tgt_lang_id < 0)
-    {
+    if (hp.startofcontext_id < 0 || hp.startoftranscript_id < 0 || src_lang_id < 0 || tgt_lang_id < 0) {
         return {};
     }
 
     // Emotion is not in the named-special KV catalog; look it up via
     // the tokenizer (every canary2 SP vocab carries <|emo:undefined|>).
     const int emo_id = cm.tok.find("<|emo:undefined|>");
-    if (emo_id < 0) return {};
+    if (emo_id < 0) {
+        return {};
+    }
 
     // Single-SP canary2 (canary-1b-v2): NeMo's prompt formatter renders
     // the empty `decodercontext` slot as one SP whitespace marker (`▁`).
     // Aggregate-tokenizer variants drop the empty slot entirely.
     if (hp.tokenizer_single_sp) {
         const int sp_space_id = cm.tok.find("\xe2\x96\x81");  // U+2581 LOWER ONE EIGHTH BLOCK = ▁
-        if (sp_space_id < 0) return {};
+        if (sp_space_id < 0) {
+            return {};
+        }
         ids.push_back(sp_space_id);
     }
 
@@ -661,32 +628,42 @@ std::vector<int32_t> build_prompt_canary2(const CanaryModel &   cm,
     ids.push_back(tgt_lang_id);
 
     const int pnc_slot = pnc ? hp.pnc_id : hp.nopnc_id;
-    if (pnc_slot < 0) return {};
+    if (pnc_slot < 0) {
+        return {};
+    }
     ids.push_back(pnc_slot);
 
-    if (hp.noitn_id < 0) return {};
+    if (hp.noitn_id < 0) {
+        return {};
+    }
     ids.push_back(hp.noitn_id);
 
-    if (hp.notimestamp_id < 0) return {};
+    if (hp.notimestamp_id < 0) {
+        return {};
+    }
     ids.push_back(hp.notimestamp_id);
 
-    if (hp.nodiarize_id < 0) return {};
+    if (hp.nodiarize_id < 0) {
+        return {};
+    }
     ids.push_back(hp.nodiarize_id);
 
     return ids;
 }
 
 int find_language_id(const CanaryHParams & hp, const char * lang) {
-    if (lang == nullptr) return -1;
+    if (lang == nullptr) {
+        return -1;
+    }
     for (size_t i = 0; i < hp.languages.size() && i < hp.language_ids.size(); ++i) {
-        if (hp.languages[i] == lang) return hp.language_ids[i];
+        if (hp.languages[i] == lang) {
+            return hp.language_ids[i];
+        }
     }
     return -1;
 }
 
-bool translation_pair_allowed(const CanaryHParams & hp,
-                              const char *          src,
-                              const char *          dst) {
+bool translation_pair_allowed(const CanaryHParams & hp, const char * src, const char * dst) {
     if (hp.translation_pairs.empty()) {
         return true;
     }
@@ -702,12 +679,10 @@ bool translation_pair_allowed(const CanaryHParams & hp,
     return false;
 }
 
-transcribe_status run(
-    transcribe_session *      session,
-    const float *             pcm,
-    int                       n_samples,
-    const transcribe_run_params * params)
-{
+transcribe_status run(transcribe_session *          session,
+                      const float *                 pcm,
+                      int                           n_samples,
+                      const transcribe_run_params * params) {
     if (session == nullptr || pcm == nullptr || n_samples <= 0) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
@@ -718,7 +693,9 @@ transcribe_status run(
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
 
-    if (cc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
+    if (cc->poll_abort()) {
+        return TRANSCRIBE_ERR_ABORTED;
+    }
 
     transcribe::debug::init();
 
@@ -727,16 +704,14 @@ transcribe_status run(
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "canary run: model has no MelFrontend");
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
-    const int64_t t_mel_start = ggml_time_us();
-    int mel_n_mels   = 0;
-    int mel_n_frames = 0;
-    if (const transcribe_status mst = cm->mel->compute(
-            pcm, static_cast<size_t>(n_samples),
-            cc->mel_buf, mel_n_mels, mel_n_frames);
-        mst != TRANSCRIBE_OK)
-    {
+    const int64_t t_mel_start  = ggml_time_us();
+    int           mel_n_mels   = 0;
+    int           mel_n_frames = 0;
+    if (const transcribe_status mst =
+            cm->mel->compute(pcm, static_cast<size_t>(n_samples), cc->mel_buf, mel_n_mels, mel_n_frames);
+        mst != TRANSCRIBE_OK) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "canary run: MelFrontend::compute failed (%s)",
-                     transcribe_status_string(mst));
+                transcribe_status_string(mst));
         return mst;
     }
     cc->t_mel_us = ggml_time_us() - t_mel_start;
@@ -746,17 +721,14 @@ transcribe_status run(
     // deterministic function of mel_n_frames, so reject an over-length clip
     // here, before building the encoder graph.
     if (cm->hparams.enc_pos_emb_max_len > 0) {
-        const int t_enc_pred = canary_predict_t_enc(
-            mel_n_frames, cm->hparams.enc_subsampling_factor);
+        const int t_enc_pred = canary_predict_t_enc(mel_n_frames, cm->hparams.enc_subsampling_factor);
         if (t_enc_pred > cm->hparams.enc_pos_emb_max_len) {
-            const double max_s =
-                static_cast<double>(cm->caps.max_audio_ms) / 1000.0;
-            transcribe::log_msg(
-                TRANSCRIBE_LOG_LEVEL_ERROR,
-                "canary run: input too long — %d encoder frames exceed the %d "
-                "the model supports (~%.0f s max). See "
-                "transcribe_capabilities.max_audio_ms.",
-                t_enc_pred, cm->hparams.enc_pos_emb_max_len, max_s);
+            const double max_s = static_cast<double>(cm->caps.max_audio_ms) / 1000.0;
+            transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
+                                "canary run: input too long — %d encoder frames exceed the %d "
+                                "the model supports (~%.0f s max). See "
+                                "transcribe_capabilities.max_audio_ms.",
+                                t_enc_pred, cm->hparams.enc_pos_emb_max_len, max_s);
             return TRANSCRIBE_ERR_INPUT_TOO_LONG;
         }
     }
@@ -770,34 +742,35 @@ transcribe_status run(
 
     // Build encoder graph.
     {
-        ggml_init_params init_params {};
+        ggml_init_params init_params{};
         init_params.mem_size   = 8 * 1024 * 1024;
         init_params.mem_buffer = nullptr;
         init_params.no_alloc   = true;
-        cc->compute_ctx = ggml_init(init_params);
+        cc->compute_ctx        = ggml_init(init_params);
         if (cc->compute_ctx == nullptr) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "canary run: compute context allocation failed — out of memory.");
+                                "canary run: compute context allocation failed — out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
     }
 
     ggml_type resolved_kv = GGML_TYPE_COUNT;
-    if (cc->kv_type == TRANSCRIBE_KV_TYPE_F32) resolved_kv = GGML_TYPE_F32;
-    if (cc->kv_type == TRANSCRIBE_KV_TYPE_F16) resolved_kv = GGML_TYPE_F16;
+    if (cc->kv_type == TRANSCRIBE_KV_TYPE_F32) {
+        resolved_kv = GGML_TYPE_F32;
+    }
+    if (cc->kv_type == TRANSCRIBE_KV_TYPE_F16) {
+        resolved_kv = GGML_TYPE_F16;
+    }
 
-    EncoderBuild eb = build_encoder_graph(
-        cc->compute_ctx, cm->weights, cm->hparams, mel_n_frames,
-        resolved_kv, cc->encoder_use_flash, cm->backend.c_str());
+    EncoderBuild eb = build_encoder_graph(cc->compute_ctx, cm->weights, cm->hparams, mel_n_frames, resolved_kv,
+                                          cc->encoder_use_flash, cm->backend.c_str());
     if (eb.mel_in == nullptr || eb.out == nullptr || eb.graph == nullptr) {
         return TRANSCRIBE_ERR_GGUF;
     }
 
     if (cc->sched == nullptr) {
-        cc->sched = ggml_backend_sched_new(
-            cm->plan.scheduler_list.data(), nullptr,
-            static_cast<int>(cm->plan.scheduler_list.size()),
-            16384, false, true);
+        cc->sched = ggml_backend_sched_new(cm->plan.scheduler_list.data(), nullptr,
+                                           static_cast<int>(cm->plan.scheduler_list.size()), 16384, false, true);
         if (cc->sched == nullptr) {
             log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "canary run: ggml_backend_sched_new failed");
             return TRANSCRIBE_ERR_GGUF;
@@ -805,13 +778,11 @@ transcribe_status run(
     }
     ggml_backend_sched_reset(cc->sched);
     if (!ggml_backend_sched_alloc_graph(cc->sched, eb.graph)) {
-        transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "canary run: encoder graph allocation failed — out of memory.");
+        transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "canary run: encoder graph allocation failed — out of memory.");
         return TRANSCRIBE_ERR_OOM;
     }
 
-    ggml_backend_tensor_set(eb.mel_in, cc->mel_buf.data(),
-                            0, cc->mel_buf.size() * sizeof(float));
+    ggml_backend_tensor_set(eb.mel_in, cc->mel_buf.data(), 0, cc->mel_buf.size() * sizeof(float));
     transcribe::debug::dump_tensor("enc.mel.in", eb.mel_in, "encoder.mel");
 
     // Sinusoidal relative positional embedding.
@@ -826,52 +797,49 @@ transcribe_status run(
         const float ln_10000 = std::log(10000.0f);
         for (int k = 0; k < d_model / 2; ++k) {
             cc->pos_div_term[static_cast<size_t>(k)] =
-                std::exp(static_cast<float>(2 * k) *
-                         (-ln_10000 / static_cast<float>(d_model)));
+                std::exp(static_cast<float>(2 * k) * (-ln_10000 / static_cast<float>(d_model)));
         }
 
         for (int i = 0; i < pos_len; ++i) {
             const float pos = static_cast<float>((T_enc - 1) - i);
-            float * row = cc->pos_buf.data() + static_cast<size_t>(i) * d_model;
+            float *     row = cc->pos_buf.data() + static_cast<size_t>(i) * d_model;
             for (int k = 0; k < d_model / 2; ++k) {
                 const float div = cc->pos_div_term[static_cast<size_t>(k)];
-                row[2 * k]     = std::sin(pos * div);
-                row[2 * k + 1] = std::cos(pos * div);
+                row[2 * k]      = std::sin(pos * div);
+                row[2 * k + 1]  = std::cos(pos * div);
             }
         }
 
-        ggml_backend_tensor_set(eb.pos_emb_in, cc->pos_buf.data(),
-                                0, cc->pos_buf.size() * sizeof(float));
+        ggml_backend_tensor_set(eb.pos_emb_in, cc->pos_buf.data(), 0, cc->pos_buf.size() * sizeof(float));
         transcribe::debug::dump_tensor("enc.pos_emb", eb.pos_emb_in, "encoder.pos_emb");
     }
 
     transcribe::configure_sched_n_threads(cc->sched, cc->n_threads);
 
     const int64_t t_enc_start = ggml_time_us();
-    if (const ggml_status gs = ggml_backend_sched_graph_compute(cc->sched, eb.graph);
-        gs != GGML_STATUS_SUCCESS)
-    {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "canary run: encoder compute failed (%d)",
-                     static_cast<int>(gs));
+    if (const ggml_status gs = ggml_backend_sched_graph_compute(cc->sched, eb.graph); gs != GGML_STATUS_SUCCESS) {
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "canary run: encoder compute failed (%d)", static_cast<int>(gs));
         return TRANSCRIBE_ERR_GGUF;
     }
     cc->t_encode_us = ggml_time_us() - t_enc_start;
 
     auto try_dump = [](const char * name, ggml_tensor * t, const char * stage) {
-        if (t != nullptr) transcribe::debug::dump_tensor(name, t, stage);
+        if (t != nullptr) {
+            transcribe::debug::dump_tensor(name, t, stage);
+        }
     };
 
     try_dump("enc.pre_encode.out", eb.dumps.pre_encode_out, "encoder.pre_encode");
-    try_dump("enc.block.0.out",    eb.dumps.block0_out,     "encoder.block0.out");
+    try_dump("enc.block.0.out", eb.dumps.block0_out, "encoder.block0.out");
     {
-        char bname[64], stage[64];
+        char      bname[64], stage[64];
         const int mid = cm->hparams.enc_n_layers / 2;
         std::snprintf(bname, sizeof(bname), "enc.block.%d.out", mid);
         std::snprintf(stage, sizeof(stage), "encoder.block%d.out", mid);
         try_dump(bname, eb.dumps.block_mid_out, stage);
     }
     {
-        char bname[64], stage[64];
+        char      bname[64], stage[64];
         const int last = cm->hparams.enc_n_layers - 1;
         std::snprintf(bname, sizeof(bname), "enc.block.%d.out", last);
         std::snprintf(stage, sizeof(stage), "encoder.block%d.out", last);
@@ -879,7 +847,7 @@ transcribe_status run(
     }
     // Native (pre-projection) and final (post-projection) encoder outs.
     try_dump("enc.native", eb.dumps.native_out, "encoder.native_out");
-    try_dump("enc.final",  eb.dumps.final_out,  "encoder.final");
+    try_dump("enc.final", eb.dumps.final_out, "encoder.final");
 
     cc->encoder_out = eb.out;
 
@@ -887,21 +855,16 @@ transcribe_status run(
     const int d_dec = static_cast<int>(eb.out->ne[0]);
     const int T_enc = static_cast<int>(eb.out->ne[1]);
     if (d_dec <= 0 || T_enc <= 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "canary run: encoder output has degenerate shape [%d, %d]",
-                     d_dec, T_enc);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "canary run: encoder output has degenerate shape [%d, %d]", d_dec, T_enc);
         return TRANSCRIBE_ERR_GGUF;
     }
-    cc->enc_host.resize(static_cast<size_t>(d_dec) *
-                        static_cast<size_t>(T_enc));
-    ggml_backend_tensor_get(eb.out, cc->enc_host.data(), 0,
-                            cc->enc_host.size() * sizeof(float));
+    cc->enc_host.resize(static_cast<size_t>(d_dec) * static_cast<size_t>(T_enc));
+    ggml_backend_tensor_get(eb.out, cc->enc_host.data(), 0, cc->enc_host.size() * sizeof(float));
 
     // Build multitask prompt.
-    const char * lang = (params && params->language) ? params->language : "en";
-    const bool is_translate =
-        (params != nullptr && params->task == TRANSCRIBE_TASK_TRANSLATE);
-    const char * tgt_lang = lang;
+    const char * lang         = (params && params->language) ? params->language : "en";
+    const bool   is_translate = (params != nullptr && params->task == TRANSCRIBE_TASK_TRANSLATE);
+    const char * tgt_lang     = lang;
     if (is_translate && params && params->target_language) {
         tgt_lang = params->target_language;
     }
@@ -911,23 +874,20 @@ transcribe_status run(
     const int tgt_id = find_language_id(cm->hparams, tgt_lang);
     if (src_id < 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "canary run: source language '%s' has no token id "
-                     "(model supports %zu langs)",
-                     lang, cm->hparams.languages.size());
+                "canary run: source language '%s' has no token id "
+                "(model supports %zu langs)",
+                lang, cm->hparams.languages.size());
         return TRANSCRIBE_ERR_UNSUPPORTED_LANGUAGE;
     }
     if (tgt_id < 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "canary run: target language '%s' has no token id "
-                     "(model supports %zu langs)",
-                     tgt_lang, cm->hparams.languages.size());
+                "canary run: target language '%s' has no token id "
+                "(model supports %zu langs)",
+                tgt_lang, cm->hparams.languages.size());
         return TRANSCRIBE_ERR_UNSUPPORTED_LANGUAGE;
     }
-    if (is_translate &&
-        !translation_pair_allowed(cm->hparams, lang, tgt_lang)) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "canary run: translation pair '%s>%s' is not advertised",
-                     lang, tgt_lang);
+    if (is_translate && !translation_pair_allowed(cm->hparams, lang, tgt_lang)) {
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "canary run: translation pair '%s>%s' is not advertised", lang, tgt_lang);
         return TRANSCRIBE_ERR_UNSUPPORTED_LANGUAGE;
     }
 
@@ -941,24 +901,27 @@ transcribe_status run(
     bool pnc = true;
     if (params != nullptr) {
         switch (params->pnc) {
-            case TRANSCRIBE_PNC_MODE_DEFAULT: pnc = true;  break;
-            case TRANSCRIBE_PNC_MODE_OFF:     pnc = false; break;
-            case TRANSCRIBE_PNC_MODE_ON:      pnc = true;  break;
+            case TRANSCRIBE_PNC_MODE_DEFAULT:
+                pnc = true;
+                break;
+            case TRANSCRIBE_PNC_MODE_OFF:
+                pnc = false;
+                break;
+            case TRANSCRIBE_PNC_MODE_ON:
+                pnc = true;
+                break;
         }
     }
 
     std::vector<int32_t> prompt_ids;
     if (cm->hparams.prompt_format == "canary2") {
-        prompt_ids = build_prompt_canary2(*cm, cm->hparams, src_id, tgt_id,
-                                          task, pnc);
+        prompt_ids = build_prompt_canary2(*cm, cm->hparams, src_id, tgt_id, task, pnc);
     } else if (cm->hparams.prompt_format == "canary") {
-        prompt_ids = build_prompt_canary(cm->hparams, src_id, tgt_id,
-                                         task, pnc);
+        prompt_ids = build_prompt_canary(cm->hparams, src_id, tgt_id, task, pnc);
     }
     if (prompt_ids.empty()) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "canary run: failed to build prompt for format='%s'",
-                     cm->hparams.prompt_format.c_str());
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "canary run: failed to build prompt for format='%s'",
+                cm->hparams.prompt_format.c_str());
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
     const int prompt_len = static_cast<int>(prompt_ids.size());
@@ -973,26 +936,23 @@ transcribe_status run(
             // optionally lowered (never raised) by the caller's n_ctx knob.
             // With the default knob (0) this is exactly dec_max_position, so
             // in-spec decode is unchanged.
-            const int n_ctx = canary_context_ceiling(cc->n_ctx, cm->hparams);
+            const int n_ctx      = canary_context_ceiling(cc->n_ctx, cm->hparams);
             ggml_type cache_type = resolved_kv;
-            if (cache_type == GGML_TYPE_COUNT) cache_type = GGML_TYPE_F16;
-            if (!kv_cache_init(cc->kv_cache, cm->plan.primary,
-                               n_ctx, T_enc,
-                               cm->hparams.dec_d_model,
-                               cm->hparams.dec_n_layers,
-                               cache_type))
-            {
+            if (cache_type == GGML_TYPE_COUNT) {
+                cache_type = GGML_TYPE_F16;
+            }
+            if (!kv_cache_init(cc->kv_cache, cm->plan.primary, n_ctx, T_enc, cm->hparams.dec_d_model,
+                               cm->hparams.dec_n_layers, cache_type)) {
                 transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                    "canary run: KV cache allocation failed (n_ctx=%d, T_enc=%d, "
-                    "%d d_model x %d layers) — out of memory. Lower "
-                    "transcribe_session_params.n_ctx or shorten the audio.",
-                    n_ctx, T_enc, cm->hparams.dec_d_model,
-                    cm->hparams.dec_n_layers);
+                                    "canary run: KV cache allocation failed (n_ctx=%d, T_enc=%d, "
+                                    "%d d_model x %d layers) — out of memory. Lower "
+                                    "transcribe_session_params.n_ctx or shorten the audio.",
+                                    n_ctx, T_enc, cm->hparams.dec_d_model, cm->hparams.dec_n_layers);
                 return TRANSCRIBE_ERR_OOM;
             }
         } else {
-            cc->kv_cache.n    = 0;
-            cc->kv_cache.head = 0;
+            cc->kv_cache.n               = 0;
+            cc->kv_cache.head            = 0;
             cc->kv_cache.cross_populated = false;
         }
     }
@@ -1003,22 +963,18 @@ transcribe_status run(
             cc->compute_ctx = nullptr;
         }
         cc->encoder_out = nullptr;
-        ggml_init_params ip {};
-        ip.mem_size   = mem_size;
-        ip.mem_buffer = nullptr;
-        ip.no_alloc   = true;
+        ggml_init_params ip{};
+        ip.mem_size     = mem_size;
+        ip.mem_buffer   = nullptr;
+        ip.no_alloc     = true;
         cc->compute_ctx = ggml_init(ip);
         return cc->compute_ctx != nullptr;
     };
 
     auto find_mask_input = [&]() -> ggml_tensor * {
-        for (ggml_tensor * t = ggml_get_first_tensor(cc->compute_ctx);
-             t != nullptr;
-             t = ggml_get_next_tensor(cc->compute_ctx, t))
-        {
-            if (std::strcmp(t->name, "dec.causal_mask") == 0 &&
-                t->type == GGML_TYPE_F32)
-            {
+        for (ggml_tensor * t = ggml_get_first_tensor(cc->compute_ctx); t != nullptr;
+             t               = ggml_get_next_tensor(cc->compute_ctx, t)) {
+            if (std::strcmp(t->name, "dec.causal_mask") == 0 && t->type == GGML_TYPE_F32) {
                 return t;
             }
         }
@@ -1030,13 +986,12 @@ transcribe_status run(
     {
         if (!new_compute_ctx(4 * 1024 * 1024)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "canary run: cross-KV compute context allocation failed — "
-                "out of memory.");
+                                "canary run: cross-KV compute context allocation failed — "
+                                "out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
 
-        DecoderBuild cross_db = build_cross_kv_graph(
-            cc->compute_ctx, cm->weights, cm->hparams, cc->kv_cache, T_enc);
+        DecoderBuild cross_db = build_cross_kv_graph(cc->compute_ctx, cm->weights, cm->hparams, cc->kv_cache, T_enc);
         if (cross_db.graph == nullptr) {
             log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "canary run: build_cross_kv_graph failed");
             return TRANSCRIBE_ERR_GGUF;
@@ -1045,20 +1000,15 @@ transcribe_status run(
         ggml_backend_sched_reset(cc->sched);
         if (!ggml_backend_sched_alloc_graph(cc->sched, cross_db.graph)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "canary run: cross-KV graph allocation failed — out of memory.");
+                                "canary run: cross-KV graph allocation failed — out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
 
-        ggml_backend_tensor_set(cross_db.encoder_out_in,
-                                cc->enc_host.data(), 0,
-                                cc->enc_host.size() * sizeof(float));
+        ggml_backend_tensor_set(cross_db.encoder_out_in, cc->enc_host.data(), 0, cc->enc_host.size() * sizeof(float));
 
-        if (const ggml_status gs =
-                ggml_backend_sched_graph_compute(cc->sched, cross_db.graph);
-            gs != GGML_STATUS_SUCCESS)
-        {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "canary run: cross_kv compute failed (%d)",
-                         static_cast<int>(gs));
+        if (const ggml_status gs = ggml_backend_sched_graph_compute(cc->sched, cross_db.graph);
+            gs != GGML_STATUS_SUCCESS) {
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "canary run: cross_kv compute failed (%d)", static_cast<int>(gs));
             return TRANSCRIBE_ERR_GGUF;
         }
         cc->kv_cache.cross_populated = true;
@@ -1068,20 +1018,18 @@ transcribe_status run(
     {
         if (!new_compute_ctx(4 * 1024 * 1024)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "canary run: decoder-prompt compute context allocation failed — "
-                "out of memory.");
+                                "canary run: decoder-prompt compute context allocation failed — "
+                                "out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
 
         // When debug-dumping, we need full softmax'd logits for the
         // pre-head dump pipeline (matches cohere's pattern). Otherwise
         // skip log_softmax and read a GPU argmax over the last position.
-        const bool prompt_skip_softmax = !transcribe::debug::enabled();
-        DecoderBuild db = build_decoder_graph_kv(
-            cc->compute_ctx, cm->weights, cm->hparams, cc->kv_cache,
-            prompt_len, /*n_past=*/0, T_enc,
-            /*skip_log_softmax=*/prompt_skip_softmax,
-            cc->decoder_use_flash);
+        const bool   prompt_skip_softmax = !transcribe::debug::enabled();
+        DecoderBuild db = build_decoder_graph_kv(cc->compute_ctx, cm->weights, cm->hparams, cc->kv_cache, prompt_len,
+                                                 /*n_past=*/0, T_enc,
+                                                 /*skip_log_softmax=*/prompt_skip_softmax, cc->decoder_use_flash);
         if (db.out == nullptr || db.graph == nullptr) {
             log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "canary run: build_decoder_graph_kv (prompt) failed");
             return TRANSCRIBE_ERR_GGUF;
@@ -1090,50 +1038,44 @@ transcribe_status run(
         ggml_backend_sched_reset(cc->sched);
         if (!ggml_backend_sched_alloc_graph(cc->sched, db.graph)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "canary run: decoder-prompt graph allocation failed — "
-                "out of memory.");
+                                "canary run: decoder-prompt graph allocation failed — "
+                                "out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
 
-        ggml_backend_tensor_set(db.token_ids_in, prompt_ids.data(),
-                                0, prompt_ids.size() * sizeof(int32_t));
+        ggml_backend_tensor_set(db.token_ids_in, prompt_ids.data(), 0, prompt_ids.size() * sizeof(int32_t));
         std::vector<int32_t> pos_ids(prompt_len);
-        for (int i = 0; i < prompt_len; ++i) pos_ids[i] = i;
-        ggml_backend_tensor_set(db.pos_ids_in, pos_ids.data(),
-                                0, pos_ids.size() * sizeof(int32_t));
+        for (int i = 0; i < prompt_len; ++i) {
+            pos_ids[i] = i;
+        }
+        ggml_backend_tensor_set(db.pos_ids_in, pos_ids.data(), 0, pos_ids.size() * sizeof(int32_t));
 
         if (prompt_len > 1) {
             ggml_tensor * mask_input = find_mask_input();
             if (mask_input != nullptr) {
-                const int n_kv = prompt_len;
-                std::vector<float> mask_data(
-                    static_cast<size_t>(n_kv) * prompt_len);
+                const int          n_kv = prompt_len;
+                std::vector<float> mask_data(static_cast<size_t>(n_kv) * prompt_len);
                 for (int q = 0; q < prompt_len; ++q) {
                     for (int k = 0; k < n_kv; ++k) {
-                        mask_data[static_cast<size_t>(q) * n_kv + k] =
-                            (k <= q) ? 0.0f : -1e9f;
+                        mask_data[static_cast<size_t>(q) * n_kv + k] = (k <= q) ? 0.0f : -1e9f;
                     }
                 }
-                ggml_backend_tensor_set(mask_input, mask_data.data(),
-                                        0, mask_data.size() * sizeof(float));
+                ggml_backend_tensor_set(mask_input, mask_data.data(), 0, mask_data.size() * sizeof(float));
             }
         }
 
-        if (const ggml_status gs =
-                ggml_backend_sched_graph_compute(cc->sched, db.graph);
-            gs != GGML_STATUS_SUCCESS)
-        {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "canary run: decoder prompt compute failed (%d)",
-                         static_cast<int>(gs));
+        if (const ggml_status gs = ggml_backend_sched_graph_compute(cc->sched, db.graph); gs != GGML_STATUS_SUCCESS) {
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "canary run: decoder prompt compute failed (%d)", static_cast<int>(gs));
             return TRANSCRIBE_ERR_GGUF;
         }
 
         // Per-sublayer dumps at layers {0, n_layers/2, n_layers-1}.
         for (int i = 0; i < cm->hparams.dec_n_layers; ++i) {
             const bool dump_this =
-                (i == 0) || (i == cm->hparams.dec_n_layers / 2) ||
-                (i == cm->hparams.dec_n_layers - 1);
-            if (!dump_this || i >= 64) continue;
+                (i == 0) || (i == cm->hparams.dec_n_layers / 2) || (i == cm->hparams.dec_n_layers - 1);
+            if (!dump_this || i >= 64) {
+                continue;
+            }
             char bname[64], stage[64];
             std::snprintf(bname, sizeof(bname), "dec.layer.%d.self_attn.out", i);
             std::snprintf(stage, sizeof(stage), "decoder.layer%d.self_attn", i);
@@ -1151,7 +1093,7 @@ transcribe_status run(
 
         cc->clear_result();
 
-        const int eos_id = cm->hparams.eos_token_id;
+        const int eos_id     = cm->hparams.eos_token_id;
         const int max_tokens = std::min(512, cc->kv_cache.n_ctx - prompt_len);
 
         int next_token = 0;
@@ -1160,25 +1102,23 @@ transcribe_status run(
             ggml_backend_tensor_get(db.argmax_out, &argmax_id, 0, sizeof(int32_t));
             next_token = argmax_id;
         } else {
-            const int64_t vocab_size = db.out->ne[0];
-            std::vector<float> logits_host(
-                static_cast<size_t>(vocab_size) * prompt_len);
-            ggml_backend_tensor_get(db.out, logits_host.data(), 0,
-                                    logits_host.size() * sizeof(float));
-            const float * last_logits = logits_host.data() +
-                                        static_cast<size_t>(prompt_len - 1) *
-                                        vocab_size;
-            float best = last_logits[0];
+            const int64_t      vocab_size = db.out->ne[0];
+            std::vector<float> logits_host(static_cast<size_t>(vocab_size) * prompt_len);
+            ggml_backend_tensor_get(db.out, logits_host.data(), 0, logits_host.size() * sizeof(float));
+            const float * last_logits = logits_host.data() + static_cast<size_t>(prompt_len - 1) * vocab_size;
+            float         best        = last_logits[0];
             for (int j = 1; j < static_cast<int>(vocab_size); ++j) {
                 if (last_logits[j] > best) {
-                    best = last_logits[j];
+                    best       = last_logits[j];
                     next_token = j;
                 }
             }
         }
 
         std::vector<int> generated_ids;
-        if (next_token != eos_id) generated_ids.push_back(next_token);
+        if (next_token != eos_id) {
+            generated_ids.push_back(next_token);
+        }
 
         int n_past = prompt_len;
 
@@ -1189,7 +1129,9 @@ transcribe_status run(
         auto commit_result = [&]() {
             cc->t_decode_us = ggml_time_us() - t_dec_start;
 
-            if (generated_ids.empty()) return;
+            if (generated_ids.empty()) {
+                return;
+            }
 
             const transcribe::Tokenizer & tok = cm->tok;
 
@@ -1199,22 +1141,24 @@ transcribe_status run(
             // strip is defensive — and only applied when the caller wants
             // clean text. --raw-tokens / keep_special_tags=true exposes
             // whatever the decoder emitted.
-            const bool strip =
-                (params == nullptr) ? true : !params->keep_special_tags;
+            const bool       strip = (params == nullptr) ? true : !params->keep_special_tags;
             std::vector<int> text_ids;
             if (strip) {
                 text_ids.reserve(generated_ids.size());
                 for (int id : generated_ids) {
-                    if (tok.is_control(id)) continue;
+                    if (tok.is_control(id)) {
+                        continue;
+                    }
                     text_ids.push_back(id);
                 }
             } else {
                 text_ids.assign(generated_ids.begin(), generated_ids.end());
             }
 
-            std::string full = tok.decode(text_ids.data(),
-                                          static_cast<int>(text_ids.size()));
-            if (!full.empty() && full.front() == ' ') full.erase(full.begin());
+            std::string full = tok.decode(text_ids.data(), static_cast<int>(text_ids.size()));
+            if (!full.empty() && full.front() == ' ') {
+                full.erase(full.begin());
+            }
 
             transcribe_session::SegmentEntry seg;
             seg.t0_ms       = 0;
@@ -1237,29 +1181,31 @@ transcribe_status run(
         //     dispatch overhead.
         //   CPU: build_decoder_graph_kv per step — n_kv grows with n_past, so
         //     no dispatch overhead to amortize and no static-graph bandwidth tax.
-        const bool primary_is_gpu =
-            cm->plan.primary_kind != transcribe::BackendKind::Cpu &&
-            cm->plan.primary_kind != transcribe::BackendKind::Accel &&
-            cm->plan.primary_kind != transcribe::BackendKind::Unknown;
+        const bool primary_is_gpu = cm->plan.primary_kind != transcribe::BackendKind::Cpu &&
+                                    cm->plan.primary_kind != transcribe::BackendKind::Accel &&
+                                    cm->plan.primary_kind != transcribe::BackendKind::Unknown;
 
         if (primary_is_gpu) {
             // Static-graph step path (GPU). max_n_kv: pad to next power of two
             // with a 1024 floor — Vulkan/Metal flash-attn dispatches ~30%
             // faster on pow2 ne[1].
             int max_n_kv = 1024;
-            while (max_n_kv < prompt_len + max_tokens) max_n_kv *= 2;
-            if (max_n_kv > cc->kv_cache.n_ctx) max_n_kv = cc->kv_cache.n_ctx;
+            while (max_n_kv < prompt_len + max_tokens) {
+                max_n_kv *= 2;
+            }
+            if (max_n_kv > cc->kv_cache.n_ctx) {
+                max_n_kv = cc->kv_cache.n_ctx;
+            }
 
             if (!new_compute_ctx(8 * 1024 * 1024)) {
                 transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                    "canary run: step compute context allocation failed — "
-                    "out of memory.");
+                                    "canary run: step compute context allocation failed — "
+                                    "out of memory.");
                 commit_result();
                 return TRANSCRIBE_ERR_OOM;
             }
-            StepBuild sb = build_step_graph(
-                cc->compute_ctx, cm->weights, cm->hparams, cc->kv_cache,
-                max_n_kv, T_enc, cc->decoder_use_flash);
+            StepBuild sb = build_step_graph(cc->compute_ctx, cm->weights, cm->hparams, cc->kv_cache, max_n_kv, T_enc,
+                                            cc->decoder_use_flash);
             if (sb.graph == nullptr || sb.argmax_out == nullptr) {
                 log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "canary run: build_step_graph failed");
                 commit_result();
@@ -1268,7 +1214,7 @@ transcribe_status run(
             ggml_backend_sched_reset(cc->sched);
             if (!ggml_backend_sched_alloc_graph(cc->sched, sb.graph)) {
                 transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                    "canary run: step graph allocation failed — out of memory.");
+                                    "canary run: step graph allocation failed — out of memory.");
                 commit_result();
                 return TRANSCRIBE_ERR_OOM;
             }
@@ -1277,10 +1223,12 @@ transcribe_status run(
             // already populated by the prompt pass [0, prompt_len) start
             // attendable; remaining slots are -inf until each step flips
             // its newly-written position to attendable.
-            const ggml_fp16_t mask_zero    = ggml_fp32_to_fp16(0.0f);
-            const ggml_fp16_t mask_neg_inf = ggml_fp32_to_fp16(-INFINITY);
+            const ggml_fp16_t        mask_zero    = ggml_fp32_to_fp16(0.0f);
+            const ggml_fp16_t        mask_neg_inf = ggml_fp32_to_fp16(-INFINITY);
             std::vector<ggml_fp16_t> step_mask(max_n_kv, mask_neg_inf);
-            for (int p = 0; p < prompt_len; ++p) step_mask[p] = mask_zero;
+            for (int p = 0; p < prompt_len; ++p) {
+                step_mask[p] = mask_zero;
+            }
 
             for (int step = 1; step < max_tokens && next_token != eos_id; ++step) {
                 if (cc->poll_abort()) {
@@ -1288,10 +1236,8 @@ transcribe_status run(
                     return TRANSCRIBE_ERR_ABORTED;
                 }
                 if (n_past + 1 > max_n_kv) {
-                    transcribe::log_msg(
-                        TRANSCRIBE_LOG_LEVEL_WARN,
-                        "canary run: hit max_n_kv=%d at n_past=%d",
-                        max_n_kv, n_past);
+                    transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_WARN, "canary run: hit max_n_kv=%d at n_past=%d", max_n_kv,
+                                        n_past);
                     break;
                 }
 
@@ -1299,18 +1245,15 @@ transcribe_status run(
                 int32_t pos_val   = n_past;
                 int64_t kv_val    = n_past;
                 ggml_backend_tensor_set(sb.token_id_in, &token_val, 0, sizeof(int32_t));
-                ggml_backend_tensor_set(sb.pos_id_in,   &pos_val,   0, sizeof(int32_t));
-                ggml_backend_tensor_set(sb.kv_idx_in,   &kv_val,    0, sizeof(int64_t));
+                ggml_backend_tensor_set(sb.pos_id_in, &pos_val, 0, sizeof(int32_t));
+                ggml_backend_tensor_set(sb.kv_idx_in, &kv_val, 0, sizeof(int64_t));
 
                 step_mask[n_past] = mask_zero;
                 ggml_backend_tensor_set(sb.mask_in, step_mask.data(), 0,
-                                        static_cast<size_t>(max_n_kv) *
-                                        sizeof(ggml_fp16_t));
+                                        static_cast<size_t>(max_n_kv) * sizeof(ggml_fp16_t));
 
-                if (const ggml_status gs =
-                        ggml_backend_sched_graph_compute(cc->sched, sb.graph);
-                    gs != GGML_STATUS_SUCCESS)
-                {
+                if (const ggml_status gs = ggml_backend_sched_graph_compute(cc->sched, sb.graph);
+                    gs != GGML_STATUS_SUCCESS) {
                     break;
                 }
 
@@ -1322,18 +1265,19 @@ transcribe_status run(
                 ggml_backend_tensor_get(sb.argmax_out, &argmax_id, 0, sizeof(int32_t));
                 next_token = argmax_id;
 
-                if (next_token != eos_id) generated_ids.push_back(next_token);
+                if (next_token != eos_id) {
+                    generated_ids.push_back(next_token);
+                }
             }
         } else {
             // Dynamic-graph step path (CPU). Reserve the worst-case step graph
             // so per-step alloc_graph doesn't grow the scheduler's memory pool.
             if (new_compute_ctx(4 * 1024 * 1024)) {
-                const int worst_n_past = cc->kv_cache.n_ctx - 1;
-                DecoderBuild db_reserve = build_decoder_graph_kv(
-                    cc->compute_ctx, cm->weights, cm->hparams, cc->kv_cache,
-                    /*n_tokens=*/1, worst_n_past, T_enc,
-                    /*skip_log_softmax=*/true,
-                    cc->decoder_use_flash);
+                const int    worst_n_past = cc->kv_cache.n_ctx - 1;
+                DecoderBuild db_reserve =
+                    build_decoder_graph_kv(cc->compute_ctx, cm->weights, cm->hparams, cc->kv_cache,
+                                           /*n_tokens=*/1, worst_n_past, T_enc,
+                                           /*skip_log_softmax=*/true, cc->decoder_use_flash);
                 if (db_reserve.graph != nullptr) {
                     ggml_backend_sched_reserve(cc->sched, db_reserve.graph);
                 }
@@ -1345,34 +1289,33 @@ transcribe_status run(
                     return TRANSCRIBE_ERR_ABORTED;
                 }
                 if (n_past + 1 > cc->kv_cache.n_ctx) {
-                    transcribe::log_msg(
-                        TRANSCRIBE_LOG_LEVEL_WARN,
-                        "canary run: KV cache full at n_past=%d",
-                        n_past);
+                    transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_WARN, "canary run: KV cache full at n_past=%d", n_past);
                     break;
                 }
 
-                if (!new_compute_ctx(4 * 1024 * 1024)) break;
+                if (!new_compute_ctx(4 * 1024 * 1024)) {
+                    break;
+                }
 
-                DecoderBuild db_step = build_decoder_graph_kv(
-                    cc->compute_ctx, cm->weights, cm->hparams, cc->kv_cache,
-                    /*n_tokens=*/1, n_past, T_enc,
-                    /*skip_log_softmax=*/true,
-                    cc->decoder_use_flash);
-                if (db_step.out == nullptr || db_step.graph == nullptr) break;
+                DecoderBuild db_step = build_decoder_graph_kv(cc->compute_ctx, cm->weights, cm->hparams, cc->kv_cache,
+                                                              /*n_tokens=*/1, n_past, T_enc,
+                                                              /*skip_log_softmax=*/true, cc->decoder_use_flash);
+                if (db_step.out == nullptr || db_step.graph == nullptr) {
+                    break;
+                }
 
                 ggml_backend_sched_reset(cc->sched);
-                if (!ggml_backend_sched_alloc_graph(cc->sched, db_step.graph)) break;
+                if (!ggml_backend_sched_alloc_graph(cc->sched, db_step.graph)) {
+                    break;
+                }
 
                 int32_t token_id = next_token;
                 int32_t pos_id   = n_past;
                 ggml_backend_tensor_set(db_step.token_ids_in, &token_id, 0, sizeof(int32_t));
-                ggml_backend_tensor_set(db_step.pos_ids_in,   &pos_id,   0, sizeof(int32_t));
+                ggml_backend_tensor_set(db_step.pos_ids_in, &pos_id, 0, sizeof(int32_t));
 
-                if (const ggml_status gs =
-                        ggml_backend_sched_graph_compute(cc->sched, db_step.graph);
-                    gs != GGML_STATUS_SUCCESS)
-                {
+                if (const ggml_status gs = ggml_backend_sched_graph_compute(cc->sched, db_step.graph);
+                    gs != GGML_STATUS_SUCCESS) {
                     break;
                 }
 
@@ -1384,7 +1327,9 @@ transcribe_status run(
                 ggml_backend_tensor_get(db_step.argmax_out, &argmax_id, 0, sizeof(int32_t));
                 next_token = argmax_id;
 
-                if (next_token != eos_id) generated_ids.push_back(next_token);
+                if (next_token != eos_id) {
+                    generated_ids.push_back(next_token);
+                }
             }
         }
 
@@ -1394,12 +1339,11 @@ transcribe_status run(
         // intentionally do NOT set the flag — abort is not a length truncation.)
         if (next_token != eos_id) {
             cc->was_truncated = true;
-            transcribe::log_msg(
-                TRANSCRIBE_LOG_LEVEL_WARN,
-                "canary run: output truncated at %d tokens — decode reached the "
-                "generation budget / decoder context (%d) before end-of-stream; "
-                "the transcript may be incomplete.",
-                static_cast<int>(generated_ids.size()), cc->kv_cache.n_ctx);
+            transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_WARN,
+                                "canary run: output truncated at %d tokens — decode reached the "
+                                "generation budget / decoder context (%d) before end-of-stream; "
+                                "the transcript may be incomplete.",
+                                static_cast<int>(generated_ids.size()), cc->kv_cache.n_ctx);
         }
 
         commit_result();
@@ -1407,8 +1351,7 @@ transcribe_status run(
 
     // Partial transcript committed above; a truncated decode returns the hard
     // OUTPUT_TRUNCATED status (the result stays readable, like an aborted run).
-    return cc->was_truncated ? TRANSCRIBE_ERR_OUTPUT_TRUNCATED
-                             : TRANSCRIBE_OK;
+    return cc->was_truncated ? TRANSCRIBE_ERR_OUTPUT_TRUNCATED : TRANSCRIBE_OK;
 }
 
 // ===========================================================================
@@ -1417,172 +1360,207 @@ transcribe_status run(
 // ===========================================================================
 
 // Encoder for one utterance from a precomputed mel buffer → host [hidden, T_enc].
-transcribe_status encode_one_to_host(
-    CanarySession * cc, CanaryModel * cm,
-    const std::vector<float> & mel_buf, int mel_n_frames,
-    std::vector<float> & enc_host_out, int & T_enc_out, int64_t & enc_us)
-{
-    if (mel_n_frames <= 0) return TRANSCRIBE_ERR_INVALID_ARG;
-
-    if (cc->compute_ctx != nullptr) { ggml_free(cc->compute_ctx); cc->compute_ctx = nullptr; }
+transcribe_status encode_one_to_host(CanarySession *            cc,
+                                     CanaryModel *              cm,
+                                     const std::vector<float> & mel_buf,
+                                     int                        mel_n_frames,
+                                     std::vector<float> &       enc_host_out,
+                                     int &                      T_enc_out,
+                                     int64_t &                  enc_us) {
+    if (mel_n_frames <= 0) {
+        return TRANSCRIBE_ERR_INVALID_ARG;
+    }
+
+    if (cc->compute_ctx != nullptr) {
+        ggml_free(cc->compute_ctx);
+        cc->compute_ctx = nullptr;
+    }
     cc->encoder_out = nullptr;
-    { ggml_init_params ip {}; ip.mem_size = 8 * 1024 * 1024; ip.mem_buffer = nullptr;
-      ip.no_alloc = true; cc->compute_ctx = ggml_init(ip);
-      if (cc->compute_ctx == nullptr) {
-          transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-              "canary encode_one_to_host: compute context allocation failed — "
-              "out of memory.");
-          return TRANSCRIBE_ERR_OOM;
-      } }
+    {
+        ggml_init_params ip{};
+        ip.mem_size     = 8 * 1024 * 1024;
+        ip.mem_buffer   = nullptr;
+        ip.no_alloc     = true;
+        cc->compute_ctx = ggml_init(ip);
+        if (cc->compute_ctx == nullptr) {
+            transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
+                                "canary encode_one_to_host: compute context allocation failed — "
+                                "out of memory.");
+            return TRANSCRIBE_ERR_OOM;
+        }
+    }
 
     ggml_type resolved_kv = GGML_TYPE_COUNT;
-    if (cc->kv_type == TRANSCRIBE_KV_TYPE_F32) resolved_kv = GGML_TYPE_F32;
-    if (cc->kv_type == TRANSCRIBE_KV_TYPE_F16) resolved_kv = GGML_TYPE_F16;
+    if (cc->kv_type == TRANSCRIBE_KV_TYPE_F32) {
+        resolved_kv = GGML_TYPE_F32;
+    }
+    if (cc->kv_type == TRANSCRIBE_KV_TYPE_F16) {
+        resolved_kv = GGML_TYPE_F16;
+    }
 
-    EncoderBuild eb = build_encoder_graph(
-        cc->compute_ctx, cm->weights, cm->hparams, mel_n_frames,
-        resolved_kv, cc->encoder_use_flash, cm->backend.c_str());
-    if (eb.out == nullptr || eb.graph == nullptr) return TRANSCRIBE_ERR_GGUF;
+    EncoderBuild eb = build_encoder_graph(cc->compute_ctx, cm->weights, cm->hparams, mel_n_frames, resolved_kv,
+                                          cc->encoder_use_flash, cm->backend.c_str());
+    if (eb.out == nullptr || eb.graph == nullptr) {
+        return TRANSCRIBE_ERR_GGUF;
+    }
 
     if (cc->sched == nullptr) {
-        cc->sched = ggml_backend_sched_new(
-            cm->plan.scheduler_list.data(), nullptr,
-            static_cast<int>(cm->plan.scheduler_list.size()), 16384, false, true);
-        if (cc->sched == nullptr) return TRANSCRIBE_ERR_GGUF;
+        cc->sched = ggml_backend_sched_new(cm->plan.scheduler_list.data(), nullptr,
+                                           static_cast<int>(cm->plan.scheduler_list.size()), 16384, false, true);
+        if (cc->sched == nullptr) {
+            return TRANSCRIBE_ERR_GGUF;
+        }
     }
     ggml_backend_sched_reset(cc->sched);
     if (!ggml_backend_sched_alloc_graph(cc->sched, eb.graph)) {
         transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "canary encode_one_to_host: encoder graph allocation failed — "
-            "out of memory.");
+                            "canary encode_one_to_host: encoder graph allocation failed — "
+                            "out of memory.");
         return TRANSCRIBE_ERR_OOM;
     }
 
     ggml_backend_tensor_set(eb.mel_in, mel_buf.data(), 0, mel_buf.size() * sizeof(float));
 
     if (eb.pos_emb_in != nullptr) {
-        const int d_model = cm->hparams.enc_d_model;
-        const int pos_len = static_cast<int>(eb.pos_emb_in->ne[1]);
-        const int T_enc   = (pos_len + 1) / 2;
+        const int          d_model = cm->hparams.enc_d_model;
+        const int          pos_len = static_cast<int>(eb.pos_emb_in->ne[1]);
+        const int          T_enc   = (pos_len + 1) / 2;
         std::vector<float> pos_buf(static_cast<size_t>(pos_len) * d_model, 0.0f);
-        const float ln_10000 = std::log(10000.0f);
+        const float        ln_10000 = std::log(10000.0f);
         std::vector<float> div_term(static_cast<size_t>(d_model / 2));
-        for (int k = 0; k < d_model / 2; ++k)
-            div_term[k] = std::exp(static_cast<float>(2 * k) *
-                                   (-ln_10000 / static_cast<float>(d_model)));
+        for (int k = 0; k < d_model / 2; ++k) {
+            div_term[k] = std::exp(static_cast<float>(2 * k) * (-ln_10000 / static_cast<float>(d_model)));
+        }
         for (int i = 0; i < pos_len; ++i) {
-            const float p = static_cast<float>((T_enc - 1) - i);
-            float * row = pos_buf.data() + static_cast<size_t>(i) * d_model;
+            const float p   = static_cast<float>((T_enc - 1) - i);
+            float *     row = pos_buf.data() + static_cast<size_t>(i) * d_model;
             for (int k = 0; k < d_model / 2; ++k) {
                 row[2 * k]     = std::sin(p * div_term[k]);
                 row[2 * k + 1] = std::cos(p * div_term[k]);
             }
         }
-        ggml_backend_tensor_set(eb.pos_emb_in, pos_buf.data(), 0,
-                                pos_buf.size() * sizeof(float));
+        ggml_backend_tensor_set(eb.pos_emb_in, pos_buf.data(), 0, pos_buf.size() * sizeof(float));
     }
 
     transcribe::configure_sched_n_threads(cc->sched, cc->n_threads);
 
     const int64_t t0 = ggml_time_us();
-    if (ggml_backend_sched_graph_compute(cc->sched, eb.graph) != GGML_STATUS_SUCCESS)
+    if (ggml_backend_sched_graph_compute(cc->sched, eb.graph) != GGML_STATUS_SUCCESS) {
         return TRANSCRIBE_ERR_GGUF;
+    }
     enc_us += ggml_time_us() - t0;
 
     const int d_dec = static_cast<int>(eb.out->ne[0]);
     const int T_enc = static_cast<int>(eb.out->ne[1]);
-    if (d_dec <= 0 || T_enc <= 0) return TRANSCRIBE_ERR_GGUF;
+    if (d_dec <= 0 || T_enc <= 0) {
+        return TRANSCRIBE_ERR_GGUF;
+    }
     enc_host_out.resize(static_cast<size_t>(d_dec) * T_enc);
-    ggml_backend_tensor_get(eb.out, enc_host_out.data(), 0,
-                            enc_host_out.size() * sizeof(float));
+    ggml_backend_tensor_get(eb.out, enc_host_out.data(), 0, enc_host_out.size() * sizeof(float));
     T_enc_out = T_enc;
     return TRANSCRIBE_OK;
 }
 
-transcribe_status run_batch_serial(CanarySession * cc,
-                                   const float * const * pcm,
-                                   const int * n_samples, int n,
+transcribe_status run_batch_serial(CanarySession *               cc,
+                                   const float * const *         pcm,
+                                   const int *                   n_samples,
+                                   int                           n,
                                    const transcribe_run_params * params) {
     for (int i = 0; i < n; ++i) {
-        if (cc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
-        const transcribe_status st =
-            (pcm[i] == nullptr || n_samples[i] <= 0)
-                ? TRANSCRIBE_ERR_INVALID_ARG
-                : run(cc, pcm[i], n_samples[i], params);
+        if (cc->poll_abort()) {
+            return TRANSCRIBE_ERR_ABORTED;
+        }
+        const transcribe_status st = (pcm[i] == nullptr || n_samples[i] <= 0) ? TRANSCRIBE_ERR_INVALID_ARG :
+                                                                                run(cc, pcm[i], n_samples[i], params);
         if (st == TRANSCRIBE_OK) {
             cc->batch_results.push_back(cc->capture_result(st));
         } else {
-            transcribe_session::ResultSet rs; rs.status = st;
+            transcribe_session::ResultSet rs;
+            rs.status = st;
             cc->batch_results.push_back(std::move(rs));
         }
     }
     return TRANSCRIBE_OK;
 }
 
-transcribe_status run_batch(
-    transcribe_session *          session,
-    const float * const *         pcm,
-    const int *                   n_samples,
-    int                           n,
-    const transcribe_run_params * params)
-{
-    if (session == nullptr || pcm == nullptr || n_samples == nullptr || n <= 0)
+transcribe_status run_batch(transcribe_session *          session,
+                            const float * const *         pcm,
+                            const int *                   n_samples,
+                            int                           n,
+                            const transcribe_run_params * params) {
+    if (session == nullptr || pcm == nullptr || n_samples == nullptr || n <= 0) {
         return TRANSCRIBE_ERR_INVALID_ARG;
+    }
     auto * cc = static_cast<CanarySession *>(session);
     auto * cm = static_cast<CanaryModel *>(cc->model);
-    if (cm == nullptr || cm->plan.scheduler_list.empty() || !cm->mel.has_value())
+    if (cm == nullptr || cm->plan.scheduler_list.empty() || !cm->mel.has_value()) {
         return TRANSCRIBE_ERR_INVALID_ARG;
+    }
 
-    const bool primary_is_gpu =
-        cm->plan.primary_kind != transcribe::BackendKind::Cpu &&
-        cm->plan.primary_kind != transcribe::BackendKind::Accel &&
-        cm->plan.primary_kind != transcribe::BackendKind::Unknown;
-    if (n == 1 || !cc->decoder_use_flash || !primary_is_gpu ||
-        transcribe::debug::enabled())
+    const bool primary_is_gpu = cm->plan.primary_kind != transcribe::BackendKind::Cpu &&
+                                cm->plan.primary_kind != transcribe::BackendKind::Accel &&
+                                cm->plan.primary_kind != transcribe::BackendKind::Unknown;
+    if (n == 1 || !cc->decoder_use_flash || !primary_is_gpu || transcribe::debug::enabled()) {
         return run_batch_serial(cc, pcm, n_samples, n, params);
+    }
 
     transcribe::debug::init();
-    const auto & hp = cm->hparams;
-    const int hidden  = hp.dec_d_model;
-    const int n_layer = hp.dec_n_layers;
+    const auto & hp      = cm->hparams;
+    const int    hidden  = hp.dec_d_model;
+    const int    n_layer = hp.dec_n_layers;
 
     // Shared multitask prompt (identical across the batch).
-    const char * lang = (params && params->language) ? params->language : "en";
-    const bool is_translate =
-        (params != nullptr && params->task == TRANSCRIBE_TASK_TRANSLATE);
-    const char * tgt_lang = lang;
-    if (is_translate && params && params->target_language) tgt_lang = params->target_language;
-    const char * task = is_translate ? "translate" : "asr";
-    const int src_id = find_language_id(hp, lang);
-    const int tgt_id = find_language_id(hp, tgt_lang);
-    if (src_id < 0 || tgt_id < 0) return TRANSCRIBE_ERR_UNSUPPORTED_LANGUAGE;
+    const char * lang         = (params && params->language) ? params->language : "en";
+    const bool   is_translate = (params != nullptr && params->task == TRANSCRIBE_TASK_TRANSLATE);
+    const char * tgt_lang     = lang;
+    if (is_translate && params && params->target_language) {
+        tgt_lang = params->target_language;
+    }
+    const char * task   = is_translate ? "translate" : "asr";
+    const int    src_id = find_language_id(hp, lang);
+    const int    tgt_id = find_language_id(hp, tgt_lang);
+    if (src_id < 0 || tgt_id < 0) {
+        return TRANSCRIBE_ERR_UNSUPPORTED_LANGUAGE;
+    }
     if (is_translate && !translation_pair_allowed(hp, lang, tgt_lang)) {
         return TRANSCRIBE_ERR_UNSUPPORTED_LANGUAGE;
     }
     bool pnc = true;
-    if (params != nullptr && params->pnc == TRANSCRIBE_PNC_MODE_OFF) pnc = false;
+    if (params != nullptr && params->pnc == TRANSCRIBE_PNC_MODE_OFF) {
+        pnc = false;
+    }
     std::vector<int32_t> prompt_ids;
-    if (hp.prompt_format == "canary2")
+    if (hp.prompt_format == "canary2") {
         prompt_ids = build_prompt_canary2(*cm, hp, src_id, tgt_id, task, pnc);
-    else if (hp.prompt_format == "canary")
+    } else if (hp.prompt_format == "canary") {
         prompt_ids = build_prompt_canary(hp, src_id, tgt_id, task, pnc);
-    if (prompt_ids.empty()) return TRANSCRIBE_ERR_INVALID_ARG;
+    }
+    if (prompt_ids.empty()) {
+        return TRANSCRIBE_ERR_INVALID_ARG;
+    }
     const int prompt_len = static_cast<int>(prompt_ids.size());
 
     // Pass 0: parallel mel.
-    std::vector<char> valid(n, 0);
+    std::vector<char>               valid(n, 0);
     std::vector<std::vector<float>> mel_bufs(n);
-    std::vector<int> mel_nf(n, 0);
-    int n_threads = cc->n_threads;
-    if (n_threads <= 0) n_threads = transcribe::default_n_threads();
-    int64_t mel_us = 0, enc_us = 0;
+    std::vector<int>                mel_nf(n, 0);
+    int                             n_threads = cc->n_threads;
+    if (n_threads <= 0) {
+        n_threads = transcribe::default_n_threads();
+    }
+    int64_t       mel_us = 0, enc_us = 0;
     const int64_t t_mel0 = ggml_time_us();
     transcribe::parallel_for_all(n, n_threads, [&](int b) {
-        if (pcm[b] == nullptr || n_samples[b] <= 0) return true;
+        if (pcm[b] == nullptr || n_samples[b] <= 0) {
+            return true;
+        }
         int nm = 0, nf = 0;
-        if (cm->mel->compute(pcm[b], static_cast<size_t>(n_samples[b]),
-                             mel_bufs[b], nm, nf, /*n_threads=*/1) == TRANSCRIBE_OK
-            && nf > 0) { mel_nf[b] = nf; valid[b] = 1; }
+        if (cm->mel->compute(pcm[b], static_cast<size_t>(n_samples[b]), mel_bufs[b], nm, nf, /*n_threads=*/1) ==
+                TRANSCRIBE_OK &&
+            nf > 0) {
+            mel_nf[b] = nf;
+            valid[b]  = 1;
+        }
         return true;
     });
     mel_us += ggml_time_us() - t_mel0;
@@ -1590,78 +1568,92 @@ transcribe_status run_batch(
     // Pass 1: serial per-utterance encoder. Per-utterance input-length gate
     // (same enc_pos_emb_max_len limit as run()); an over-length utterance is
     // marked invalid with INPUT_TOO_LONG so the rest of the batch still decodes.
-    std::vector<transcribe_status> reject_status(n, TRANSCRIBE_ERR_INVALID_ARG);
+    std::vector<transcribe_status>  reject_status(n, TRANSCRIBE_ERR_INVALID_ARG);
     std::vector<std::vector<float>> enc_hosts(n);
-    std::vector<int> T_enc(n, 0);
-    int T_enc_max = 0;
+    std::vector<int>                T_enc(n, 0);
+    int                             T_enc_max = 0;
     for (int b = 0; b < n; ++b) {
-        if (cc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
-        if (!valid[b]) continue;
+        if (cc->poll_abort()) {
+            return TRANSCRIBE_ERR_ABORTED;
+        }
+        if (!valid[b]) {
+            continue;
+        }
         if (cm->hparams.enc_pos_emb_max_len > 0) {
-            const int t_enc_pred = canary_predict_t_enc(
-                mel_nf[b], cm->hparams.enc_subsampling_factor);
+            const int t_enc_pred = canary_predict_t_enc(mel_nf[b], cm->hparams.enc_subsampling_factor);
             if (t_enc_pred > cm->hparams.enc_pos_emb_max_len) {
-                const double max_s =
-                    static_cast<double>(cm->caps.max_audio_ms) / 1000.0;
-                transcribe::log_msg(
-                    TRANSCRIBE_LOG_LEVEL_ERROR,
-                    "canary run_batch: utterance %d too long — %d encoder frames "
-                    "exceed the %d the model supports (~%.0f s max). See "
-                    "transcribe_capabilities.max_audio_ms.",
-                    b, t_enc_pred, cm->hparams.enc_pos_emb_max_len, max_s);
+                const double max_s = static_cast<double>(cm->caps.max_audio_ms) / 1000.0;
+                transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
+                                    "canary run_batch: utterance %d too long — %d encoder frames "
+                                    "exceed the %d the model supports (~%.0f s max). See "
+                                    "transcribe_capabilities.max_audio_ms.",
+                                    b, t_enc_pred, cm->hparams.enc_pos_emb_max_len, max_s);
                 reject_status[b] = TRANSCRIBE_ERR_INPUT_TOO_LONG;
-                valid[b] = 0;
+                valid[b]         = 0;
                 continue;
             }
         }
-        if (encode_one_to_host(cc, cm, mel_bufs[b], mel_nf[b],
-                               enc_hosts[b], T_enc[b], enc_us) != TRANSCRIBE_OK
-            || T_enc[b] <= 0) { valid[b] = 0; continue; }
+        if (encode_one_to_host(cc, cm, mel_bufs[b], mel_nf[b], enc_hosts[b], T_enc[b], enc_us) != TRANSCRIBE_OK ||
+            T_enc[b] <= 0) {
+            valid[b] = 0;
+            continue;
+        }
         T_enc_max = std::max(T_enc_max, T_enc[b]);
     }
     if (T_enc_max <= 0) {
         for (int b = 0; b < n; ++b) {
-            transcribe_session::ResultSet rs; rs.status = reject_status[b];
+            transcribe_session::ResultSet rs;
+            rs.status = reject_status[b];
             cc->batch_results.push_back(std::move(rs));
         }
         return TRANSCRIBE_OK;
     }
 
     // Batched KV cache.
-    const int max_new = 512;
-    int max_n_kv = 1024;
-    while (max_n_kv < prompt_len + max_new) max_n_kv *= 2;
+    const int max_new  = 512;
+    int       max_n_kv = 1024;
+    while (max_n_kv < prompt_len + max_new) {
+        max_n_kv *= 2;
+    }
     // Decoder self-KV ceiling: dec_max_position, optionally lowered (never
     // raised) by the caller's n_ctx knob. Default knob (0) leaves it at
     // dec_max_position, so in-spec batched decode is unchanged.
     const int n_ctx_cap = canary_context_ceiling(cc->n_ctx, hp);
-    if (max_n_kv > n_ctx_cap) max_n_kv = n_ctx_cap;
+    if (max_n_kv > n_ctx_cap) {
+        max_n_kv = n_ctx_cap;
+    }
 
-    ggml_type kv_type = (cc->kv_type == TRANSCRIBE_KV_TYPE_F32)
-                      ? GGML_TYPE_F32 : GGML_TYPE_F16;
+    ggml_type kv_type = (cc->kv_type == TRANSCRIBE_KV_TYPE_F32) ? GGML_TYPE_F32 : GGML_TYPE_F16;
     if (cc->kv_cache.buffer != nullptr &&
-        (cc->kv_cache.n_batch != n || cc->kv_cache.T_enc != T_enc_max ||
-         cc->kv_cache.n_ctx != max_n_kv))
+        (cc->kv_cache.n_batch != n || cc->kv_cache.T_enc != T_enc_max || cc->kv_cache.n_ctx != max_n_kv)) {
         cc->kv_cache.free();
+    }
     if (cc->kv_cache.buffer == nullptr) {
-        if (!kv_cache_init_batched(cc->kv_cache, cm->plan.primary,
-                                   max_n_kv, T_enc_max, hidden, n_layer, n, kv_type)) {
+        if (!kv_cache_init_batched(cc->kv_cache, cm->plan.primary, max_n_kv, T_enc_max, hidden, n_layer, n, kv_type)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "canary run_batch: batched KV cache allocation failed "
-                "(n_ctx=%d, T_enc=%d, %d d_model x %d layers x %d batch) — "
-                "out of memory.",
-                max_n_kv, T_enc_max, hidden, n_layer, n);
+                                "canary run_batch: batched KV cache allocation failed "
+                                "(n_ctx=%d, T_enc=%d, %d d_model x %d layers x %d batch) — "
+                                "out of memory.",
+                                max_n_kv, T_enc_max, hidden, n_layer, n);
             return TRANSCRIBE_ERR_OOM;
         }
     } else {
         ggml_backend_buffer_clear(cc->kv_cache.buffer, 0);
-        cc->kv_cache.n = 0; cc->kv_cache.head = 0; cc->kv_cache.cross_populated = false;
+        cc->kv_cache.n               = 0;
+        cc->kv_cache.head            = 0;
+        cc->kv_cache.cross_populated = false;
     }
 
     auto new_compute_ctx = [&](size_t mem) -> bool {
-        if (cc->compute_ctx != nullptr) { ggml_free(cc->compute_ctx); cc->compute_ctx = nullptr; }
+        if (cc->compute_ctx != nullptr) {
+            ggml_free(cc->compute_ctx);
+            cc->compute_ctx = nullptr;
+        }
         cc->encoder_out = nullptr;
-        ggml_init_params ip {}; ip.mem_size = mem; ip.mem_buffer = nullptr; ip.no_alloc = true;
+        ggml_init_params ip{};
+        ip.mem_size     = mem;
+        ip.mem_buffer   = nullptr;
+        ip.no_alloc     = true;
         cc->compute_ctx = ggml_init(ip);
         return cc->compute_ctx != nullptr;
     };
@@ -1672,31 +1664,33 @@ transcribe_status run_batch(
     {
         if (!new_compute_ctx(8 * 1024 * 1024)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "canary run_batch: cross-KV compute context allocation failed — "
-                "out of memory.");
+                                "canary run_batch: cross-KV compute context allocation failed — "
+                                "out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
-        DecoderBuild cross = build_cross_kv_graph_batched(
-            cc->compute_ctx, cm->weights, hp, cc->kv_cache, T_enc_max, n);
-        if (cross.graph == nullptr) return TRANSCRIBE_ERR_GGUF;
+        DecoderBuild cross = build_cross_kv_graph_batched(cc->compute_ctx, cm->weights, hp, cc->kv_cache, T_enc_max, n);
+        if (cross.graph == nullptr) {
+            return TRANSCRIBE_ERR_GGUF;
+        }
         ggml_backend_sched_reset(cc->sched);
         if (!ggml_backend_sched_alloc_graph(cc->sched, cross.graph)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "canary run_batch: cross-KV graph allocation failed — "
-                "out of memory.");
+                                "canary run_batch: cross-KV graph allocation failed — "
+                                "out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
         std::vector<float> packed(static_cast<size_t>(hidden) * T_enc_max * n, 0.0f);
         for (int b = 0; b < n; ++b) {
-            if (!valid[b]) continue;
-            std::memcpy(packed.data() + static_cast<size_t>(b) * T_enc_max * hidden,
-                        enc_hosts[b].data(),
+            if (!valid[b]) {
+                continue;
+            }
+            std::memcpy(packed.data() + static_cast<size_t>(b) * T_enc_max * hidden, enc_hosts[b].data(),
                         static_cast<size_t>(hidden) * T_enc[b] * sizeof(float));
         }
-        ggml_backend_tensor_set(cross.encoder_out_in, packed.data(), 0,
-                                packed.size() * sizeof(float));
-        if (ggml_backend_sched_graph_compute(cc->sched, cross.graph) != GGML_STATUS_SUCCESS)
+        ggml_backend_tensor_set(cross.encoder_out_in, packed.data(), 0, packed.size() * sizeof(float));
+        if (ggml_backend_sched_graph_compute(cc->sched, cross.graph) != GGML_STATUS_SUCCESS) {
             return TRANSCRIBE_ERR_GGUF;
+        }
         cc->kv_cache.cross_populated = true;
     }
 
@@ -1706,29 +1700,38 @@ transcribe_status run_batch(
     // mask, O(log) rebuilds; KV cache persists, capacity max_n_kv unchanged).
     const ggml_fp16_t f16_zero = ggml_fp32_to_fp16(0.0f);
     const ggml_fp16_t f16_ninf = ggml_fp32_to_fp16(-INFINITY);
-    const int32_t eos_id = hp.eos_token_id;
+    const int32_t     eos_id   = hp.eos_token_id;
 
     std::vector<ggml_fp16_t> cmask(static_cast<size_t>(T_enc_max) * n, f16_ninf);
     for (int b = 0; b < n; ++b) {
-        const int real = valid[b] ? T_enc[b] : 1;
+        const int     real = valid[b] ? T_enc[b] : 1;
         ggml_fp16_t * base = cmask.data() + static_cast<size_t>(b) * T_enc_max;
         std::fill(base, base + std::min(real, T_enc_max), f16_zero);
     }
 
     int init_window = 64;
-    while (init_window > max_n_kv) init_window /= 2;
-    if (init_window < 1) init_window = max_n_kv;
-
-    StepBuildBatched sb {};
-    auto rebuild = [&](int win, transcribe::EncDecStepIO & io) -> bool {
-        if (!new_compute_ctx(16 * 1024 * 1024)) return false;
-        sb = build_step_graph_batched(cc->compute_ctx, cm->weights, hp,
-                                      cc->kv_cache, win, T_enc_max, n, cc->decoder_use_flash);
-        if (sb.graph == nullptr || sb.argmax_out == nullptr) return false;
+    while (init_window > max_n_kv) {
+        init_window /= 2;
+    }
+    if (init_window < 1) {
+        init_window = max_n_kv;
+    }
+
+    StepBuildBatched sb{};
+    auto             rebuild = [&](int win, transcribe::EncDecStepIO & io) -> bool {
+        if (!new_compute_ctx(16 * 1024 * 1024)) {
+            return false;
+        }
+        sb = build_step_graph_batched(cc->compute_ctx, cm->weights, hp, cc->kv_cache, win, T_enc_max, n,
+                                      cc->decoder_use_flash);
+        if (sb.graph == nullptr || sb.argmax_out == nullptr) {
+            return false;
+        }
         ggml_backend_sched_reset(cc->sched);
-        if (!ggml_backend_sched_alloc_graph(cc->sched, sb.graph)) return false;
-        ggml_backend_tensor_set(sb.cross_mask_in, cmask.data(), 0,
-                                cmask.size() * sizeof(ggml_fp16_t));
+        if (!ggml_backend_sched_alloc_graph(cc->sched, sb.graph)) {
+            return false;
+        }
+        ggml_backend_tensor_set(sb.cross_mask_in, cmask.data(), 0, cmask.size() * sizeof(ggml_fp16_t));
         io.token_ids = sb.token_ids_in;
         io.pos_ids   = sb.pos_ids_in;
         io.kv_idx    = sb.kv_idx_in;
@@ -1739,10 +1742,9 @@ transcribe_status run_batch(
     };
 
     std::vector<std::vector<int32_t>> generated(n);
-    std::vector<char> truncated;
+    std::vector<char>                 truncated;
     if (const transcribe_status st = transcribe::run_batched_encdec_step_loop(
-            cc, cc->sched, rebuild, prompt_ids, prompt_len, init_window,
-            max_new, max_n_kv, eos_id, n, valid, generated,
+            cc, cc->sched, rebuild, prompt_ids, prompt_len, init_window, max_new, max_n_kv, eos_id, n, valid, generated,
             /*n_steps_out=*/nullptr, &truncated);
         st != TRANSCRIBE_OK) {
         return st;
@@ -1750,38 +1752,47 @@ transcribe_status run_batch(
     const int64_t dec_us = ggml_time_us() - t_dec0;
 
     // Capture (strip control tokens like serial commit_result).
-    const bool strip = (params == nullptr) ? true : !params->keep_special_tags;
-    const int valid_count = std::max(1, static_cast<int>(
-        std::count(valid.begin(), valid.end(), char(1))));
+    const bool strip       = (params == nullptr) ? true : !params->keep_special_tags;
+    const int  valid_count = std::max(1, static_cast<int>(std::count(valid.begin(), valid.end(), char(1))));
     for (int b = 0; b < n; ++b) {
         transcribe_session::ResultSet rs;
-        if (!valid[b]) { rs.status = reject_status[b];
-                         cc->batch_results.push_back(std::move(rs)); continue; }
+        if (!valid[b]) {
+            rs.status = reject_status[b];
+            cc->batch_results.push_back(std::move(rs));
+            continue;
+        }
         std::vector<int> text_ids;
         if (strip) {
-            for (int id : generated[b]) if (!cm->tok.is_control(id)) text_ids.push_back(id);
+            for (int id : generated[b]) {
+                if (!cm->tok.is_control(id)) {
+                    text_ids.push_back(id);
+                }
+            }
         } else {
             text_ids.assign(generated[b].begin(), generated[b].end());
         }
-        std::string full = cm->tok.decode(text_ids.data(),
-                                          static_cast<int>(text_ids.size()));
-        if (!full.empty() && full.front() == ' ') full.erase(full.begin());
-        transcribe_session::SegmentEntry seg {};
-        seg.t0_ms = 0; seg.t1_ms = 0; seg.text = full;
+        std::string full = cm->tok.decode(text_ids.data(), static_cast<int>(text_ids.size()));
+        if (!full.empty() && full.front() == ' ') {
+            full.erase(full.begin());
+        }
+        transcribe_session::SegmentEntry seg{};
+        seg.t0_ms = 0;
+        seg.t1_ms = 0;
+        seg.text  = full;
         rs.segments.push_back(std::move(seg));
-        rs.full_text = full;
+        rs.full_text   = full;
         rs.result_kind = TRANSCRIBE_TIMESTAMPS_NONE;
-        rs.has_result = true; rs.status = TRANSCRIBE_OK;
+        rs.has_result  = true;
+        rs.status      = TRANSCRIBE_OK;
         // Per-utterance truncation parity with the single-shot path: a valid row
         // that hit the generation budget / context window before eos reports
         // TRANSCRIBE_ERR_OUTPUT_TRUNCATED (partial transcript retained). Only
         // override an otherwise-OK status — never a worse one.
-        if (rs.status == TRANSCRIBE_OK &&
-            b < static_cast<int>(truncated.size()) && truncated[b]) {
+        if (rs.status == TRANSCRIBE_OK && b < static_cast<int>(truncated.size()) && truncated[b]) {
             cc->was_truncated = true;
-            rs.status = TRANSCRIBE_ERR_OUTPUT_TRUNCATED;
+            rs.status         = TRANSCRIBE_ERR_OUTPUT_TRUNCATED;
         }
-        rs.t_mel_us = mel_us / valid_count;
+        rs.t_mel_us    = mel_us / valid_count;
         rs.t_encode_us = enc_us / valid_count;
         rs.t_decode_us = dec_us / valid_count;
         cc->batch_results.push_back(std::move(rs));
@@ -1789,15 +1800,14 @@ transcribe_status run_batch(
 
     if (transcribe::env::flag("TRANSCRIBE_PERF_DEBUG")) {
         log_msg(TRANSCRIBE_LOG_LEVEL_DEBUG,
-            "canary run_batch: n=%d T_enc_max=%d kv_cap=%d prompt=%d\n"
-            "  mel=%.1fms (parallel)  enc=%.1fms (serial x%d)  decode=%.1fms (batched)",
-            n, T_enc_max, max_n_kv, prompt_len,
-            mel_us / 1000.0, enc_us / 1000.0, n, dec_us / 1000.0);
+                "canary run_batch: n=%d T_enc_max=%d kv_cap=%d prompt=%d\n"
+                "  mel=%.1fms (parallel)  enc=%.1fms (serial x%d)  decode=%.1fms (batched)",
+                n, T_enc_max, max_n_kv, prompt_len, mel_us / 1000.0, enc_us / 1000.0, n, dec_us / 1000.0);
     }
     return TRANSCRIBE_OK;
 }
 
-} // namespace
+}  // namespace
 
 extern const Arch arch = {
     /* .name             = */ "canary",
@@ -1813,4 +1823,4 @@ extern const Arch arch = {
     /* .accepts_ext_kind = */ nullptr,
 };
 
-} // namespace transcribe::canary
+}  // namespace transcribe::canary
diff --git a/src/arch/canary/weights.cpp b/src/arch/canary/weights.cpp
index c8d7fac1..11d1d2a9 100644
--- a/src/arch/canary/weights.cpp
+++ b/src/arch/canary/weights.cpp
@@ -5,12 +5,11 @@
 
 #include "weights.h"
 
-#include "transcribe-meta.h"
-#include "transcribe-weights-util.h"
-#include "transcribe-log.h"
-
 #include "ggml.h"
 #include "gguf.h"
+#include "transcribe-log.h"
+#include "transcribe-meta.h"
+#include "transcribe-weights-util.h"
 
 #include <cstdio>
 #include <cstring>
@@ -23,49 +22,117 @@ namespace {
 constexpr const char * kFamilyTag = "canary";
 
 KvResult read_token_id_required(const gguf_context * gguf, const char * key, int32_t & out) {
-    int v = -1;
+    int  v = -1;
     auto r = read_token_id_kv(gguf, key, v);
-    if (r == KvResult::Ok) out = v;
+    if (r == KvResult::Ok) {
+        out = v;
+    }
     return r;
 }
 
-} // namespace
+}  // namespace
 
-transcribe_status read_canary_hparams(const gguf_context * gguf,
-                                      CanaryHParams &      hp)
-{
+transcribe_status read_canary_hparams(const gguf_context * gguf, CanaryHParams & hp) {
     if (gguf == nullptr) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
 
-    if (auto st = read_required_u32_kv(gguf, "stt.canary.encoder.n_layers",            kFamilyTag, hp.enc_n_layers);             st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.canary.encoder.d_model",             kFamilyTag, hp.enc_d_model);              st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.canary.encoder.n_heads",             kFamilyTag, hp.enc_n_heads);              st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.canary.encoder.d_ff",                kFamilyTag, hp.enc_d_ff);                 st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.canary.encoder.conv_kernel",         kFamilyTag, hp.enc_conv_kernel);          st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.canary.encoder.subsampling_factor",  kFamilyTag, hp.enc_subsampling_factor);   st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.canary.encoder.subsampling_channels",kFamilyTag, hp.enc_subsampling_channels); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.canary.encoder.pos_emb_max_len",     kFamilyTag, hp.enc_pos_emb_max_len);      st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_bool_kv(gguf, "stt.canary.encoder.use_bias",           kFamilyTag, false, hp.enc_use_bias);      st != TRANSCRIBE_OK) return st;
-
-    if (auto st = read_required_u32_kv(gguf, "stt.canary.decoder.n_layers",       kFamilyTag, hp.dec_n_layers);    st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.canary.decoder.d_model",        kFamilyTag, hp.dec_d_model);     st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.canary.decoder.n_heads",        kFamilyTag, hp.dec_n_heads);     st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.canary.decoder.d_ff",           kFamilyTag, hp.dec_d_ff);        st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.canary.decoder.max_position",   kFamilyTag, hp.dec_max_position); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.canary.decoder.vocab_size",     kFamilyTag, hp.dec_vocab_size);  st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.canary.decoder.activation", kFamilyTag, hp.dec_activation);    st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_bool_kv(gguf, "stt.canary.decoder.pre_ln",        kFamilyTag, true,  hp.dec_pre_ln); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_bool_kv(gguf, "stt.canary.decoder.learn_positional_encodings", kFamilyTag, false, hp.dec_learn_positional_encodings); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_bool_kv(gguf, "stt.canary.decoder.encoder_decoder_proj", kFamilyTag, false, hp.dec_has_encoder_decoder_proj); st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_u32_kv(gguf, "stt.canary.encoder.n_layers", kFamilyTag, hp.enc_n_layers);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.canary.encoder.d_model", kFamilyTag, hp.enc_d_model);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.canary.encoder.n_heads", kFamilyTag, hp.enc_n_heads);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.canary.encoder.d_ff", kFamilyTag, hp.enc_d_ff); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.canary.encoder.conv_kernel", kFamilyTag, hp.enc_conv_kernel);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st =
+            read_required_u32_kv(gguf, "stt.canary.encoder.subsampling_factor", kFamilyTag, hp.enc_subsampling_factor);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.canary.encoder.subsampling_channels", kFamilyTag,
+                                       hp.enc_subsampling_channels);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.canary.encoder.pos_emb_max_len", kFamilyTag, hp.enc_pos_emb_max_len);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_bool_kv(gguf, "stt.canary.encoder.use_bias", kFamilyTag, false, hp.enc_use_bias);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+
+    if (auto st = read_required_u32_kv(gguf, "stt.canary.decoder.n_layers", kFamilyTag, hp.dec_n_layers);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.canary.decoder.d_model", kFamilyTag, hp.dec_d_model);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.canary.decoder.n_heads", kFamilyTag, hp.dec_n_heads);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.canary.decoder.d_ff", kFamilyTag, hp.dec_d_ff); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.canary.decoder.max_position", kFamilyTag, hp.dec_max_position);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.canary.decoder.vocab_size", kFamilyTag, hp.dec_vocab_size);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_string_kv(gguf, "stt.canary.decoder.activation", kFamilyTag, hp.dec_activation);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_bool_kv(gguf, "stt.canary.decoder.pre_ln", kFamilyTag, true, hp.dec_pre_ln);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_bool_kv(gguf, "stt.canary.decoder.learn_positional_encodings", kFamilyTag, false,
+                                        hp.dec_learn_positional_encodings);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_bool_kv(gguf, "stt.canary.decoder.encoder_decoder_proj", kFamilyTag, false,
+                                        hp.dec_has_encoder_decoder_proj);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Multitask prompt + special tokens.
-    if (auto st = read_required_string_kv(gguf, "stt.canary.tokenizer.prompt_format", kFamilyTag, hp.prompt_format); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_bool_kv(gguf, "stt.canary.tokenizer.single_sp",  kFamilyTag, false, hp.tokenizer_single_sp); st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_string_kv(gguf, "stt.canary.tokenizer.prompt_format", kFamilyTag, hp.prompt_format);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st =
+            read_optional_bool_kv(gguf, "stt.canary.tokenizer.single_sp", kFamilyTag, false, hp.tokenizer_single_sp);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     auto require_special = [&](const char * key, int32_t & out) -> transcribe_status {
         const auto r = read_token_id_required(gguf, key, out);
-        if (r == KvResult::Ok)      return TRANSCRIBE_OK;
+        if (r == KvResult::Ok) {
+            return TRANSCRIBE_OK;
+        }
         if (r == KvResult::Absent) {
             log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: required special-token KV missing: %s", kFamilyTag, key);
             return TRANSCRIBE_ERR_GGUF;
@@ -74,32 +141,69 @@ transcribe_status read_canary_hparams(const gguf_context * gguf,
         return TRANSCRIBE_ERR_GGUF;
     };
 
-    if (auto st = require_special("stt.canary.special.startoftranscript_id", hp.startoftranscript_id); st != TRANSCRIBE_OK) return st;
-    if (auto st = require_special("stt.canary.special.endoftext_id",         hp.endoftext_id);         st != TRANSCRIBE_OK) return st;
-    if (auto st = require_special("stt.canary.special.pad_id",               hp.pad_special_id);      st != TRANSCRIBE_OK) return st;
+    if (auto st = require_special("stt.canary.special.startoftranscript_id", hp.startoftranscript_id);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = require_special("stt.canary.special.endoftext_id", hp.endoftext_id); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = require_special("stt.canary.special.pad_id", hp.pad_special_id); st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Optional task tokens — present on canary2 variants, may be missing on canary-1b.
     auto opt_special = [&](const char * key, int32_t & out) -> transcribe_status {
         const auto r = read_token_id_required(gguf, key, out);
-        if (r == KvResult::Ok || r == KvResult::Absent) return TRANSCRIBE_OK;
+        if (r == KvResult::Ok || r == KvResult::Absent) {
+            return TRANSCRIBE_OK;
+        }
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: optional special-token KV %s has wrong type", kFamilyTag, key);
         return TRANSCRIBE_ERR_GGUF;
     };
 
-    if (auto st = opt_special("stt.canary.special.startofcontext_id", hp.startofcontext_id);  st != TRANSCRIBE_OK) return st;
-    if (auto st = opt_special("stt.canary.special.nospeech_id",       hp.nospeech_id);        st != TRANSCRIBE_OK) return st;
-    if (auto st = opt_special("stt.canary.special.pnc_id",            hp.pnc_id);             st != TRANSCRIBE_OK) return st;
-    if (auto st = opt_special("stt.canary.special.nopnc_id",          hp.nopnc_id);           st != TRANSCRIBE_OK) return st;
-    if (auto st = opt_special("stt.canary.special.itn_id",            hp.itn_id);             st != TRANSCRIBE_OK) return st;
-    if (auto st = opt_special("stt.canary.special.noitn_id",          hp.noitn_id);           st != TRANSCRIBE_OK) return st;
-    if (auto st = opt_special("stt.canary.special.timestamp_id",      hp.timestamp_id);       st != TRANSCRIBE_OK) return st;
-    if (auto st = opt_special("stt.canary.special.notimestamp_id",    hp.notimestamp_id);     st != TRANSCRIBE_OK) return st;
-    if (auto st = opt_special("stt.canary.special.diarize_id",        hp.diarize_id);         st != TRANSCRIBE_OK) return st;
-    if (auto st = opt_special("stt.canary.special.nodiarize_id",      hp.nodiarize_id);       st != TRANSCRIBE_OK) return st;
-    if (auto st = opt_special("stt.canary.special.spkchange_id",      hp.spkchange_id);       st != TRANSCRIBE_OK) return st;
-    if (auto st = opt_special("stt.canary.special.audioseparator_id", hp.audioseparator_id);  st != TRANSCRIBE_OK) return st;
-    if (auto st = opt_special("stt.canary.special.transcribe_id",     hp.transcribe_id);     st != TRANSCRIBE_OK) return st;
-    if (auto st = opt_special("stt.canary.special.translate_id",      hp.translate_id);      st != TRANSCRIBE_OK) return st;
+    if (auto st = opt_special("stt.canary.special.startofcontext_id", hp.startofcontext_id); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = opt_special("stt.canary.special.nospeech_id", hp.nospeech_id); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = opt_special("stt.canary.special.pnc_id", hp.pnc_id); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = opt_special("stt.canary.special.nopnc_id", hp.nopnc_id); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = opt_special("stt.canary.special.itn_id", hp.itn_id); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = opt_special("stt.canary.special.noitn_id", hp.noitn_id); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = opt_special("stt.canary.special.timestamp_id", hp.timestamp_id); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = opt_special("stt.canary.special.notimestamp_id", hp.notimestamp_id); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = opt_special("stt.canary.special.diarize_id", hp.diarize_id); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = opt_special("stt.canary.special.nodiarize_id", hp.nodiarize_id); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = opt_special("stt.canary.special.spkchange_id", hp.spkchange_id); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = opt_special("stt.canary.special.audioseparator_id", hp.audioseparator_id); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = opt_special("stt.canary.special.transcribe_id", hp.transcribe_id); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = opt_special("stt.canary.special.translate_id", hp.translate_id); st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Language list -> language token id table. Two converter shapes for the
     // routing keys: aggregate tokenizers put per-language codes in
@@ -111,8 +215,7 @@ transcribe_status read_canary_hparams(const gguf_context * gguf,
     {
         std::vector<std::string> all_codes;
         std::vector<std::string> tmp;
-        if (read_string_array_kv(gguf, "stt.canary.tokenizer.lang_codes", tmp)
-            == KvResult::Ok) {
+        if (read_string_array_kv(gguf, "stt.canary.tokenizer.lang_codes", tmp) == KvResult::Ok) {
             all_codes.insert(all_codes.end(), tmp.begin(), tmp.end());
         }
         tmp.clear();
@@ -123,13 +226,18 @@ transcribe_status read_canary_hparams(const gguf_context * gguf,
         for (const auto & code : all_codes) {
             bool dup = false;
             for (const auto & s : seen_codes) {
-                if (s == code) { dup = true; break; }
+                if (s == code) {
+                    dup = true;
+                    break;
+                }
+            }
+            if (dup) {
+                continue;
             }
-            if (dup) continue;
             seen_codes.push_back(code);
             std::string key = std::string("stt.canary.special.lang.") + code + "_id";
-            int v = -1;
-            const auto kr = read_token_id_kv(gguf, key.c_str(), v);
+            int         v   = -1;
+            const auto  kr  = read_token_id_kv(gguf, key.c_str(), v);
             if (kr == KvResult::Ok) {
                 hp.languages.push_back(code);
                 hp.language_ids.push_back(v);
@@ -149,96 +257,113 @@ transcribe_status read_canary_hparams(const gguf_context * gguf,
                 hp.translation_pairs = pairs;
                 break;
             case KvResult::BadType:
-                log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                             "%s: stt.translation.pairs wrong type", kFamilyTag);
+                log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: stt.translation.pairs wrong type", kFamilyTag);
                 return TRANSCRIBE_ERR_GGUF;
         }
     }
 
-    if (auto st = read_required_string_kv(gguf, "stt.frontend.type",       kFamilyTag, hp.fe_type);        st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.frontend.num_mels",      kFamilyTag, hp.fe_num_mels);    st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.frontend.sample_rate",   kFamilyTag, hp.fe_sample_rate); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.frontend.n_fft",         kFamilyTag, hp.fe_n_fft);       st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.frontend.win_length",    kFamilyTag, hp.fe_win_length);  st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.frontend.hop_length",    kFamilyTag, hp.fe_hop_length);  st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.frontend.window",     kFamilyTag, hp.fe_window);       st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.frontend.normalize",  kFamilyTag, hp.fe_normalize);    st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf, "stt.frontend.dither",        kFamilyTag, hp.fe_dither);       st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf, "stt.frontend.pre_emphasis",  kFamilyTag, hp.fe_pre_emphasis); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf, "stt.frontend.f_min",         kFamilyTag, hp.fe_f_min);        st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf, "stt.frontend.f_max",         kFamilyTag, hp.fe_f_max);        st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_string_kv(gguf, "stt.frontend.pad_mode",   kFamilyTag, "reflect", hp.fe_pad_mode); st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_string_kv(gguf, "stt.frontend.type", kFamilyTag, hp.fe_type); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.num_mels", kFamilyTag, hp.fe_num_mels);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.sample_rate", kFamilyTag, hp.fe_sample_rate);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.n_fft", kFamilyTag, hp.fe_n_fft); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.win_length", kFamilyTag, hp.fe_win_length);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.hop_length", kFamilyTag, hp.fe_hop_length);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_string_kv(gguf, "stt.frontend.window", kFamilyTag, hp.fe_window); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_string_kv(gguf, "stt.frontend.normalize", kFamilyTag, hp.fe_normalize);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.frontend.dither", kFamilyTag, hp.fe_dither); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.frontend.pre_emphasis", kFamilyTag, hp.fe_pre_emphasis);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.frontend.f_min", kFamilyTag, hp.fe_f_min); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.frontend.f_max", kFamilyTag, hp.fe_f_max); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_string_kv(gguf, "stt.frontend.pad_mode", kFamilyTag, "reflect", hp.fe_pad_mode);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Cross-field invariants.
-    if (hp.enc_n_layers <= 0 || hp.enc_d_model <= 0 || hp.enc_n_heads <= 0 ||
-        hp.enc_d_ff <= 0 || hp.enc_conv_kernel <= 0 ||
-        hp.enc_subsampling_factor <= 0 || hp.enc_subsampling_channels <= 0)
-    {
+    if (hp.enc_n_layers <= 0 || hp.enc_d_model <= 0 || hp.enc_n_heads <= 0 || hp.enc_d_ff <= 0 ||
+        hp.enc_conv_kernel <= 0 || hp.enc_subsampling_factor <= 0 || hp.enc_subsampling_channels <= 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "canary: encoder hparams must be positive");
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.enc_d_model % hp.enc_n_heads != 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "canary: encoder d_model (%d) not divisible by n_heads (%d)",
-                     hp.enc_d_model, hp.enc_n_heads);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "canary: encoder d_model (%d) not divisible by n_heads (%d)",
+                hp.enc_d_model, hp.enc_n_heads);
         return TRANSCRIBE_ERR_GGUF;
     }
-    if (hp.dec_n_layers <= 0 || hp.dec_d_model <= 0 || hp.dec_n_heads <= 0 ||
-        hp.dec_d_ff <= 0 || hp.dec_max_position <= 0 || hp.dec_vocab_size <= 0)
-    {
+    if (hp.dec_n_layers <= 0 || hp.dec_d_model <= 0 || hp.dec_n_heads <= 0 || hp.dec_d_ff <= 0 ||
+        hp.dec_max_position <= 0 || hp.dec_vocab_size <= 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "canary: decoder hparams must be positive");
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.dec_d_model % hp.dec_n_heads != 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "canary: decoder d_model (%d) not divisible by n_heads (%d)",
-                     hp.dec_d_model, hp.dec_n_heads);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "canary: decoder d_model (%d) not divisible by n_heads (%d)",
+                hp.dec_d_model, hp.dec_n_heads);
         return TRANSCRIBE_ERR_GGUF;
     }
-    if (hp.dec_activation != "relu" && hp.dec_activation != "silu" &&
-        hp.dec_activation != "swish")
-    {
+    if (hp.dec_activation != "relu" && hp.dec_activation != "silu" && hp.dec_activation != "swish") {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "canary: unsupported decoder activation \"%s\" "
-                     "(only relu, silu, swish are implemented)",
-                     hp.dec_activation.c_str());
+                "canary: unsupported decoder activation \"%s\" "
+                "(only relu, silu, swish are implemented)",
+                hp.dec_activation.c_str());
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.fe_type != "mel") {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "canary: unsupported frontend type \"%s\" (only \"mel\")",
-                     hp.fe_type.c_str());
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "canary: unsupported frontend type \"%s\" (only \"mel\")",
+                hp.fe_type.c_str());
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.fe_window != "hann") {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "canary: unsupported frontend window \"%s\" (only \"hann\")",
-                     hp.fe_window.c_str());
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "canary: unsupported frontend window \"%s\" (only \"hann\")",
+                hp.fe_window.c_str());
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.fe_normalize != "per_feature") {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "canary: unsupported frontend normalize \"%s\"",
-                     hp.fe_normalize.c_str());
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "canary: unsupported frontend normalize \"%s\"", hp.fe_normalize.c_str());
         return TRANSCRIBE_ERR_GGUF;
     }
     if ((hp.fe_n_fft & (hp.fe_n_fft - 1)) != 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "canary: frontend n_fft (%d) must be a power of 2",
-                     hp.fe_n_fft);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "canary: frontend n_fft (%d) must be a power of 2", hp.fe_n_fft);
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.fe_pad_mode != "reflect" && hp.fe_pad_mode != "constant") {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "canary: unsupported frontend pad_mode \"%s\"",
-                     hp.fe_pad_mode.c_str());
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "canary: unsupported frontend pad_mode \"%s\"", hp.fe_pad_mode.c_str());
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.prompt_format != "canary" && hp.prompt_format != "canary2") {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "canary: unsupported prompt_format \"%s\" "
-                     "(only \"canary\" and \"canary2\")",
-                     hp.prompt_format.c_str());
+                "canary: unsupported prompt_format \"%s\" "
+                "(only \"canary\" and \"canary2\")",
+                hp.prompt_format.c_str());
         return TRANSCRIBE_ERR_GGUF;
     }
 
@@ -255,41 +380,36 @@ using transcribe::weights::lname;
 
 constexpr const char * kTag = kFamilyTag;
 
-#define GET_F32(slot, name, ...) \
-    do { \
-        ggml_tensor * _t = transcribe::weights::find_tensor( \
-            ctx_meta, (name), \
-            {GGML_TYPE_F32}, {__VA_ARGS__}, kTag); \
-        if (_t == nullptr) return TRANSCRIBE_ERR_GGUF; \
-        (slot) = _t; \
+#define GET_F32(slot, name, ...)                                                                          \
+    do {                                                                                                  \
+        ggml_tensor * _t =                                                                                \
+            transcribe::weights::find_tensor(ctx_meta, (name), { GGML_TYPE_F32 }, { __VA_ARGS__ }, kTag); \
+        if (_t == nullptr)                                                                                \
+            return TRANSCRIBE_ERR_GGUF;                                                                   \
+        (slot) = _t;                                                                                      \
     } while (0)
 
-#define GET_CONV(slot, name, ...) \
-    do { \
-        ggml_tensor * _t = transcribe::weights::find_tensor( \
-            ctx_meta, (name), \
-            {TRANSCRIBE_QUANT_CONV_TYPES}, \
-            {__VA_ARGS__}, kTag); \
-        if (_t == nullptr) return TRANSCRIBE_ERR_GGUF; \
-        (slot) = _t; \
+#define GET_CONV(slot, name, ...)                                                                              \
+    do {                                                                                                       \
+        ggml_tensor * _t = transcribe::weights::find_tensor(ctx_meta, (name), { TRANSCRIBE_QUANT_CONV_TYPES }, \
+                                                            { __VA_ARGS__ }, kTag);                            \
+        if (_t == nullptr)                                                                                     \
+            return TRANSCRIBE_ERR_GGUF;                                                                        \
+        (slot) = _t;                                                                                           \
     } while (0)
 
-#define GET_LIN(slot, name, ...) \
-    do { \
-        ggml_tensor * _t = transcribe::weights::find_tensor( \
-            ctx_meta, (name), \
-            {TRANSCRIBE_QUANT_LINEAR_TYPES}, \
-            {__VA_ARGS__}, kTag); \
-        if (_t == nullptr) return TRANSCRIBE_ERR_GGUF; \
-        (slot) = _t; \
+#define GET_LIN(slot, name, ...)                                                                                 \
+    do {                                                                                                         \
+        ggml_tensor * _t = transcribe::weights::find_tensor(ctx_meta, (name), { TRANSCRIBE_QUANT_LINEAR_TYPES }, \
+                                                            { __VA_ARGS__ }, kTag);                              \
+        if (_t == nullptr)                                                                                       \
+            return TRANSCRIBE_ERR_GGUF;                                                                          \
+        (slot) = _t;                                                                                             \
     } while (0)
 
-} // namespace
+}  // namespace
 
-transcribe_status build_canary_weights(ggml_context *         ctx_meta,
-                                       const CanaryHParams &  hp,
-                                       CanaryWeights &        weights)
-{
+transcribe_status build_canary_weights(ggml_context * ctx_meta, const CanaryHParams & hp, CanaryWeights & weights) {
     if (ctx_meta == nullptr) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
@@ -308,18 +428,18 @@ transcribe_status build_canary_weights(ggml_context *         ctx_meta,
     const int64_t pre_encode_in   = pre_encode_freq;
 
     // pre_encode
-    GET_CONV(weights.pre_encode.conv0_w, "enc.pre_encode.conv.0.weight", 3, 3, 1,        channels);
-    GET_F32 (weights.pre_encode.conv0_b, "enc.pre_encode.conv.0.bias", channels);
-    GET_CONV(weights.pre_encode.conv2_w, "enc.pre_encode.conv.2.weight", 3, 3, 1,        channels);
-    GET_F32 (weights.pre_encode.conv2_b, "enc.pre_encode.conv.2.bias", channels);
+    GET_CONV(weights.pre_encode.conv0_w, "enc.pre_encode.conv.0.weight", 3, 3, 1, channels);
+    GET_F32(weights.pre_encode.conv0_b, "enc.pre_encode.conv.0.bias", channels);
+    GET_CONV(weights.pre_encode.conv2_w, "enc.pre_encode.conv.2.weight", 3, 3, 1, channels);
+    GET_F32(weights.pre_encode.conv2_b, "enc.pre_encode.conv.2.bias", channels);
     GET_CONV(weights.pre_encode.conv3_w, "enc.pre_encode.conv.3.weight", 1, 1, channels, channels);
-    GET_F32 (weights.pre_encode.conv3_b, "enc.pre_encode.conv.3.bias", channels);
-    GET_CONV(weights.pre_encode.conv5_w, "enc.pre_encode.conv.5.weight", 3, 3, 1,        channels);
-    GET_F32 (weights.pre_encode.conv5_b, "enc.pre_encode.conv.5.bias", channels);
+    GET_F32(weights.pre_encode.conv3_b, "enc.pre_encode.conv.3.bias", channels);
+    GET_CONV(weights.pre_encode.conv5_w, "enc.pre_encode.conv.5.weight", 3, 3, 1, channels);
+    GET_F32(weights.pre_encode.conv5_b, "enc.pre_encode.conv.5.bias", channels);
     GET_CONV(weights.pre_encode.conv6_w, "enc.pre_encode.conv.6.weight", 1, 1, channels, channels);
-    GET_F32 (weights.pre_encode.conv6_b, "enc.pre_encode.conv.6.bias", channels);
-    GET_LIN (weights.pre_encode.out_w,   "enc.pre_encode.out.weight", pre_encode_in, d_enc);
-    GET_F32 (weights.pre_encode.out_b,   "enc.pre_encode.out.bias", d_enc);
+    GET_F32(weights.pre_encode.conv6_b, "enc.pre_encode.conv.6.bias", channels);
+    GET_LIN(weights.pre_encode.out_w, "enc.pre_encode.out.weight", pre_encode_in, d_enc);
+    GET_F32(weights.pre_encode.out_b, "enc.pre_encode.out.bias", d_enc);
 
     // Encoder blocks. Every linear carries a bias term — both macaron FFs,
     // Q/K/V/out, attention-pos projection, and the conv pointwise pair
@@ -329,54 +449,54 @@ transcribe_status build_canary_weights(ggml_context *         ctx_meta,
         auto & b = weights.blocks[i];
 
         GET_F32(b.norm_ff1_w, lname("enc.blocks.%d.norm_ff1.weight", i), d_enc);
-        GET_F32(b.norm_ff1_b, lname("enc.blocks.%d.norm_ff1.bias",   i), d_enc);
+        GET_F32(b.norm_ff1_b, lname("enc.blocks.%d.norm_ff1.bias", i), d_enc);
         GET_LIN(b.ff1_lin1_w, lname("enc.blocks.%d.ff1.linear1.weight", i), d_enc, d_ff_e);
-        GET_F32(b.ff1_lin1_b, lname("enc.blocks.%d.ff1.linear1.bias",   i), d_ff_e);
+        GET_F32(b.ff1_lin1_b, lname("enc.blocks.%d.ff1.linear1.bias", i), d_ff_e);
         GET_LIN(b.ff1_lin2_w, lname("enc.blocks.%d.ff1.linear2.weight", i), d_ff_e, d_enc);
-        GET_F32(b.ff1_lin2_b, lname("enc.blocks.%d.ff1.linear2.bias",   i), d_enc);
+        GET_F32(b.ff1_lin2_b, lname("enc.blocks.%d.ff1.linear2.bias", i), d_enc);
 
         GET_F32(b.norm_attn_w, lname("enc.blocks.%d.norm_attn.weight", i), d_enc);
-        GET_F32(b.norm_attn_b, lname("enc.blocks.%d.norm_attn.bias",   i), d_enc);
-        GET_LIN(b.attn_q_w,    lname("enc.blocks.%d.attn.linear_q.weight",   i), d_enc, d_enc);
-        GET_F32(b.attn_q_b,    lname("enc.blocks.%d.attn.linear_q.bias",     i), d_enc);
-        GET_LIN(b.attn_k_w,    lname("enc.blocks.%d.attn.linear_k.weight",   i), d_enc, d_enc);
-        GET_F32(b.attn_k_b,    lname("enc.blocks.%d.attn.linear_k.bias",     i), d_enc);
-        GET_LIN(b.attn_v_w,    lname("enc.blocks.%d.attn.linear_v.weight",   i), d_enc, d_enc);
-        GET_F32(b.attn_v_b,    lname("enc.blocks.%d.attn.linear_v.bias",     i), d_enc);
-        GET_LIN(b.attn_out_w,  lname("enc.blocks.%d.attn.linear_out.weight", i), d_enc, d_enc);
-        GET_F32(b.attn_out_b,  lname("enc.blocks.%d.attn.linear_out.bias",   i), d_enc);
-        GET_LIN(b.attn_pos_w,  lname("enc.blocks.%d.attn.linear_pos.weight", i), d_enc, d_enc);
-        GET_F32(b.attn_pos_u,  lname("enc.blocks.%d.attn.pos_bias_u",        i), head_dim, n_heads);
-        GET_F32(b.attn_pos_v,  lname("enc.blocks.%d.attn.pos_bias_v",        i), head_dim, n_heads);
-
-        GET_F32 (b.norm_conv_w, lname("enc.blocks.%d.norm_conv.weight", i), d_enc);
-        GET_F32 (b.norm_conv_b, lname("enc.blocks.%d.norm_conv.bias",   i), d_enc);
-        GET_CONV(b.conv_pw1_w,  lname("enc.blocks.%d.conv.pointwise1.weight", i), 1, d_enc, 2 * d_enc);
-        GET_F32 (b.conv_pw1_b,  lname("enc.blocks.%d.conv.pointwise1.bias",   i), 2 * d_enc);
-        GET_CONV(b.conv_dw_w,   lname("enc.blocks.%d.conv.depthwise.weight",  i), k, 1,    d_enc);
-        GET_F32 (b.conv_dw_b,   lname("enc.blocks.%d.conv.depthwise.bias",    i), d_enc);
-        GET_CONV(b.conv_pw2_w,  lname("enc.blocks.%d.conv.pointwise2.weight", i), 1, d_enc, d_enc);
-        GET_F32 (b.conv_pw2_b,  lname("enc.blocks.%d.conv.pointwise2.bias",   i), d_enc);
-        GET_F32 (b.conv_bn_w,   lname("enc.blocks.%d.conv.bn.weight",       i), d_enc);
-        GET_F32 (b.conv_bn_b,   lname("enc.blocks.%d.conv.bn.bias",         i), d_enc);
-        GET_F32 (b.conv_bn_rm,  lname("enc.blocks.%d.conv.bn.running_mean", i), d_enc);
-        GET_F32 (b.conv_bn_rv,  lname("enc.blocks.%d.conv.bn.running_var",  i), d_enc);
+        GET_F32(b.norm_attn_b, lname("enc.blocks.%d.norm_attn.bias", i), d_enc);
+        GET_LIN(b.attn_q_w, lname("enc.blocks.%d.attn.linear_q.weight", i), d_enc, d_enc);
+        GET_F32(b.attn_q_b, lname("enc.blocks.%d.attn.linear_q.bias", i), d_enc);
+        GET_LIN(b.attn_k_w, lname("enc.blocks.%d.attn.linear_k.weight", i), d_enc, d_enc);
+        GET_F32(b.attn_k_b, lname("enc.blocks.%d.attn.linear_k.bias", i), d_enc);
+        GET_LIN(b.attn_v_w, lname("enc.blocks.%d.attn.linear_v.weight", i), d_enc, d_enc);
+        GET_F32(b.attn_v_b, lname("enc.blocks.%d.attn.linear_v.bias", i), d_enc);
+        GET_LIN(b.attn_out_w, lname("enc.blocks.%d.attn.linear_out.weight", i), d_enc, d_enc);
+        GET_F32(b.attn_out_b, lname("enc.blocks.%d.attn.linear_out.bias", i), d_enc);
+        GET_LIN(b.attn_pos_w, lname("enc.blocks.%d.attn.linear_pos.weight", i), d_enc, d_enc);
+        GET_F32(b.attn_pos_u, lname("enc.blocks.%d.attn.pos_bias_u", i), head_dim, n_heads);
+        GET_F32(b.attn_pos_v, lname("enc.blocks.%d.attn.pos_bias_v", i), head_dim, n_heads);
+
+        GET_F32(b.norm_conv_w, lname("enc.blocks.%d.norm_conv.weight", i), d_enc);
+        GET_F32(b.norm_conv_b, lname("enc.blocks.%d.norm_conv.bias", i), d_enc);
+        GET_CONV(b.conv_pw1_w, lname("enc.blocks.%d.conv.pointwise1.weight", i), 1, d_enc, 2 * d_enc);
+        GET_F32(b.conv_pw1_b, lname("enc.blocks.%d.conv.pointwise1.bias", i), 2 * d_enc);
+        GET_CONV(b.conv_dw_w, lname("enc.blocks.%d.conv.depthwise.weight", i), k, 1, d_enc);
+        GET_F32(b.conv_dw_b, lname("enc.blocks.%d.conv.depthwise.bias", i), d_enc);
+        GET_CONV(b.conv_pw2_w, lname("enc.blocks.%d.conv.pointwise2.weight", i), 1, d_enc, d_enc);
+        GET_F32(b.conv_pw2_b, lname("enc.blocks.%d.conv.pointwise2.bias", i), d_enc);
+        GET_F32(b.conv_bn_w, lname("enc.blocks.%d.conv.bn.weight", i), d_enc);
+        GET_F32(b.conv_bn_b, lname("enc.blocks.%d.conv.bn.bias", i), d_enc);
+        GET_F32(b.conv_bn_rm, lname("enc.blocks.%d.conv.bn.running_mean", i), d_enc);
+        GET_F32(b.conv_bn_rv, lname("enc.blocks.%d.conv.bn.running_var", i), d_enc);
 
         GET_F32(b.norm_ff2_w, lname("enc.blocks.%d.norm_ff2.weight", i), d_enc);
-        GET_F32(b.norm_ff2_b, lname("enc.blocks.%d.norm_ff2.bias",   i), d_enc);
+        GET_F32(b.norm_ff2_b, lname("enc.blocks.%d.norm_ff2.bias", i), d_enc);
         GET_LIN(b.ff2_lin1_w, lname("enc.blocks.%d.ff2.linear1.weight", i), d_enc, d_ff_e);
-        GET_F32(b.ff2_lin1_b, lname("enc.blocks.%d.ff2.linear1.bias",   i), d_ff_e);
+        GET_F32(b.ff2_lin1_b, lname("enc.blocks.%d.ff2.linear1.bias", i), d_ff_e);
         GET_LIN(b.ff2_lin2_w, lname("enc.blocks.%d.ff2.linear2.weight", i), d_ff_e, d_enc);
-        GET_F32(b.ff2_lin2_b, lname("enc.blocks.%d.ff2.linear2.bias",   i), d_enc);
+        GET_F32(b.ff2_lin2_b, lname("enc.blocks.%d.ff2.linear2.bias", i), d_enc);
 
         GET_F32(b.norm_out_w, lname("enc.blocks.%d.norm_out.weight", i), d_enc);
-        GET_F32(b.norm_out_b, lname("enc.blocks.%d.norm_out.bias",   i), d_enc);
+        GET_F32(b.norm_out_b, lname("enc.blocks.%d.norm_out.bias", i), d_enc);
     }
 
     // Optional encoder->decoder projection (180m-flash only).
     if (hp.dec_has_encoder_decoder_proj) {
         GET_LIN(weights.enc_proj.weight, "enc.proj.weight", d_enc, d_dec);
-        GET_F32(weights.enc_proj.bias,   "enc.proj.bias",   d_dec);
+        GET_F32(weights.enc_proj.bias, "enc.proj.bias", d_dec);
     }
 
     // Decoder embedding.
@@ -387,60 +507,58 @@ transcribe_status build_canary_weights(ggml_context *         ctx_meta,
             return TRANSCRIBE_ERR_GGUF;
         }
         if (tw->ne[0] != d_dec || tw->ne[1] != vocab) {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "canary: dec.embed.token.weight shape [%lld,%lld] expected [%lld,%lld]",
-                         (long long)tw->ne[0], (long long)tw->ne[1],
-                         (long long)d_dec, (long long)vocab);
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "canary: dec.embed.token.weight shape [%lld,%lld] expected [%lld,%lld]",
+                    (long long) tw->ne[0], (long long) tw->ne[1], (long long) d_dec, (long long) vocab);
             return TRANSCRIBE_ERR_GGUF;
         }
         weights.dec_embed.token_w = tw;
     }
     GET_F32(weights.dec_embed.pos_enc, "dec.embed.pos_enc", d_dec, hp.dec_max_position);
-    GET_F32(weights.dec_embed.norm_w,  "dec.embed.norm.weight", d_dec);
-    GET_F32(weights.dec_embed.norm_b,  "dec.embed.norm.bias",   d_dec);
+    GET_F32(weights.dec_embed.norm_w, "dec.embed.norm.weight", d_dec);
+    GET_F32(weights.dec_embed.norm_b, "dec.embed.norm.bias", d_dec);
 
     // Decoder blocks (canary tensor naming).
     weights.dec_blocks.assign(hp.dec_n_layers, CanaryDecBlock{});
     for (int i = 0; i < hp.dec_n_layers; ++i) {
         auto & db = weights.dec_blocks[i];
 
-        GET_F32(db.norm1_w,  lname("dec.layer.%d.norm1.weight", i), d_dec);
-        GET_F32(db.norm1_b,  lname("dec.layer.%d.norm1.bias",   i), d_dec);
+        GET_F32(db.norm1_w, lname("dec.layer.%d.norm1.weight", i), d_dec);
+        GET_F32(db.norm1_b, lname("dec.layer.%d.norm1.bias", i), d_dec);
         GET_LIN(db.self_q_w, lname("dec.layer.%d.self_attn.q.weight", i), d_dec, d_dec);
-        GET_F32(db.self_q_b, lname("dec.layer.%d.self_attn.q.bias",   i), d_dec);
+        GET_F32(db.self_q_b, lname("dec.layer.%d.self_attn.q.bias", i), d_dec);
         GET_LIN(db.self_k_w, lname("dec.layer.%d.self_attn.k.weight", i), d_dec, d_dec);
-        GET_F32(db.self_k_b, lname("dec.layer.%d.self_attn.k.bias",   i), d_dec);
+        GET_F32(db.self_k_b, lname("dec.layer.%d.self_attn.k.bias", i), d_dec);
         GET_LIN(db.self_v_w, lname("dec.layer.%d.self_attn.v.weight", i), d_dec, d_dec);
-        GET_F32(db.self_v_b, lname("dec.layer.%d.self_attn.v.bias",   i), d_dec);
+        GET_F32(db.self_v_b, lname("dec.layer.%d.self_attn.v.bias", i), d_dec);
         GET_LIN(db.self_o_w, lname("dec.layer.%d.self_attn.o.weight", i), d_dec, d_dec);
-        GET_F32(db.self_o_b, lname("dec.layer.%d.self_attn.o.bias",   i), d_dec);
+        GET_F32(db.self_o_b, lname("dec.layer.%d.self_attn.o.bias", i), d_dec);
 
-        GET_F32(db.norm2_w,   lname("dec.layer.%d.norm2.weight", i), d_dec);
-        GET_F32(db.norm2_b,   lname("dec.layer.%d.norm2.bias",   i), d_dec);
+        GET_F32(db.norm2_w, lname("dec.layer.%d.norm2.weight", i), d_dec);
+        GET_F32(db.norm2_b, lname("dec.layer.%d.norm2.bias", i), d_dec);
         GET_LIN(db.cross_q_w, lname("dec.layer.%d.cross_attn.q.weight", i), d_dec, d_dec);
-        GET_F32(db.cross_q_b, lname("dec.layer.%d.cross_attn.q.bias",   i), d_dec);
+        GET_F32(db.cross_q_b, lname("dec.layer.%d.cross_attn.q.bias", i), d_dec);
         GET_LIN(db.cross_k_w, lname("dec.layer.%d.cross_attn.k.weight", i), d_dec, d_dec);
-        GET_F32(db.cross_k_b, lname("dec.layer.%d.cross_attn.k.bias",   i), d_dec);
+        GET_F32(db.cross_k_b, lname("dec.layer.%d.cross_attn.k.bias", i), d_dec);
         GET_LIN(db.cross_v_w, lname("dec.layer.%d.cross_attn.v.weight", i), d_dec, d_dec);
-        GET_F32(db.cross_v_b, lname("dec.layer.%d.cross_attn.v.bias",   i), d_dec);
+        GET_F32(db.cross_v_b, lname("dec.layer.%d.cross_attn.v.bias", i), d_dec);
         GET_LIN(db.cross_o_w, lname("dec.layer.%d.cross_attn.o.weight", i), d_dec, d_dec);
-        GET_F32(db.cross_o_b, lname("dec.layer.%d.cross_attn.o.bias",   i), d_dec);
+        GET_F32(db.cross_o_b, lname("dec.layer.%d.cross_attn.o.bias", i), d_dec);
 
-        GET_F32(db.norm3_w,    lname("dec.layer.%d.norm3.weight", i), d_dec);
-        GET_F32(db.norm3_b,    lname("dec.layer.%d.norm3.bias",   i), d_dec);
-        GET_LIN(db.ffn_up_w,   lname("dec.layer.%d.ffn.up.weight",   i), d_dec, d_ff_d);
-        GET_F32(db.ffn_up_b,   lname("dec.layer.%d.ffn.up.bias",     i), d_ff_d);
+        GET_F32(db.norm3_w, lname("dec.layer.%d.norm3.weight", i), d_dec);
+        GET_F32(db.norm3_b, lname("dec.layer.%d.norm3.bias", i), d_dec);
+        GET_LIN(db.ffn_up_w, lname("dec.layer.%d.ffn.up.weight", i), d_dec, d_ff_d);
+        GET_F32(db.ffn_up_b, lname("dec.layer.%d.ffn.up.bias", i), d_ff_d);
         GET_LIN(db.ffn_down_w, lname("dec.layer.%d.ffn.down.weight", i), d_ff_d, d_dec);
-        GET_F32(db.ffn_down_b, lname("dec.layer.%d.ffn.down.bias",   i), d_dec);
+        GET_F32(db.ffn_down_b, lname("dec.layer.%d.ffn.down.bias", i), d_dec);
     }
 
     // Decoder final norm.
     GET_F32(weights.dec_final.norm_w, "dec.norm.weight", d_dec);
-    GET_F32(weights.dec_final.norm_b, "dec.norm.bias",   d_dec);
+    GET_F32(weights.dec_final.norm_b, "dec.norm.bias", d_dec);
 
     // LM head (untied).
     GET_LIN(weights.head.weight, "dec.head.weight", d_dec, vocab);
-    GET_F32(weights.head.bias,   "dec.head.bias",   vocab);
+    GET_F32(weights.head.bias, "dec.head.bias", vocab);
 
     return TRANSCRIBE_OK;
 }
@@ -449,4 +567,4 @@ transcribe_status build_canary_weights(ggml_context *         ctx_meta,
 #undef GET_CONV
 #undef GET_LIN
 
-} // namespace transcribe::canary
+}  // namespace transcribe::canary
diff --git a/src/arch/canary/weights.h b/src/arch/canary/weights.h
index f8bfa197..99aff864 100644
--- a/src/arch/canary/weights.h
+++ b/src/arch/canary/weights.h
@@ -35,23 +35,23 @@ struct CanaryHParams {
     bool    enc_use_bias             = false;
 
     // Decoder (autoregressive Transformer).
-    int32_t dec_n_layers   = 0;
-    int32_t dec_d_model    = 0;   // hidden size; d_dec
-    int32_t dec_n_heads    = 0;
-    int32_t dec_d_ff       = 0;   // FFN inner size
-    int32_t dec_max_position = 0;
-    int32_t dec_vocab_size = 0;   // declared in KV; cross-checked against dec.embed.token.weight
-    std::string dec_activation;   // "relu" / "silu" / "swish"
-    bool    dec_pre_ln                  = true;
-    bool    dec_learn_positional_encodings = false;
-    bool    dec_has_encoder_decoder_proj = false;  // 180m-flash: true; others: false
+    int32_t     dec_n_layers     = 0;
+    int32_t     dec_d_model      = 0;  // hidden size; d_dec
+    int32_t     dec_n_heads      = 0;
+    int32_t     dec_d_ff         = 0;  // FFN inner size
+    int32_t     dec_max_position = 0;
+    int32_t     dec_vocab_size   = 0;  // declared in KV; cross-checked against dec.embed.token.weight
+    std::string dec_activation;        // "relu" / "silu" / "swish"
+    bool        dec_pre_ln                     = true;
+    bool        dec_learn_positional_encodings = false;
+    bool        dec_has_encoder_decoder_proj   = false;  // 180m-flash: true; others: false
 
     // True when the tokenizer is a single SentencePiece (canary-1b-v2)
     // rather than a CanaryTokenizer aggregate. Single-SP tokenizers
     // render an empty decoder-context slot as a leading whitespace
     // marker (`▁`) in the canary2 prompt — adds one token to the prompt
     // length. Aggregate tokenizers skip the empty slot entirely.
-    bool    tokenizer_single_sp = false;
+    bool tokenizer_single_sp = false;
 
     // Token IDs (filled from tokenizer at load time).
     int32_t bos_token_id = -1;
@@ -59,31 +59,31 @@ struct CanaryHParams {
     int32_t pad_token_id = -1;
 
     // Multitask special-token catalog. Read from stt.canary.special.* KV.
-    std::string prompt_format;        // "canary" or "canary2"
-    int32_t startoftranscript_id = -1;
-    int32_t startofcontext_id    = -1;
-    int32_t endoftext_id         = -1;
-    int32_t pad_special_id       = -1;
-    int32_t nospeech_id          = -1;
-    int32_t pnc_id               = -1;
-    int32_t nopnc_id             = -1;
-    int32_t itn_id               = -1;
-    int32_t noitn_id             = -1;
-    int32_t timestamp_id         = -1;
-    int32_t notimestamp_id       = -1;
-    int32_t diarize_id           = -1;
-    int32_t nodiarize_id         = -1;
-    int32_t spkchange_id         = -1;
-    int32_t audioseparator_id    = -1;
+    std::string prompt_format;  // "canary" or "canary2"
+    int32_t     startoftranscript_id = -1;
+    int32_t     startofcontext_id    = -1;
+    int32_t     endoftext_id         = -1;
+    int32_t     pad_special_id       = -1;
+    int32_t     nospeech_id          = -1;
+    int32_t     pnc_id               = -1;
+    int32_t     nopnc_id             = -1;
+    int32_t     itn_id               = -1;
+    int32_t     noitn_id             = -1;
+    int32_t     timestamp_id         = -1;
+    int32_t     notimestamp_id       = -1;
+    int32_t     diarize_id           = -1;
+    int32_t     nodiarize_id         = -1;
+    int32_t     spkchange_id         = -1;
+    int32_t     audioseparator_id    = -1;
     // canary-1 explicit task tokens (canary2 omits these — task is
     // inferred from src_lang vs tgt_lang).
-    int32_t transcribe_id        = -1;
-    int32_t translate_id         = -1;
+    int32_t     transcribe_id        = -1;
+    int32_t     translate_id         = -1;
 
     // Language code -> language token id, in the order published via
     // stt.canary.tokenizer.lang_codes / stt.canary.special.lang.<code>_id.
-    std::vector<std::string> languages;        // e.g. {"en","de","es","fr"}
-    std::vector<int32_t>     language_ids;     // parallel: id of "<|en|>" etc.
+    std::vector<std::string> languages;     // e.g. {"en","de","es","fr"}
+    std::vector<int32_t>     language_ids;  // parallel: id of "<|en|>" etc.
 
     // Optional GGUF contract: allowed translation pairs as "src>target".
     // Old GGUFs do not carry this KV; an empty list preserves legacy behavior.
@@ -105,11 +105,11 @@ struct CanaryHParams {
     std::string fe_pad_mode;
 
     int32_t enc_head_dim() const { return enc_n_heads > 0 ? enc_d_model / enc_n_heads : 0; }
+
     int32_t dec_head_dim() const { return dec_n_heads > 0 ? dec_d_model / dec_n_heads : 0; }
 };
 
-transcribe_status read_canary_hparams(const gguf_context * gguf,
-                                      CanaryHParams &      hp);
+transcribe_status read_canary_hparams(const gguf_context * gguf, CanaryHParams & hp);
 
 // ---------------------------------------------------------------------------
 // Weight slots
@@ -141,33 +141,33 @@ struct CanaryBlock {
     ggml_tensor * ff1_lin2_w = nullptr;
     ggml_tensor * ff1_lin2_b = nullptr;
 
-    ggml_tensor * norm_attn_w  = nullptr;
-    ggml_tensor * norm_attn_b  = nullptr;
-    ggml_tensor * attn_q_w     = nullptr;
-    ggml_tensor * attn_q_b     = nullptr;
-    ggml_tensor * attn_k_w     = nullptr;
-    ggml_tensor * attn_k_b     = nullptr;
-    ggml_tensor * attn_v_w     = nullptr;
-    ggml_tensor * attn_v_b     = nullptr;
-    ggml_tensor * attn_out_w   = nullptr;
-    ggml_tensor * attn_out_b   = nullptr;
-    ggml_tensor * attn_pos_w   = nullptr;
-    ggml_tensor * attn_pos_u   = nullptr;
-    ggml_tensor * attn_pos_v   = nullptr;
+    ggml_tensor * norm_attn_w = nullptr;
+    ggml_tensor * norm_attn_b = nullptr;
+    ggml_tensor * attn_q_w    = nullptr;
+    ggml_tensor * attn_q_b    = nullptr;
+    ggml_tensor * attn_k_w    = nullptr;
+    ggml_tensor * attn_k_b    = nullptr;
+    ggml_tensor * attn_v_w    = nullptr;
+    ggml_tensor * attn_v_b    = nullptr;
+    ggml_tensor * attn_out_w  = nullptr;
+    ggml_tensor * attn_out_b  = nullptr;
+    ggml_tensor * attn_pos_w  = nullptr;
+    ggml_tensor * attn_pos_u  = nullptr;
+    ggml_tensor * attn_pos_v  = nullptr;
 
     // Conv module — BN fused at load into _scale/_bias.
-    ggml_tensor * norm_conv_w  = nullptr;
-    ggml_tensor * norm_conv_b  = nullptr;
-    ggml_tensor * conv_pw1_w   = nullptr;
-    ggml_tensor * conv_pw1_b   = nullptr;
-    ggml_tensor * conv_dw_w    = nullptr;
-    ggml_tensor * conv_dw_b    = nullptr;
-    ggml_tensor * conv_pw2_w   = nullptr;
-    ggml_tensor * conv_pw2_b   = nullptr;
-    ggml_tensor * conv_bn_w    = nullptr;
-    ggml_tensor * conv_bn_b    = nullptr;
-    ggml_tensor * conv_bn_rm   = nullptr;
-    ggml_tensor * conv_bn_rv   = nullptr;
+    ggml_tensor * norm_conv_w         = nullptr;
+    ggml_tensor * norm_conv_b         = nullptr;
+    ggml_tensor * conv_pw1_w          = nullptr;
+    ggml_tensor * conv_pw1_b          = nullptr;
+    ggml_tensor * conv_dw_w           = nullptr;
+    ggml_tensor * conv_dw_b           = nullptr;
+    ggml_tensor * conv_pw2_w          = nullptr;
+    ggml_tensor * conv_pw2_b          = nullptr;
+    ggml_tensor * conv_bn_w           = nullptr;
+    ggml_tensor * conv_bn_b           = nullptr;
+    ggml_tensor * conv_bn_rm          = nullptr;
+    ggml_tensor * conv_bn_rv          = nullptr;
     ggml_tensor * conv_bn_fused_scale = nullptr;
     ggml_tensor * conv_bn_fused_bias  = nullptr;
 
@@ -200,34 +200,34 @@ struct CanaryDecEmbed {
 //   norm2 -> cross_attn -> add residual
 //   norm3 -> ffn -> add residual
 struct CanaryDecBlock {
-    ggml_tensor * norm1_w     = nullptr;
-    ggml_tensor * norm1_b     = nullptr;
-    ggml_tensor * self_q_w    = nullptr;
-    ggml_tensor * self_q_b    = nullptr;
-    ggml_tensor * self_k_w    = nullptr;
-    ggml_tensor * self_k_b    = nullptr;
-    ggml_tensor * self_v_w    = nullptr;
-    ggml_tensor * self_v_b    = nullptr;
-    ggml_tensor * self_o_w    = nullptr;
-    ggml_tensor * self_o_b    = nullptr;
-
-    ggml_tensor * norm2_w     = nullptr;
-    ggml_tensor * norm2_b     = nullptr;
-    ggml_tensor * cross_q_w   = nullptr;
-    ggml_tensor * cross_q_b   = nullptr;
-    ggml_tensor * cross_k_w   = nullptr;
-    ggml_tensor * cross_k_b   = nullptr;
-    ggml_tensor * cross_v_w   = nullptr;
-    ggml_tensor * cross_v_b   = nullptr;
-    ggml_tensor * cross_o_w   = nullptr;
-    ggml_tensor * cross_o_b   = nullptr;
-
-    ggml_tensor * norm3_w     = nullptr;
-    ggml_tensor * norm3_b     = nullptr;
-    ggml_tensor * ffn_up_w    = nullptr;
-    ggml_tensor * ffn_up_b    = nullptr;
-    ggml_tensor * ffn_down_w  = nullptr;
-    ggml_tensor * ffn_down_b  = nullptr;
+    ggml_tensor * norm1_w  = nullptr;
+    ggml_tensor * norm1_b  = nullptr;
+    ggml_tensor * self_q_w = nullptr;
+    ggml_tensor * self_q_b = nullptr;
+    ggml_tensor * self_k_w = nullptr;
+    ggml_tensor * self_k_b = nullptr;
+    ggml_tensor * self_v_w = nullptr;
+    ggml_tensor * self_v_b = nullptr;
+    ggml_tensor * self_o_w = nullptr;
+    ggml_tensor * self_o_b = nullptr;
+
+    ggml_tensor * norm2_w   = nullptr;
+    ggml_tensor * norm2_b   = nullptr;
+    ggml_tensor * cross_q_w = nullptr;
+    ggml_tensor * cross_q_b = nullptr;
+    ggml_tensor * cross_k_w = nullptr;
+    ggml_tensor * cross_k_b = nullptr;
+    ggml_tensor * cross_v_w = nullptr;
+    ggml_tensor * cross_v_b = nullptr;
+    ggml_tensor * cross_o_w = nullptr;
+    ggml_tensor * cross_o_b = nullptr;
+
+    ggml_tensor * norm3_w    = nullptr;
+    ggml_tensor * norm3_b    = nullptr;
+    ggml_tensor * ffn_up_w   = nullptr;
+    ggml_tensor * ffn_up_b   = nullptr;
+    ggml_tensor * ffn_down_w = nullptr;
+    ggml_tensor * ffn_down_b = nullptr;
 };
 
 struct CanaryDecFinal {
@@ -242,17 +242,15 @@ struct CanaryHead {
 };
 
 struct CanaryWeights {
-    CanaryPreEncode              pre_encode;
-    std::vector<CanaryBlock>     blocks;
-    CanaryEncProj                enc_proj;       // unused when has_encoder_decoder_proj=false
-    CanaryDecEmbed               dec_embed;
-    std::vector<CanaryDecBlock>  dec_blocks;
-    CanaryDecFinal               dec_final;
-    CanaryHead                   head;
+    CanaryPreEncode             pre_encode;
+    std::vector<CanaryBlock>    blocks;
+    CanaryEncProj               enc_proj;  // unused when has_encoder_decoder_proj=false
+    CanaryDecEmbed              dec_embed;
+    std::vector<CanaryDecBlock> dec_blocks;
+    CanaryDecFinal              dec_final;
+    CanaryHead                  head;
 };
 
-transcribe_status build_canary_weights(ggml_context *         ctx_meta,
-                                       const CanaryHParams &  hp,
-                                       CanaryWeights &        weights);
+transcribe_status build_canary_weights(ggml_context * ctx_meta, const CanaryHParams & hp, CanaryWeights & weights);
 
-} // namespace transcribe::canary
+}  // namespace transcribe::canary
diff --git a/src/arch/canary_qwen/canary_qwen.h b/src/arch/canary_qwen/canary_qwen.h
index 422b66a6..0fbce933 100644
--- a/src/arch/canary_qwen/canary_qwen.h
+++ b/src/arch/canary_qwen/canary_qwen.h
@@ -17,14 +17,13 @@
 
 #pragma once
 
-#include "weights.h"
-
 #include "causal_lm/causal_lm.h"
 #include "transcribe-backend.h"
-#include "transcribe-session.h"
 #include "transcribe-mel.h"
 #include "transcribe-model.h"
+#include "transcribe-session.h"
 #include "transcribe-tokenizer.h"
+#include "weights.h"
 
 #include <cstdint>
 #include <optional>
@@ -46,34 +45,34 @@ void apply_family_invariants(transcribe_model & model);
 // GGUF tokenizer). The HF chat template emits these by name; we look up
 // each token id once and reuse.
 struct ChatTokens {
-    int32_t im_start       = -1;   // "<|im_start|>"
-    int32_t im_end         = -1;   // "<|im_end|>"
-    int32_t role_user      = -1;   // bpe("user") = single token in Qwen2 BPE
-    int32_t role_assistant = -1;   // bpe("assistant") = single token
+    int32_t im_start       = -1;  // "<|im_start|>"
+    int32_t im_end         = -1;  // "<|im_end|>"
+    int32_t role_user      = -1;  // bpe("user") = single token in Qwen2 BPE
+    int32_t role_assistant = -1;  // bpe("assistant") = single token
 };
 
 struct CanaryQwenModel final : public transcribe_model {
-    Tokenizer            tok;
-    CanaryQwenHParams    hparams;
-    CanaryQwenWeights    weights;
-    ggml_context *       ctx_meta = nullptr;
+    Tokenizer         tok;
+    CanaryQwenHParams hparams;
+    CanaryQwenWeights weights;
+    ggml_context *    ctx_meta = nullptr;
 
-    transcribe::BackendPlan       plan;
-    ggml_backend_buffer_t         backend_buffer = nullptr;
+    transcribe::BackendPlan plan;
+    ggml_backend_buffer_t   backend_buffer = nullptr;
 
     // BatchNorm fusion in the conformer conv module: fused (scale, bias)
     // computed at load time; running_mean/var unused at inference.
-    ggml_context *               bn_fused_ctx    = nullptr;
-    ggml_backend_buffer_t        bn_fused_buffer = nullptr;
+    ggml_context *        bn_fused_ctx    = nullptr;
+    ggml_backend_buffer_t bn_fused_buffer = nullptr;
 
     // F16 conv pointwise/depthwise weights promoted to F32 (see model.cpp).
-    ggml_context *               conv_pw_f32_ctx    = nullptr;
-    ggml_backend_buffer_t        conv_pw_f32_buffer = nullptr;
+    ggml_context *        conv_pw_f32_ctx    = nullptr;
+    ggml_backend_buffer_t conv_pw_f32_buffer = nullptr;
 
     // BF16 encoder + decoder linear weights promoted to F32 on CPU (see
     // model.cpp; matches the reference's F32 inference regime).
-    ggml_context *               linear_f32_ctx    = nullptr;
-    ggml_backend_buffer_t        linear_f32_buffer = nullptr;
+    ggml_context *        linear_f32_ctx    = nullptr;
+    ggml_backend_buffer_t linear_f32_buffer = nullptr;
 
     transcribe::causal_lm::PackedGateUpHandles packed_gate_up;
 
@@ -103,9 +102,8 @@ struct CanaryQwenSession final : public transcribe_session {
 
     // Batched KV cache for offline transcribe_run_batch (n_batch slabs).
     transcribe::causal_lm::KvCache kv_cache_batch;
-    int                           kv_batch_cap   = 0;
-    int                           kv_batch_n_ctx = 0;
-
+    int                            kv_batch_cap   = 0;
+    int                            kv_batch_n_ctx = 0;
 
     // Reusable host scratch.
     std::vector<float> mel_buf;       // [num_mels, n_frames]
@@ -123,4 +121,4 @@ struct CanaryQwenSession final : public transcribe_session {
     ~CanaryQwenSession() override;
 };
 
-} // namespace transcribe::canary_qwen
+}  // namespace transcribe::canary_qwen
diff --git a/src/arch/canary_qwen/capabilities.cpp b/src/arch/canary_qwen/capabilities.cpp
index 75e6c71c..575c49de 100644
--- a/src/arch/canary_qwen/capabilities.cpp
+++ b/src/arch/canary_qwen/capabilities.cpp
@@ -22,4 +22,4 @@ void apply_family_invariants(transcribe_model & model) {
     transcribe::set_feature(&model, TRANSCRIBE_FEATURE_CANCELLATION, true);
 }
 
-} // namespace transcribe::canary_qwen
+}  // namespace transcribe::canary_qwen
diff --git a/src/arch/canary_qwen/decoder.cpp b/src/arch/canary_qwen/decoder.cpp
index b5af743f..6e295a08 100644
--- a/src/arch/canary_qwen/decoder.cpp
+++ b/src/arch/canary_qwen/decoder.cpp
@@ -8,11 +8,10 @@
 #include "decoder.h"
 
 #include "causal_lm/causal_lm.h"
+#include "ggml.h"
 #include "transcribe-debug.h"
 #include "transcribe-log.h"
 
-#include "ggml.h"
-
 #include <cmath>
 #include <cstdio>
 
@@ -21,12 +20,14 @@ namespace transcribe::canary_qwen {
 namespace {
 
 ggml_tensor * named(ggml_tensor * t, const char * name) {
-    if (t != nullptr && name != nullptr) ggml_set_name(t, name);
+    if (t != nullptr && name != nullptr) {
+        ggml_set_name(t, name);
+    }
     return t;
 }
 
 causal_lm::BlockView to_block_view(const DecBlockSlots & b) {
-    causal_lm::BlockView v {};
+    causal_lm::BlockView v{};
     v.norm_attn_w   = b.norm_attn_w;
     v.norm_ffn_w    = b.norm_ffn_w;
     v.attn_q_w      = b.attn_q_w;
@@ -41,7 +42,7 @@ causal_lm::BlockView to_block_view(const DecBlockSlots & b) {
 }
 
 causal_lm::BlockParams to_block_params(const CanaryQwenHParams & hp) {
-    causal_lm::BlockParams p {};
+    causal_lm::BlockParams p{};
     p.n_heads      = hp.dec_n_heads;
     p.n_kv_heads   = hp.dec_n_kv_heads;
     p.head_dim     = hp.dec_head_dim;
@@ -51,38 +52,34 @@ causal_lm::BlockParams to_block_params(const CanaryQwenHParams & hp) {
     return p;
 }
 
-} // namespace
+}  // namespace
 
-PrefillBuild build_prefill_graph(ggml_context *                  ctx,
-                                 const CanaryQwenWeights &       weights,
-                                 const CanaryQwenHParams &       hp,
+PrefillBuild build_prefill_graph(ggml_context *                   ctx,
+                                 const CanaryQwenWeights &        weights,
+                                 const CanaryQwenHParams &        hp,
                                  transcribe::causal_lm::KvCache & kv_cache,
-                                 int                             T_prompt,
-                                 int                             T_audio,
-                                 int                             prefix_len,
-                                 int                             suffix_len,
-                                 bool                            use_flash,
-                                 bool                            slice_last)
-{
-    PrefillBuild pb {};
+                                 int                              T_prompt,
+                                 int                              T_audio,
+                                 int                              prefix_len,
+                                 int                              suffix_len,
+                                 bool                             use_flash,
+                                 bool                             slice_last) {
+    PrefillBuild pb{};
     pb.T_prompt   = T_prompt;
     pb.T_audio    = T_audio;
     pb.prefix_len = prefix_len;
     pb.suffix_len = suffix_len;
 
     if (ctx == nullptr || T_prompt <= 0 || T_audio < 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "canary_qwen decoder: invalid arg (T_prompt=%d, T_audio=%d)",
-                     T_prompt, T_audio);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "canary_qwen decoder: invalid arg (T_prompt=%d, T_audio=%d)", T_prompt,
+                T_audio);
         return pb;
     }
-    if (prefix_len < 0 || suffix_len < 0 ||
-        prefix_len + T_audio + suffix_len != T_prompt)
-    {
+    if (prefix_len < 0 || suffix_len < 0 || prefix_len + T_audio + suffix_len != T_prompt) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "canary_qwen decoder: prefix_len(%d) + T_audio(%d) + "
-                     "suffix_len(%d) != T_prompt(%d)",
-                     prefix_len, T_audio, suffix_len, T_prompt);
+                "canary_qwen decoder: prefix_len(%d) + T_audio(%d) + "
+                "suffix_len(%d) != T_prompt(%d)",
+                prefix_len, T_audio, suffix_len, T_prompt);
         return pb;
     }
     if (kv_cache.self_k == nullptr || kv_cache.self_v == nullptr) {
@@ -90,9 +87,8 @@ PrefillBuild build_prefill_graph(ggml_context *                  ctx,
         return pb;
     }
     if (T_prompt > kv_cache.n_ctx) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "canary_qwen decoder: T_prompt=%d exceeds kv_cache.n_ctx=%d",
-                     T_prompt, kv_cache.n_ctx);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "canary_qwen decoder: T_prompt=%d exceeds kv_cache.n_ctx=%d", T_prompt,
+                kv_cache.n_ctx);
         return pb;
     }
 
@@ -123,8 +119,7 @@ PrefillBuild build_prefill_graph(ggml_context *                  ctx,
 
     ggml_cgraph * gf = ggml_new_graph_custom(ctx, /*size=*/16384, /*grads=*/false);
     if (gf == nullptr) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "canary_qwen decoder: ggml_new_graph_custom failed");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "canary_qwen decoder: ggml_new_graph_custom failed");
         return pb;
     }
     pb.graph = gf;
@@ -134,25 +129,19 @@ PrefillBuild build_prefill_graph(ggml_context *                  ctx,
     // those positions is replaced by the audio rows in the concat below
     // (so the lookup value at locator positions is dead, exactly like
     // NeMo's `tokens.where(tokens != audio_locator_id, 0)`).
-    ggml_tensor * token_emb_all = ggml_get_rows(
-        ctx, weights.dec_embed.token_w, pb.input_ids_in);
+    ggml_tensor * token_emb_all = ggml_get_rows(ctx, weights.dec_embed.token_w, pb.input_ids_in);
 
     // ---- Audio injection via 3-way concat ----
-    const size_t emb_elem = ggml_element_size(token_emb_all);
+    const size_t  emb_elem = ggml_element_size(token_emb_all);
     ggml_tensor * x_prefix = nullptr;
     if (prefix_len > 0) {
-        x_prefix = ggml_view_2d(ctx, token_emb_all,
-                                hidden, prefix_len,
-                                emb_elem * hidden, /*off=*/0);
+        x_prefix = ggml_view_2d(ctx, token_emb_all, hidden, prefix_len, emb_elem * hidden, /*off=*/0);
         x_prefix = ggml_cont(ctx, x_prefix);
     }
     ggml_tensor * x_suffix = nullptr;
     if (suffix_len > 0) {
-        x_suffix = ggml_view_2d(ctx, token_emb_all,
-                                hidden, suffix_len,
-                                emb_elem * hidden,
-                                emb_elem * hidden *
-                                    static_cast<size_t>(prefix_len + T_audio));
+        x_suffix = ggml_view_2d(ctx, token_emb_all, hidden, suffix_len, emb_elem * hidden,
+                                emb_elem * hidden * static_cast<size_t>(prefix_len + T_audio));
         x_suffix = ggml_cont(ctx, x_suffix);
     }
 
@@ -163,8 +152,12 @@ PrefillBuild build_prefill_graph(ggml_context *                  ctx,
     ggml_tensor * x;
     if (T_audio > 0) {
         x = pb.audio_in;
-        if (x_prefix != nullptr) x = ggml_concat(ctx, x_prefix, x, /*dim=*/1);
-        if (x_suffix != nullptr) x = ggml_concat(ctx, x, x_suffix, /*dim=*/1);
+        if (x_prefix != nullptr) {
+            x = ggml_concat(ctx, x_prefix, x, /*dim=*/1);
+        }
+        if (x_suffix != nullptr) {
+            x = ggml_concat(ctx, x, x_suffix, /*dim=*/1);
+        }
     } else {
         x = token_emb_all;
     }
@@ -175,20 +168,12 @@ PrefillBuild build_prefill_graph(ggml_context *                  ctx,
     // ---- Block stack (28 Qwen3 layers) ----
     const int mid_idx = n_layer / 2;
     for (int il = 0; il < n_layer; ++il) {
-        causal_lm::BlockOpts opts {};
+        causal_lm::BlockOpts opts{};
         opts.use_flash             = use_flash;
         opts.slice_last_before_ffn = slice_last && (il == n_layer - 1);
 
-        x = causal_lm::block_prefill(
-            ctx, gf, x,
-            to_block_view(weights.dec_blocks[il]),
-            block_params,
-            kv_cache,
-            il,
-            T_prompt,
-            pb.mask_in,
-            pb.positions_in,
-            opts);
+        x = causal_lm::block_prefill(ctx, gf, x, to_block_view(weights.dec_blocks[il]), block_params, kv_cache, il,
+                                     T_prompt, pb.mask_in, pb.positions_in, opts);
 
         if (il == 0) {
             named(x, "dec.block.0.out");
@@ -210,8 +195,7 @@ PrefillBuild build_prefill_graph(ggml_context *                  ctx,
     }
 
     // ---- Final RMSNorm + tied lm_head ----
-    x = ggml_mul(ctx, ggml_rms_norm(ctx, x, rms_eps),
-                 weights.dec_final.norm_w);
+    x = ggml_mul(ctx, ggml_rms_norm(ctx, x, rms_eps), weights.dec_final.norm_w);
     named(x, "dec.out_before_head");
     pb.dumps.out_before_head = x;
     transcribe::debug::mark_tensor_for_dump(x);
@@ -220,15 +204,13 @@ PrefillBuild build_prefill_graph(ggml_context *                  ctx,
     if (slice_last) {
         last_x = x;
     } else {
-        last_x = ggml_view_2d(
-            ctx, x, hidden, 1,
-            ggml_element_size(x) * hidden,
-            ggml_element_size(x) * hidden * static_cast<size_t>(T_prompt - 1));
+        last_x = ggml_view_2d(ctx, x, hidden, 1, ggml_element_size(x) * hidden,
+                              ggml_element_size(x) * hidden * static_cast<size_t>(T_prompt - 1));
         last_x = ggml_cont(ctx, last_x);
     }
 
     ggml_tensor * logits = ggml_mul_mat(ctx, weights.dec_embed.token_w, last_x);
-    logits = ggml_reshape_1d(ctx, logits, vocab);
+    logits               = ggml_reshape_1d(ctx, logits, vocab);
     named(logits, "dec.logits_raw.gen0");
     pb.dumps.logits_raw = logits;
     transcribe::debug::mark_tensor_for_dump(logits);
@@ -237,31 +219,41 @@ PrefillBuild build_prefill_graph(ggml_context *                  ctx,
     ggml_set_output(pb.out);
 
     ggml_build_forward_expand(gf, pb.out);
-    if (pb.dumps.token_emb)       ggml_build_forward_expand(gf, pb.dumps.token_emb);
-    if (pb.dumps.audio_injected)  ggml_build_forward_expand(gf, pb.dumps.audio_injected);
-    if (pb.dumps.block_0_out)     ggml_build_forward_expand(gf, pb.dumps.block_0_out);
-    if (pb.dumps.block_mid_out)   ggml_build_forward_expand(gf, pb.dumps.block_mid_out);
-    if (pb.dumps.block_last_out)  ggml_build_forward_expand(gf, pb.dumps.block_last_out);
-    if (pb.dumps.out_before_head) ggml_build_forward_expand(gf, pb.dumps.out_before_head);
+    if (pb.dumps.token_emb) {
+        ggml_build_forward_expand(gf, pb.dumps.token_emb);
+    }
+    if (pb.dumps.audio_injected) {
+        ggml_build_forward_expand(gf, pb.dumps.audio_injected);
+    }
+    if (pb.dumps.block_0_out) {
+        ggml_build_forward_expand(gf, pb.dumps.block_0_out);
+    }
+    if (pb.dumps.block_mid_out) {
+        ggml_build_forward_expand(gf, pb.dumps.block_mid_out);
+    }
+    if (pb.dumps.block_last_out) {
+        ggml_build_forward_expand(gf, pb.dumps.block_last_out);
+    }
+    if (pb.dumps.out_before_head) {
+        ggml_build_forward_expand(gf, pb.dumps.out_before_head);
+    }
 
     return pb;
 }
 
 // Step graph (single-token decode)
 
-StepBuild build_step_graph(ggml_context *                  ctx,
-                           const CanaryQwenWeights &       weights,
-                           const CanaryQwenHParams &       hp,
+StepBuild build_step_graph(ggml_context *                   ctx,
+                           const CanaryQwenWeights &        weights,
+                           const CanaryQwenHParams &        hp,
                            transcribe::causal_lm::KvCache & kv_cache,
-                           int                             max_n_kv,
-                           bool                            use_flash)
-{
-    StepBuild sb {};
+                           int                              max_n_kv,
+                           bool                             use_flash) {
+    StepBuild sb{};
     sb.max_n_kv = max_n_kv;
 
     if (ctx == nullptr || max_n_kv <= 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "canary_qwen step: invalid arg (max_n_kv=%d)", max_n_kv);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "canary_qwen step: invalid arg (max_n_kv=%d)", max_n_kv);
         return sb;
     }
     if (kv_cache.self_k == nullptr) {
@@ -269,9 +261,8 @@ StepBuild build_step_graph(ggml_context *                  ctx,
         return sb;
     }
     if (max_n_kv > kv_cache.n_ctx) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "canary_qwen step: max_n_kv=%d exceeds kv_cache.n_ctx=%d",
-                     max_n_kv, kv_cache.n_ctx);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "canary_qwen step: max_n_kv=%d exceeds kv_cache.n_ctx=%d", max_n_kv,
+                kv_cache.n_ctx);
         return sb;
     }
 
@@ -299,33 +290,21 @@ StepBuild build_step_graph(ggml_context *                  ctx,
 
     ggml_cgraph * gf = ggml_new_graph_custom(ctx, /*size=*/8192, /*grads=*/false);
     if (gf == nullptr) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "canary_qwen step: ggml_new_graph_custom failed");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "canary_qwen step: ggml_new_graph_custom failed");
         return sb;
     }
     sb.graph = gf;
 
-    ggml_tensor * x = ggml_get_rows(ctx, weights.dec_embed.token_w,
-                                    sb.input_id_in);
+    ggml_tensor * x = ggml_get_rows(ctx, weights.dec_embed.token_w, sb.input_id_in);
 
     for (int il = 0; il < n_layer; ++il) {
-        x = causal_lm::block_step(
-            ctx, gf, x,
-            to_block_view(weights.dec_blocks[il]),
-            block_params,
-            kv_cache,
-            il,
-            max_n_kv,
-            sb.mask_in,
-            sb.position_in,
-            sb.kv_idx_in,
-            use_flash);
+        x = causal_lm::block_step(ctx, gf, x, to_block_view(weights.dec_blocks[il]), block_params, kv_cache, il,
+                                  max_n_kv, sb.mask_in, sb.position_in, sb.kv_idx_in, use_flash);
     }
 
-    x = ggml_mul(ctx, ggml_rms_norm(ctx, x, rms_eps),
-                 weights.dec_final.norm_w);
+    x                    = ggml_mul(ctx, ggml_rms_norm(ctx, x, rms_eps), weights.dec_final.norm_w);
     ggml_tensor * logits = ggml_mul_mat(ctx, weights.dec_embed.token_w, x);
-    logits = ggml_reshape_1d(ctx, logits, vocab);
+    logits               = ggml_reshape_1d(ctx, logits, vocab);
     ggml_set_name(logits, "step.logits");
 
     ggml_tensor * amax = ggml_argmax(ctx, logits);
@@ -343,44 +322,38 @@ StepBuild build_step_graph(ggml_context *                  ctx,
 
 // Batched prefill / step (offline transcribe_run_batch)
 
-PrefillBuildBatched build_prefill_graph_batched(
-    ggml_context *                  ctx,
-    const CanaryQwenWeights &       weights,
-    const CanaryQwenHParams &       hp,
-    transcribe::causal_lm::KvCache & kv_cache,
-    int                             T_prompt_max,
-    int                             T_audio_max,
-    int                             n_batch,
-    bool                            use_flash)
-{
-    PrefillBuildBatched pb {};
+PrefillBuildBatched build_prefill_graph_batched(ggml_context *                   ctx,
+                                                const CanaryQwenWeights &        weights,
+                                                const CanaryQwenHParams &        hp,
+                                                transcribe::causal_lm::KvCache & kv_cache,
+                                                int                              T_prompt_max,
+                                                int                              T_audio_max,
+                                                int                              n_batch,
+                                                bool                             use_flash) {
+    PrefillBuildBatched pb{};
     pb.T_prompt_max = T_prompt_max;
     pb.T_audio_max  = T_audio_max;
     pb.n_batch      = n_batch;
 
-    if (ctx == nullptr || T_prompt_max <= 0 || T_audio_max <= 0 ||
-        n_batch <= 0 || !use_flash ||
-        kv_cache.self_k == nullptr || kv_cache.n_batch != n_batch ||
-        T_prompt_max > kv_cache.n_ctx) {
+    if (ctx == nullptr || T_prompt_max <= 0 || T_audio_max <= 0 || n_batch <= 0 || !use_flash ||
+        kv_cache.self_k == nullptr || kv_cache.n_batch != n_batch || T_prompt_max > kv_cache.n_ctx) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "canary_qwen prefill(batched): invalid arg");
         return pb;
     }
 
-    const int64_t hidden  = hp.dec_hidden;
-    const int64_t vocab   = hp.dec_vocab_size;
-    const int     n_layer = hp.dec_n_layers;
-    const float   rms_eps = hp.dec_rms_norm_eps;
-    const int     B       = n_batch;
-    const auto block_params = to_block_params(hp);
+    const int64_t hidden       = hp.dec_hidden;
+    const int64_t vocab        = hp.dec_vocab_size;
+    const int     n_layer      = hp.dec_n_layers;
+    const float   rms_eps      = hp.dec_rms_norm_eps;
+    const int     B            = n_batch;
+    const auto    block_params = to_block_params(hp);
 
     pb.input_ids_in = ggml_new_tensor_2d(ctx, GGML_TYPE_I32, T_prompt_max, B);
     ggml_set_input(pb.input_ids_in);
     // Audio injection via elementwise blend (no set_rows); see decoder.h.
-    pb.audio_dense_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, hidden,
-                                           static_cast<int64_t>(T_prompt_max) * B);
+    pb.audio_dense_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, hidden, static_cast<int64_t>(T_prompt_max) * B);
     ggml_set_input(pb.audio_dense_in);
-    pb.keep_mask_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, 1,
-                                         static_cast<int64_t>(T_prompt_max) * B);
+    pb.keep_mask_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, 1, static_cast<int64_t>(T_prompt_max) * B);
     ggml_set_input(pb.keep_mask_in);
     pb.positions_in = ggml_new_tensor_1d(ctx, GGML_TYPE_I32, T_prompt_max);
     ggml_set_input(pb.positions_in);
@@ -392,64 +365,61 @@ PrefillBuildBatched build_prefill_graph_batched(
     ggml_set_input(pb.last_idx_in);
 
     ggml_cgraph * gf = ggml_new_graph_custom(ctx, /*size=*/16384, /*grads=*/false);
-    if (gf == nullptr) return pb;
+    if (gf == nullptr) {
+        return pb;
+    }
     pb.graph = gf;
 
-    ggml_tensor * ids_flat =
-        ggml_reshape_1d(ctx, pb.input_ids_in,
-                        static_cast<int64_t>(T_prompt_max) * B);
+    ggml_tensor * ids_flat = ggml_reshape_1d(ctx, pb.input_ids_in, static_cast<int64_t>(T_prompt_max) * B);
     // x = x*keep_mask + audio_dense (keep_mask broadcasts over hidden), then
     // reshape to 3D for the batched block stack.
-    ggml_tensor * x = ggml_get_rows(ctx, weights.dec_embed.token_w, ids_flat);
-    x = ggml_add(ctx, ggml_mul(ctx, x, pb.keep_mask_in), pb.audio_dense_in);
-    x = ggml_reshape_3d(ctx, x, hidden, T_prompt_max, B);
+    ggml_tensor * x        = ggml_get_rows(ctx, weights.dec_embed.token_w, ids_flat);
+    x                      = ggml_add(ctx, ggml_mul(ctx, x, pb.keep_mask_in), pb.audio_dense_in);
+    x                      = ggml_reshape_3d(ctx, x, hidden, T_prompt_max, B);
 
     for (int il = 0; il < n_layer; ++il) {
-        x = causal_lm::block_prefill_batched(
-            ctx, gf, x, to_block_view(weights.dec_blocks[il]),
-            block_params, kv_cache, il, T_prompt_max, B,
-            pb.mask_in, pb.positions_in, pb.kv_idx_in, use_flash);
-        if (x == nullptr) { pb.graph = nullptr; return pb; }
+        x = causal_lm::block_prefill_batched(ctx, gf, x, to_block_view(weights.dec_blocks[il]), block_params, kv_cache,
+                                             il, T_prompt_max, B, pb.mask_in, pb.positions_in, pb.kv_idx_in, use_flash);
+        if (x == nullptr) {
+            pb.graph = nullptr;
+            return pb;
+        }
     }
 
     ggml_tensor * x_last = ggml_get_rows(ctx, x, pb.last_idx_in);
-    x_last = ggml_reshape_2d(ctx, x_last, hidden, B);
-    x_last = ggml_mul(ctx, ggml_rms_norm(ctx, x_last, rms_eps),
-                      weights.dec_final.norm_w);
+    x_last               = ggml_reshape_2d(ctx, x_last, hidden, B);
+    x_last               = ggml_mul(ctx, ggml_rms_norm(ctx, x_last, rms_eps), weights.dec_final.norm_w);
     ggml_tensor * logits = ggml_mul_mat(ctx, weights.dec_embed.token_w, x_last);
-    logits = ggml_reshape_2d(ctx, logits, vocab, B);
-    pb.logits = logits;
-    pb.out = ggml_argmax(ctx, logits);
+    logits               = ggml_reshape_2d(ctx, logits, vocab, B);
+    pb.logits            = logits;
+    pb.out               = ggml_argmax(ctx, logits);
     ggml_set_output(pb.out);
     ggml_build_forward_expand(gf, pb.out);
     ggml_build_forward_expand(gf, logits);
     return pb;
 }
 
-StepBuildBatched build_step_graph_batched(
-    ggml_context *                  ctx,
-    const CanaryQwenWeights &       weights,
-    const CanaryQwenHParams &       hp,
-    transcribe::causal_lm::KvCache & kv_cache,
-    int                             max_n_kv,
-    int                             n_batch,
-    bool                            use_flash)
-{
-    StepBuildBatched sb {};
+StepBuildBatched build_step_graph_batched(ggml_context *                   ctx,
+                                          const CanaryQwenWeights &        weights,
+                                          const CanaryQwenHParams &        hp,
+                                          transcribe::causal_lm::KvCache & kv_cache,
+                                          int                              max_n_kv,
+                                          int                              n_batch,
+                                          bool                             use_flash) {
+    StepBuildBatched sb{};
     sb.max_n_kv = max_n_kv;
     sb.n_batch  = n_batch;
-    if (ctx == nullptr || max_n_kv <= 0 || n_batch <= 0 || !use_flash ||
-        kv_cache.self_k == nullptr || kv_cache.n_batch != n_batch ||
-        max_n_kv > kv_cache.n_ctx) {
+    if (ctx == nullptr || max_n_kv <= 0 || n_batch <= 0 || !use_flash || kv_cache.self_k == nullptr ||
+        kv_cache.n_batch != n_batch || max_n_kv > kv_cache.n_ctx) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "canary_qwen step(batched): invalid arg");
         return sb;
     }
 
-    const int64_t vocab   = hp.dec_vocab_size;
-    const int     n_layer = hp.dec_n_layers;
-    const float   rms_eps = hp.dec_rms_norm_eps;
-    const int     B       = n_batch;
-    const auto block_params = to_block_params(hp);
+    const int64_t vocab        = hp.dec_vocab_size;
+    const int     n_layer      = hp.dec_n_layers;
+    const float   rms_eps      = hp.dec_rms_norm_eps;
+    const int     B            = n_batch;
+    const auto    block_params = to_block_params(hp);
 
     sb.input_ids_in = ggml_new_tensor_1d(ctx, GGML_TYPE_I32, B);
     ggml_set_input(sb.input_ids_in);
@@ -461,28 +431,31 @@ StepBuildBatched build_step_graph_batched(
     ggml_set_input(sb.mask_in);
 
     ggml_cgraph * gf = ggml_new_graph_custom(ctx, /*size=*/8192, /*grads=*/false);
-    if (gf == nullptr) return sb;
+    if (gf == nullptr) {
+        return sb;
+    }
     sb.graph = gf;
 
     ggml_tensor * x = ggml_get_rows(ctx, weights.dec_embed.token_w,
                                     sb.input_ids_in);  // [hidden, B]
     for (int il = 0; il < n_layer; ++il) {
-        x = causal_lm::block_step_batched(
-            ctx, gf, x, to_block_view(weights.dec_blocks[il]),
-            block_params, kv_cache, il, max_n_kv, B,
-            sb.mask_in, sb.position_in, sb.kv_idx_in, use_flash);
-        if (x == nullptr) { sb.graph = nullptr; return sb; }
+        x = causal_lm::block_step_batched(ctx, gf, x, to_block_view(weights.dec_blocks[il]), block_params, kv_cache, il,
+                                          max_n_kv, B, sb.mask_in, sb.position_in, sb.kv_idx_in, use_flash);
+        if (x == nullptr) {
+            sb.graph = nullptr;
+            return sb;
+        }
     }
 
-    x = ggml_mul(ctx, ggml_rms_norm(ctx, x, rms_eps), weights.dec_final.norm_w);
+    x                    = ggml_mul(ctx, ggml_rms_norm(ctx, x, rms_eps), weights.dec_final.norm_w);
     ggml_tensor * logits = ggml_mul_mat(ctx, weights.dec_embed.token_w, x);
-    logits = ggml_reshape_2d(ctx, logits, vocab, B);
-    sb.logits = logits;
-    sb.out = ggml_argmax(ctx, logits);
+    logits               = ggml_reshape_2d(ctx, logits, vocab, B);
+    sb.logits            = logits;
+    sb.out               = ggml_argmax(ctx, logits);
     ggml_set_output(sb.out);
     ggml_build_forward_expand(gf, sb.out);
     ggml_build_forward_expand(gf, logits);
     return sb;
 }
 
-} // namespace transcribe::canary_qwen
+}  // namespace transcribe::canary_qwen
diff --git a/src/arch/canary_qwen/decoder.h b/src/arch/canary_qwen/decoder.h
index cd4082cc..b788bbe5 100644
--- a/src/arch/canary_qwen/decoder.h
+++ b/src/arch/canary_qwen/decoder.h
@@ -12,9 +12,8 @@
 
 #include "canary_qwen.h"
 #include "causal_lm/causal_lm.h"
-#include "weights.h"
-
 #include "ggml.h"
+#include "weights.h"
 
 struct ggml_context;
 struct ggml_cgraph;
@@ -26,10 +25,10 @@ struct DecoderDumps {
     ggml_tensor * token_emb       = nullptr;
     ggml_tensor * audio_injected  = nullptr;
     ggml_tensor * block_0_out     = nullptr;
-    ggml_tensor * block_mid_out   = nullptr;   // dec.block.{n_layers/2}
-    ggml_tensor * block_last_out  = nullptr;   // dec.block.{n_layers-1}
+    ggml_tensor * block_mid_out   = nullptr;  // dec.block.{n_layers/2}
+    ggml_tensor * block_last_out  = nullptr;  // dec.block.{n_layers-1}
     ggml_tensor * out_before_head = nullptr;
-    ggml_tensor * logits_raw      = nullptr;   // dec.logits_raw.gen0
+    ggml_tensor * logits_raw      = nullptr;  // dec.logits_raw.gen0
 };
 
 struct PrefillBuild {
@@ -38,8 +37,8 @@ struct PrefillBuild {
     ggml_tensor * positions_in = nullptr;  // [T_prompt] i32
     ggml_tensor * mask_in      = nullptr;  // [T_prompt, T_prompt] f16
     ggml_tensor * out          = nullptr;  // [vocab] f32
-    DecoderDumps  dumps {};
-    ggml_cgraph * graph        = nullptr;
+    DecoderDumps  dumps{};
+    ggml_cgraph * graph = nullptr;
 
     int T_prompt   = 0;
     int T_audio    = 0;
@@ -47,16 +46,16 @@ struct PrefillBuild {
     int suffix_len = 0;
 };
 
-PrefillBuild build_prefill_graph(ggml_context *                  ctx,
-                                 const CanaryQwenWeights &       weights,
-                                 const CanaryQwenHParams &       hp,
+PrefillBuild build_prefill_graph(ggml_context *                   ctx,
+                                 const CanaryQwenWeights &        weights,
+                                 const CanaryQwenHParams &        hp,
                                  transcribe::causal_lm::KvCache & kv_cache,
-                                 int                             T_prompt,
-                                 int                             T_audio,
-                                 int                             prefix_len,
-                                 int                             suffix_len,
-                                 bool                            use_flash,
-                                 bool                            slice_last);
+                                 int                              T_prompt,
+                                 int                              T_audio,
+                                 int                              prefix_len,
+                                 int                              suffix_len,
+                                 bool                             use_flash,
+                                 bool                             slice_last);
 
 struct StepBuild {
     ggml_tensor * input_id_in = nullptr;  // [1] i32
@@ -70,19 +69,19 @@ struct StepBuild {
     int max_n_kv = 0;
 };
 
-StepBuild build_step_graph(ggml_context *                  ctx,
-                           const CanaryQwenWeights &       weights,
-                           const CanaryQwenHParams &       hp,
+StepBuild build_step_graph(ggml_context *                   ctx,
+                           const CanaryQwenWeights &        weights,
+                           const CanaryQwenHParams &        hp,
                            transcribe::causal_lm::KvCache & kv_cache,
-                           int                             max_n_kv,
-                           bool                            use_flash);
+                           int                              max_n_kv,
+                           bool                             use_flash);
 
 // ---------- Batched prefill / step (offline transcribe_run_batch) ----------
 // Mirror arch/qwen3_asr + arch/funasr_nano; audio block is the perception
 // output. See causal_lm::block_prefill_batched / block_step_batched.
 
 struct PrefillBuildBatched {
-    ggml_tensor * input_ids_in = nullptr;  // [T_prompt_max, B] i32
+    ggml_tensor * input_ids_in   = nullptr;  // [T_prompt_max, B] i32
     // Audio injection via elementwise blend (no set_rows): audio_dense holds the
     // audio embeds scattered host-side into their prompt positions (zero
     // elsewhere), keep_mask is 0 there and 1 elsewhere, block input is
@@ -90,27 +89,26 @@ struct PrefillBuildBatched {
     // (forced by k-quant token_embd get_rows) cleanly, unlike a set_rows.
     ggml_tensor * audio_dense_in = nullptr;  // [hidden, T_prompt_max*B] f32
     ggml_tensor * keep_mask_in   = nullptr;  // [1, T_prompt_max*B] f32 (0=audio,1=keep)
-    ggml_tensor * positions_in = nullptr;  // [T_prompt_max] i32
-    ggml_tensor * mask_in      = nullptr;  // [T_prompt_max, T_prompt_max] f16
-    ggml_tensor * kv_idx_in    = nullptr;  // [T_prompt_max, B] i64
-    ggml_tensor * last_idx_in  = nullptr;  // [1, B] i32
-    ggml_tensor * logits       = nullptr;  // [vocab, B]
-    ggml_tensor * out          = nullptr;  // [B] i32 argmax
-    ggml_cgraph * graph        = nullptr;
-    int T_prompt_max = 0;
-    int T_audio_max  = 0;
-    int n_batch      = 0;
+    ggml_tensor * positions_in   = nullptr;  // [T_prompt_max] i32
+    ggml_tensor * mask_in        = nullptr;  // [T_prompt_max, T_prompt_max] f16
+    ggml_tensor * kv_idx_in      = nullptr;  // [T_prompt_max, B] i64
+    ggml_tensor * last_idx_in    = nullptr;  // [1, B] i32
+    ggml_tensor * logits         = nullptr;  // [vocab, B]
+    ggml_tensor * out            = nullptr;  // [B] i32 argmax
+    ggml_cgraph * graph          = nullptr;
+    int           T_prompt_max   = 0;
+    int           T_audio_max    = 0;
+    int           n_batch        = 0;
 };
 
-PrefillBuildBatched build_prefill_graph_batched(
-    ggml_context *                  ctx,
-    const CanaryQwenWeights &       weights,
-    const CanaryQwenHParams &       hp,
-    transcribe::causal_lm::KvCache & kv_cache,
-    int                             T_prompt_max,
-    int                             T_audio_max,
-    int                             n_batch,
-    bool                            use_flash);
+PrefillBuildBatched build_prefill_graph_batched(ggml_context *                   ctx,
+                                                const CanaryQwenWeights &        weights,
+                                                const CanaryQwenHParams &        hp,
+                                                transcribe::causal_lm::KvCache & kv_cache,
+                                                int                              T_prompt_max,
+                                                int                              T_audio_max,
+                                                int                              n_batch,
+                                                bool                             use_flash);
 
 struct StepBuildBatched {
     ggml_tensor * input_ids_in = nullptr;  // [B] i32
@@ -120,17 +118,16 @@ struct StepBuildBatched {
     ggml_tensor * logits       = nullptr;  // [vocab, B]
     ggml_tensor * out          = nullptr;  // [B] i32 argmax
     ggml_cgraph * graph        = nullptr;
-    int max_n_kv = 0;
-    int n_batch  = 0;
+    int           max_n_kv     = 0;
+    int           n_batch      = 0;
 };
 
-StepBuildBatched build_step_graph_batched(
-    ggml_context *                  ctx,
-    const CanaryQwenWeights &       weights,
-    const CanaryQwenHParams &       hp,
-    transcribe::causal_lm::KvCache & kv_cache,
-    int                             max_n_kv,
-    int                             n_batch,
-    bool                            use_flash);
+StepBuildBatched build_step_graph_batched(ggml_context *                   ctx,
+                                          const CanaryQwenWeights &        weights,
+                                          const CanaryQwenHParams &        hp,
+                                          transcribe::causal_lm::KvCache & kv_cache,
+                                          int                              max_n_kv,
+                                          int                              n_batch,
+                                          bool                             use_flash);
 
-} // namespace transcribe::canary_qwen
+}  // namespace transcribe::canary_qwen
diff --git a/src/arch/canary_qwen/encoder.cpp b/src/arch/canary_qwen/encoder.cpp
index 4eee347f..b434a052 100644
--- a/src/arch/canary_qwen/encoder.cpp
+++ b/src/arch/canary_qwen/encoder.cpp
@@ -13,13 +13,11 @@
 
 #include "encoder.h"
 
-#include "weights.h"
-
 #include "conformer/conformer.h"
+#include "ggml.h"
 #include "transcribe-debug.h"
 #include "transcribe-log.h"
-
-#include "ggml.h"
+#include "weights.h"
 
 #include <cstdio>
 #include <cstdlib>
@@ -32,19 +30,24 @@ namespace {
 namespace conf = transcribe::conformer;
 
 bool detect_direct_dw_in_block(const char * /*backend*/) {
-    return conf::resolve_conv_direct("TRANSCRIBE_CONV_DIRECT_DW",
-                                     "TRANSCRIBE_CONV_NO_DIRECT_DW",
+    return conf::resolve_conv_direct("TRANSCRIBE_CONV_DIRECT_DW", "TRANSCRIBE_CONV_NO_DIRECT_DW",
                                      /*backend_default=*/true);
 }
 
 conf::PreEncodeView to_view(const PreEncodeSlots & pe) {
     conf::PreEncodeView v;
-    v.conv0_w = pe.conv0_w; v.conv0_b = pe.conv0_b;
-    v.conv2_w = pe.conv2_w; v.conv2_b = pe.conv2_b;
-    v.conv3_w = pe.conv3_w; v.conv3_b = pe.conv3_b;
-    v.conv5_w = pe.conv5_w; v.conv5_b = pe.conv5_b;
-    v.conv6_w = pe.conv6_w; v.conv6_b = pe.conv6_b;
-    v.out_w   = pe.out_w;   v.out_b   = pe.out_b;
+    v.conv0_w = pe.conv0_w;
+    v.conv0_b = pe.conv0_b;
+    v.conv2_w = pe.conv2_w;
+    v.conv2_b = pe.conv2_b;
+    v.conv3_w = pe.conv3_w;
+    v.conv3_b = pe.conv3_b;
+    v.conv5_w = pe.conv5_w;
+    v.conv5_b = pe.conv5_b;
+    v.conv6_w = pe.conv6_w;
+    v.conv6_b = pe.conv6_b;
+    v.out_w   = pe.out_w;
+    v.out_b   = pe.out_b;
     return v;
 }
 
@@ -53,83 +56,94 @@ conf::BlockView to_view(const EncBlockSlots & b) {
 
     v.norm_ff1_w = b.norm_ff1_w;
     v.norm_ff1_b = b.norm_ff1_b;
-    v.ff1_lin1_w = b.ff1_lin1_w; v.ff1_lin1_b = b.ff1_lin1_b;
-    v.ff1_lin2_w = b.ff1_lin2_w; v.ff1_lin2_b = b.ff1_lin2_b;
+    v.ff1_lin1_w = b.ff1_lin1_w;
+    v.ff1_lin1_b = b.ff1_lin1_b;
+    v.ff1_lin2_w = b.ff1_lin2_w;
+    v.ff1_lin2_b = b.ff1_lin2_b;
 
     v.norm_attn_w = b.norm_attn_w;
     v.norm_attn_b = b.norm_attn_b;
-    v.attn_q_w    = b.attn_q_w;   v.attn_q_b   = b.attn_q_b;
-    v.attn_k_w    = b.attn_k_w;   v.attn_k_b   = b.attn_k_b;
-    v.attn_v_w    = b.attn_v_w;   v.attn_v_b   = b.attn_v_b;
-    v.attn_out_w  = b.attn_out_w; v.attn_out_b = b.attn_out_b;
+    v.attn_q_w    = b.attn_q_w;
+    v.attn_q_b    = b.attn_q_b;
+    v.attn_k_w    = b.attn_k_w;
+    v.attn_k_b    = b.attn_k_b;
+    v.attn_v_w    = b.attn_v_w;
+    v.attn_v_b    = b.attn_v_b;
+    v.attn_out_w  = b.attn_out_w;
+    v.attn_out_b  = b.attn_out_b;
     v.attn_pos_w  = b.attn_pos_w;
     v.attn_pos_u  = b.attn_pos_u;
     v.attn_pos_v  = b.attn_pos_v;
 
     v.norm_conv_w         = b.norm_conv_w;
     v.norm_conv_b         = b.norm_conv_b;
-    v.conv_pw1_w          = b.conv_pw1_w; v.conv_pw1_b = b.conv_pw1_b;
-    v.conv_dw_w           = b.conv_dw_w;  v.conv_dw_b  = b.conv_dw_b;
-    v.conv_pw2_w          = b.conv_pw2_w; v.conv_pw2_b = b.conv_pw2_b;
+    v.conv_pw1_w          = b.conv_pw1_w;
+    v.conv_pw1_b          = b.conv_pw1_b;
+    v.conv_dw_w           = b.conv_dw_w;
+    v.conv_dw_b           = b.conv_dw_b;
+    v.conv_pw2_w          = b.conv_pw2_w;
+    v.conv_pw2_b          = b.conv_pw2_b;
     v.conv_bn_fused_scale = b.conv_bn_fused_scale;
     v.conv_bn_fused_bias  = b.conv_bn_fused_bias;
 
     v.norm_ff2_w = b.norm_ff2_w;
     v.norm_ff2_b = b.norm_ff2_b;
-    v.ff2_lin1_w = b.ff2_lin1_w; v.ff2_lin1_b = b.ff2_lin1_b;
-    v.ff2_lin2_w = b.ff2_lin2_w; v.ff2_lin2_b = b.ff2_lin2_b;
+    v.ff2_lin1_w = b.ff2_lin1_w;
+    v.ff2_lin1_b = b.ff2_lin1_b;
+    v.ff2_lin2_w = b.ff2_lin2_w;
+    v.ff2_lin2_b = b.ff2_lin2_b;
 
     v.norm_out_w = b.norm_out_w;
     v.norm_out_b = b.norm_out_b;
     return v;
 }
 
-} // namespace
-
-EncoderBuild build_encoder_graph(ggml_context *             ctx,
-                                 const CanaryQwenWeights &  w,
-                                 const CanaryQwenHParams &  hp,
-                                 int                        n_mel_frames,
-                                 ggml_type                  kv_type,
-                                 bool                       use_flash,
-                                 const char *               backend_name)
-{
-    conf::ConvPolicy policy {};
+}  // namespace
+
+EncoderBuild build_encoder_graph(ggml_context *            ctx,
+                                 const CanaryQwenWeights & w,
+                                 const CanaryQwenHParams & hp,
+                                 int                       n_mel_frames,
+                                 ggml_type                 kv_type,
+                                 bool                      use_flash,
+                                 const char *              backend_name) {
+    conf::ConvPolicy policy{};
     policy.direct_pw               = conf::detect_direct_pw(backend_name);
     policy.direct_dw_in_block      = detect_direct_dw_in_block(backend_name);
     policy.direct_dw_in_pre_encode = false;
 
-    EncoderBuild eb {};
+    EncoderBuild eb{};
 
     if (ctx == nullptr || n_mel_frames <= 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "canary_qwen encoder: invalid arg (ctx=%p, n_mel_frames=%d)",
-                     static_cast<void *>(ctx), n_mel_frames);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "canary_qwen encoder: invalid arg (ctx=%p, n_mel_frames=%d)",
+                static_cast<void *>(ctx), n_mel_frames);
         return eb;
     }
 
     if (hp.enc_subsampling_factor != 8 || hp.fe_num_mels != 128) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "canary_qwen encoder: unsupported geometry "
-                     "subsampling_factor=%d num_mels=%d",
-                     hp.enc_subsampling_factor, hp.fe_num_mels);
+                "canary_qwen encoder: unsupported geometry "
+                "subsampling_factor=%d num_mels=%d",
+                hp.enc_subsampling_factor, hp.fe_num_mels);
         return eb;
     }
 
     // Mel input.
-    eb.mel_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32,
-                                   n_mel_frames, hp.fe_num_mels);
-    if (eb.mel_in == nullptr) return eb;
+    eb.mel_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, n_mel_frames, hp.fe_num_mels);
+    if (eb.mel_in == nullptr) {
+        return eb;
+    }
     ggml_set_name(eb.mel_in, "mel.in");
     ggml_set_input(eb.mel_in);
     eb.dumps.mel_in = eb.mel_in;
 
     // Pre-encode.
-    ggml_tensor * x = conf::build_pre_encode(ctx, to_view(w.pre_encode),
-                                             eb.mel_in, policy,
+    ggml_tensor * x = conf::build_pre_encode(ctx, to_view(w.pre_encode), eb.mel_in, policy,
                                              /*name_prefix=*/"enc.pre_encode",
                                              /*error_tag=*/"canary_qwen");
-    if (x == nullptr) return eb;
+    if (x == nullptr) {
+        return eb;
+    }
     eb.dumps.pre_encode_out = x;
     transcribe::debug::mark_tensor_for_dump(x);
 
@@ -137,13 +151,12 @@ EncoderBuild build_encoder_graph(ggml_context *             ctx,
         const int64_t T_enc   = x->ne[1];
         const int64_t pos_len = 2 * T_enc - 1;
 
-        eb.pos_emb_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32,
-                                           hp.enc_d_model, pos_len);
+        eb.pos_emb_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, hp.enc_d_model, pos_len);
         ggml_set_name(eb.pos_emb_in, "pos_emb.in");
         ggml_set_input(eb.pos_emb_in);
         eb.dumps.pos_emb = eb.pos_emb_in;
 
-        conf::BlockParams bparams {};
+        conf::BlockParams bparams{};
         bparams.d_model     = hp.enc_d_model;
         bparams.n_head      = hp.enc_n_heads;
         bparams.conv_kernel = hp.enc_conv_kernel;
@@ -154,27 +167,25 @@ EncoderBuild build_encoder_graph(ggml_context *             ctx,
         const int mid_idx = hp.enc_n_layers / 2;
 
         // Block 0
-        x = conf::build_conformer_block(ctx, x, eb.pos_emb_in,
-                                        to_view(w.blocks[0]), bparams);
-        x = conf::named(x, "enc.block.0.out");
+        x                   = conf::build_conformer_block(ctx, x, eb.pos_emb_in, to_view(w.blocks[0]), bparams);
+        x                   = conf::named(x, "enc.block.0.out");
         eb.dumps.block0_out = x;
         transcribe::debug::mark_tensor_for_dump(x);
 
         // Blocks 1..N-1
         for (size_t i = 1; i < w.blocks.size(); ++i) {
-            x = conf::build_conformer_block(ctx, x, eb.pos_emb_in,
-                                            to_view(w.blocks[i]), bparams);
+            x = conf::build_conformer_block(ctx, x, eb.pos_emb_in, to_view(w.blocks[i]), bparams);
             if (i == static_cast<size_t>(mid_idx)) {
                 char bname[64];
                 std::snprintf(bname, sizeof(bname), "enc.block.%zu.out", i);
-                x = conf::named(x, bname);
+                x                      = conf::named(x, bname);
                 eb.dumps.block_mid_out = x;
                 transcribe::debug::mark_tensor_for_dump(x);
             }
             if (i == w.blocks.size() - 1) {
                 char bname[64];
                 std::snprintf(bname, sizeof(bname), "enc.block.%zu.out", i);
-                x = conf::named(x, bname);
+                x                       = conf::named(x, bname);
                 eb.dumps.block_last_out = x;
                 transcribe::debug::mark_tensor_for_dump(x);
             }
@@ -188,9 +199,9 @@ EncoderBuild build_encoder_graph(ggml_context *             ctx,
     // (T_enc, d_model). Permute + cont so the dumped shape matches
     // reference exactly (and so compare_tensors stops flagging SHAPE).
     {
-        ggml_tensor * final_ct = ggml_cont(ctx, ggml_permute(ctx, x, 1, 0, 2, 3));
+        ggml_tensor * final_ct    = ggml_cont(ctx, ggml_permute(ctx, x, 1, 0, 2, 3));
         ggml_tensor * named_final = conf::named(final_ct, "enc.final");
-        eb.dumps.final_out = named_final;
+        eb.dumps.final_out        = named_final;
         transcribe::debug::mark_tensor_for_dump(named_final);
     }
 
@@ -205,7 +216,7 @@ EncoderBuild build_encoder_graph(ggml_context *             ctx,
         if (w.perception_proj.bias != nullptr) {
             proj = ggml_add(ctx, proj, w.perception_proj.bias);
         }
-        x = conf::named(proj, "perception.proj.out");
+        x                       = conf::named(proj, "perception.proj.out");
         eb.dumps.perception_out = x;
         transcribe::debug::mark_tensor_for_dump(x);
     }
@@ -232,4 +243,4 @@ EncoderBuild build_encoder_graph(ggml_context *             ctx,
     return eb;
 }
 
-} // namespace transcribe::canary_qwen
+}  // namespace transcribe::canary_qwen
diff --git a/src/arch/canary_qwen/encoder.h b/src/arch/canary_qwen/encoder.h
index ee4033cb..23def1f2 100644
--- a/src/arch/canary_qwen/encoder.h
+++ b/src/arch/canary_qwen/encoder.h
@@ -18,30 +18,30 @@ struct CanaryQwenHParams;
 struct CanaryQwenWeights;
 
 struct EncoderDumps {
-    ggml_tensor * mel_in          = nullptr;
-    ggml_tensor * pre_encode_out  = nullptr;
-    ggml_tensor * pos_emb         = nullptr;
-    ggml_tensor * block0_out      = nullptr;
-    ggml_tensor * block_mid_out   = nullptr;   // block n_layers/2
-    ggml_tensor * block_last_out  = nullptr;   // block n_layers-1
-    ggml_tensor * final_out       = nullptr;   // post-encoder, pre-projection
-    ggml_tensor * perception_out  = nullptr;   // post Linear(1024, 2048)
+    ggml_tensor * mel_in         = nullptr;
+    ggml_tensor * pre_encode_out = nullptr;
+    ggml_tensor * pos_emb        = nullptr;
+    ggml_tensor * block0_out     = nullptr;
+    ggml_tensor * block_mid_out  = nullptr;  // block n_layers/2
+    ggml_tensor * block_last_out = nullptr;  // block n_layers-1
+    ggml_tensor * final_out      = nullptr;  // post-encoder, pre-projection
+    ggml_tensor * perception_out = nullptr;  // post Linear(1024, 2048)
 };
 
 struct EncoderBuild {
     ggml_tensor * mel_in     = nullptr;
     ggml_tensor * pos_emb_in = nullptr;
-    ggml_tensor * out        = nullptr;   // perception_out
-    EncoderDumps  dumps {};
-    ggml_cgraph * graph      = nullptr;
+    ggml_tensor * out        = nullptr;  // perception_out
+    EncoderDumps  dumps{};
+    ggml_cgraph * graph = nullptr;
 };
 
-EncoderBuild build_encoder_graph(ggml_context *             ctx,
-                                 const CanaryQwenWeights &  weights,
-                                 const CanaryQwenHParams &  hp,
-                                 int                        n_mel_frames,
-                                 ggml_type                  kv_type      = GGML_TYPE_COUNT,
-                                 bool                       use_flash    = false,
-                                 const char *               backend_name = "");
+EncoderBuild build_encoder_graph(ggml_context *            ctx,
+                                 const CanaryQwenWeights & weights,
+                                 const CanaryQwenHParams & hp,
+                                 int                       n_mel_frames,
+                                 ggml_type                 kv_type      = GGML_TYPE_COUNT,
+                                 bool                      use_flash    = false,
+                                 const char *              backend_name = "");
 
-} // namespace transcribe::canary_qwen
+}  // namespace transcribe::canary_qwen
diff --git a/src/arch/canary_qwen/model.cpp b/src/arch/canary_qwen/model.cpp
index 1d8cd953..35de0274 100644
--- a/src/arch/canary_qwen/model.cpp
+++ b/src/arch/canary_qwen/model.cpp
@@ -18,12 +18,13 @@
 // (matches the reference's f32 regime); see promote_linears_bf16_to_f32_on_cpu.
 
 #include "canary_qwen.h"
-
+#include "causal_lm/causal_lm.h"
 #include "decoder.h"
 #include "encoder.h"
-#include "weights.h"
-
-#include "causal_lm/causal_lm.h"
+#include "ggml-alloc.h"
+#include "ggml-backend.h"
+#include "ggml.h"
+#include "gguf.h"
 #include "transcribe-arch.h"
 #include "transcribe-batch-util.h"
 #include "transcribe-debug.h"
@@ -34,11 +35,7 @@
 #include "transcribe-log.h"
 #include "transcribe-mel.h"
 #include "transcribe-meta.h"
-
-#include "ggml.h"
-#include "ggml-alloc.h"
-#include "ggml-backend.h"
-#include "gguf.h"
+#include "weights.h"
 
 #include <algorithm>
 #include <cmath>
@@ -57,7 +54,7 @@ namespace transcribe::canary_qwen {
 
 extern const Arch arch;
 
-static_assert(std::is_base_of_v<transcribe_model,   CanaryQwenModel>);
+static_assert(std::is_base_of_v<transcribe_model, CanaryQwenModel>);
 static_assert(std::is_base_of_v<transcribe_session, CanaryQwenSession>);
 
 CanaryQwenSession::~CanaryQwenSession() {
@@ -107,9 +104,7 @@ CanaryQwenModel::~CanaryQwenModel() {
         linear_f32_ctx = nullptr;
     }
     packed_gate_up.free();
-    for (auto it = plan.scheduler_list.rbegin();
-         it != plan.scheduler_list.rend(); ++it)
-    {
+    for (auto it = plan.scheduler_list.rbegin(); it != plan.scheduler_list.rend(); ++it) {
         ggml_backend_free(*it);
     }
     plan.scheduler_list.clear();
@@ -120,7 +115,7 @@ CanaryQwenModel::~CanaryQwenModel() {
 namespace {
 
 constexpr const char k_default_variant[] = "canary-qwen-2.5b";
-constexpr float kBnEps = 1e-5f;
+constexpr float      kBnEps              = 1e-5f;
 
 // Input-length contract (see docs/input-limits.md). canary_qwen is a
 // hard-context-cap family: audio tokens + chat prompt + generation share the
@@ -154,24 +149,21 @@ int canary_qwen_context_ceiling(int32_t n_ctx_knob, const CanaryQwenHParams & hp
 // truncate at the generation budget (transcribe_was_truncated) —
 // max_audio_ms is the input bound.
 int64_t canary_qwen_max_audio_ms(const CanaryQwenHParams & hp) {
-    if (hp.dec_max_position <= 0 || hp.enc_subsampling_factor <= 0 ||
-        hp.fe_hop_length <= 0 || hp.fe_sample_rate <= 0) {
+    if (hp.dec_max_position <= 0 || hp.enc_subsampling_factor <= 0 || hp.fe_hop_length <= 0 || hp.fe_sample_rate <= 0) {
         return 0;
     }
     // Representative fixed chat-template overhead (prefix + suffix token
     // counts; ~14 for canary_qwen). Advisory headroom, generous enough to
     // cover small template drift.
     constexpr int k_prompt_overhead = 32;
-    const int max_audio_tokens =
-        hp.dec_max_position - k_prompt_overhead - k_max_new;
+    const int     max_audio_tokens  = hp.dec_max_position - k_prompt_overhead - k_max_new;
     if (max_audio_tokens <= 0) {
         return 0;
     }
     // audio_tokens ≈ mel_frames / subsampling_factor ;
     //   mel_frames = ms * sr / (hop * 1000)
     //   => ms ≈ audio_tokens * subsampling_factor * hop * 1000 / sr
-    const int64_t mel_frames =
-        static_cast<int64_t>(max_audio_tokens) * hp.enc_subsampling_factor;
+    const int64_t mel_frames = static_cast<int64_t>(max_audio_tokens) * hp.enc_subsampling_factor;
     return mel_frames * hp.fe_hop_length * 1000 / hp.fe_sample_rate;
 }
 
@@ -183,10 +175,12 @@ int64_t canary_qwen_max_audio_ms(const CanaryQwenHParams & hp) {
 // suffix at load; the audio_locator id is replicated T_enc times between them
 // at run time.
 
-transcribe_status resolve_chat_tokens(const transcribe::Tokenizer & tok,
-                                      ChatTokens &                  out)
-{
-    struct PieceSlot { const char * piece; int32_t * slot; };
+transcribe_status resolve_chat_tokens(const transcribe::Tokenizer & tok, ChatTokens & out) {
+    struct PieceSlot {
+        const char * piece;
+        int32_t *    slot;
+    };
+
     const PieceSlot pieces[] = {
         { "<|im_start|>", &out.im_start       },
         { "<|im_end|>",   &out.im_end         },
@@ -196,9 +190,7 @@ transcribe_status resolve_chat_tokens(const transcribe::Tokenizer & tok,
     for (const auto & p : pieces) {
         const int id = tok.find(p.piece);
         if (id < 0) {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "canary_qwen: chat-template piece \"%s\" not in tokenizer",
-                         p.piece);
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "canary_qwen: chat-template piece \"%s\" not in tokenizer", p.piece);
             return TRANSCRIBE_ERR_GGUF;
         }
         *p.slot = id;
@@ -209,8 +201,8 @@ transcribe_status resolve_chat_tokens(const transcribe::Tokenizer & tok,
 transcribe_status build_static_prompt_segments(CanaryQwenModel & m) {
     if (!m.tok.has_encoder()) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "canary_qwen: tokenizer has no BPE encoder — cannot "
-                     "tokenize chat template at load time");
+                "canary_qwen: tokenizer has no BPE encoder — cannot "
+                "tokenize chat template at load time");
         return TRANSCRIBE_ERR_GGUF;
     }
 
@@ -219,14 +211,11 @@ transcribe_status build_static_prompt_segments(CanaryQwenModel & m) {
     m.prompt_prefix_ids.push_back(m.chat_tokens.im_start);
     {
         std::vector<int32_t> ids;
-        if (auto st = m.tok.encode("user\nTranscribe the following: ", ids);
-            st != TRANSCRIBE_OK)
-        {
+        if (auto st = m.tok.encode("user\nTranscribe the following: ", ids); st != TRANSCRIBE_OK) {
             log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "canary_qwen: prefix BPE encode failed");
             return st;
         }
-        m.prompt_prefix_ids.insert(m.prompt_prefix_ids.end(),
-                                   ids.begin(), ids.end());
+        m.prompt_prefix_ids.insert(m.prompt_prefix_ids.end(), ids.begin(), ids.end());
     }
 
     // suffix = [<|im_end|>] + bpe("\n") + [<|im_start|>] + bpe("assistant\n")
@@ -234,16 +223,18 @@ transcribe_status build_static_prompt_segments(CanaryQwenModel & m) {
     m.prompt_suffix_ids.push_back(m.chat_tokens.im_end);
     {
         std::vector<int32_t> ids;
-        if (auto st = m.tok.encode("\n", ids); st != TRANSCRIBE_OK) return st;
-        m.prompt_suffix_ids.insert(m.prompt_suffix_ids.end(),
-                                   ids.begin(), ids.end());
+        if (auto st = m.tok.encode("\n", ids); st != TRANSCRIBE_OK) {
+            return st;
+        }
+        m.prompt_suffix_ids.insert(m.prompt_suffix_ids.end(), ids.begin(), ids.end());
     }
     m.prompt_suffix_ids.push_back(m.chat_tokens.im_start);
     {
         std::vector<int32_t> ids;
-        if (auto st = m.tok.encode("assistant\n", ids); st != TRANSCRIBE_OK) return st;
-        m.prompt_suffix_ids.insert(m.prompt_suffix_ids.end(),
-                                   ids.begin(), ids.end());
+        if (auto st = m.tok.encode("assistant\n", ids); st != TRANSCRIBE_OK) {
+            return st;
+        }
+        m.prompt_suffix_ids.insert(m.prompt_suffix_ids.end(), ids.begin(), ids.end());
     }
     return TRANSCRIBE_OK;
 }
@@ -252,44 +243,49 @@ transcribe_status build_static_prompt_segments(CanaryQwenModel & m) {
 // (running_mean, running_var, weight, bias, eps).
 transcribe_status fuse_batch_norm(CanaryQwenModel & m) {
     const size_t n_blocks = m.weights.blocks.size();
-    if (n_blocks == 0) return TRANSCRIBE_OK;
+    if (n_blocks == 0) {
+        return TRANSCRIBE_OK;
+    }
 
-    const int64_t d = m.hparams.enc_d_model;
+    const int64_t d            = m.hparams.enc_d_model;
     const size_t  tensor_bytes = static_cast<size_t>(d) * sizeof(float);
 
-    const size_t ctx_size = n_blocks * 2 * ggml_tensor_overhead() + 256;
-    ggml_init_params params = {ctx_size, nullptr, true};
-    m.bn_fused_ctx = ggml_init(params);
-    if (m.bn_fused_ctx == nullptr) return TRANSCRIBE_ERR_BACKEND;
+    const size_t     ctx_size = n_blocks * 2 * ggml_tensor_overhead() + 256;
+    ggml_init_params params   = { ctx_size, nullptr, true };
+    m.bn_fused_ctx            = ggml_init(params);
+    if (m.bn_fused_ctx == nullptr) {
+        return TRANSCRIBE_ERR_BACKEND;
+    }
 
     for (size_t i = 0; i < n_blocks; ++i) {
-        auto & b = m.weights.blocks[i];
+        auto & b              = m.weights.blocks[i];
         b.conv_bn_fused_scale = ggml_new_tensor_1d(m.bn_fused_ctx, GGML_TYPE_F32, d);
         b.conv_bn_fused_bias  = ggml_new_tensor_1d(m.bn_fused_ctx, GGML_TYPE_F32, d);
     }
 
-    m.bn_fused_buffer = ggml_backend_alloc_ctx_tensors(
-        m.bn_fused_ctx, m.plan.scheduler_list.back());
-    if (m.bn_fused_buffer == nullptr) return TRANSCRIBE_ERR_BACKEND;
+    m.bn_fused_buffer = ggml_backend_alloc_ctx_tensors(m.bn_fused_ctx, m.plan.scheduler_list.back());
+    if (m.bn_fused_buffer == nullptr) {
+        return TRANSCRIBE_ERR_BACKEND;
+    }
 
     std::vector<float> bn_w(d), bn_b(d), rm(d), rv(d);
     std::vector<float> fused_s(d), fused_b(d);
 
     for (size_t i = 0; i < n_blocks; ++i) {
         auto & b = m.weights.blocks[i];
-        ggml_backend_tensor_get(b.conv_bn_w,  bn_w.data(), 0, tensor_bytes);
-        ggml_backend_tensor_get(b.conv_bn_b,  bn_b.data(), 0, tensor_bytes);
-        ggml_backend_tensor_get(b.conv_bn_rm, rm.data(),   0, tensor_bytes);
-        ggml_backend_tensor_get(b.conv_bn_rv, rv.data(),   0, tensor_bytes);
+        ggml_backend_tensor_get(b.conv_bn_w, bn_w.data(), 0, tensor_bytes);
+        ggml_backend_tensor_get(b.conv_bn_b, bn_b.data(), 0, tensor_bytes);
+        ggml_backend_tensor_get(b.conv_bn_rm, rm.data(), 0, tensor_bytes);
+        ggml_backend_tensor_get(b.conv_bn_rv, rv.data(), 0, tensor_bytes);
 
         for (int64_t c = 0; c < d; ++c) {
             const float s = bn_w[c] / std::sqrt(rv[c] + kBnEps);
-            fused_s[c] = s;
-            fused_b[c] = bn_b[c] - rm[c] * s;
+            fused_s[c]    = s;
+            fused_b[c]    = bn_b[c] - rm[c] * s;
         }
 
         ggml_backend_tensor_set(b.conv_bn_fused_scale, fused_s.data(), 0, tensor_bytes);
-        ggml_backend_tensor_set(b.conv_bn_fused_bias,  fused_b.data(), 0, tensor_bytes);
+        ggml_backend_tensor_set(b.conv_bn_fused_bias, fused_b.data(), 0, tensor_bytes);
     }
 
     return TRANSCRIBE_OK;
@@ -304,14 +300,20 @@ transcribe_status fuse_batch_norm(CanaryQwenModel & m) {
 // (load_common::promote_conv_pw_f16_to_f32_on_cpu can't be used — it early-outs
 // on non-CPU backends.)
 transcribe_status promote_conv_pw_to_f32_on_cpu(CanaryQwenModel & m) {
-    if (m.plan.primary == nullptr) return TRANSCRIBE_OK;
+    if (m.plan.primary == nullptr) {
+        return TRANSCRIBE_OK;
+    }
+
+    struct Slot {
+        ggml_tensor ** dst_slot;
+        ggml_tensor *  src;
+    };
 
-    struct Slot { ggml_tensor ** dst_slot; ggml_tensor * src; };
     std::vector<Slot> slots;
     slots.reserve(m.weights.blocks.size() * 3);
     auto add = [&](ggml_tensor ** s) {
         if (s != nullptr && *s != nullptr && (*s)->type == GGML_TYPE_F16) {
-            slots.push_back({s, *s});
+            slots.push_back({ s, *s });
         }
     };
     for (auto & b : m.weights.blocks) {
@@ -319,19 +321,21 @@ transcribe_status promote_conv_pw_to_f32_on_cpu(CanaryQwenModel & m) {
         add(&b.conv_dw_w);
         add(&b.conv_pw2_w);
     }
-    if (slots.empty()) return TRANSCRIBE_OK;
+    if (slots.empty()) {
+        return TRANSCRIBE_OK;
+    }
 
-    const size_t ctx_size = slots.size() * ggml_tensor_overhead() + 256;
-    ggml_init_params init_params = {ctx_size, nullptr, true};
-    m.conv_pw_f32_ctx = ggml_init(init_params);
-    if (m.conv_pw_f32_ctx == nullptr) return TRANSCRIBE_ERR_BACKEND;
+    const size_t     ctx_size    = slots.size() * ggml_tensor_overhead() + 256;
+    ggml_init_params init_params = { ctx_size, nullptr, true };
+    m.conv_pw_f32_ctx            = ggml_init(init_params);
+    if (m.conv_pw_f32_ctx == nullptr) {
+        return TRANSCRIBE_ERR_BACKEND;
+    }
 
     std::vector<ggml_tensor *> replacements;
     replacements.reserve(slots.size());
     for (const auto & s : slots) {
-        ggml_tensor * r = ggml_new_tensor(
-            m.conv_pw_f32_ctx, GGML_TYPE_F32,
-            ggml_n_dims(s.src), s.src->ne);
+        ggml_tensor * r = ggml_new_tensor(m.conv_pw_f32_ctx, GGML_TYPE_F32, ggml_n_dims(s.src), s.src->ne);
         if (r == nullptr) {
             ggml_free(m.conv_pw_f32_ctx);
             m.conv_pw_f32_ctx = nullptr;
@@ -341,22 +345,18 @@ transcribe_status promote_conv_pw_to_f32_on_cpu(CanaryQwenModel & m) {
         replacements.push_back(r);
     }
 
-    m.conv_pw_f32_buffer = ggml_backend_alloc_ctx_tensors(
-        m.conv_pw_f32_ctx, m.plan.primary);
+    m.conv_pw_f32_buffer = ggml_backend_alloc_ctx_tensors(m.conv_pw_f32_ctx, m.plan.primary);
     if (m.conv_pw_f32_buffer == nullptr) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "canary_qwen: conv F16->F32 promotion buffer alloc failed");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "canary_qwen: conv F16->F32 promotion buffer alloc failed");
         ggml_free(m.conv_pw_f32_ctx);
         m.conv_pw_f32_ctx = nullptr;
         return TRANSCRIBE_ERR_BACKEND;
     }
-    ggml_backend_buffer_set_usage(
-        m.conv_pw_f32_buffer, GGML_BACKEND_BUFFER_USAGE_WEIGHTS);
+    ggml_backend_buffer_set_usage(m.conv_pw_f32_buffer, GGML_BACKEND_BUFFER_USAGE_WEIGHTS);
 
     const auto * f16_traits = ggml_get_type_traits(GGML_TYPE_F16);
     if (f16_traits == nullptr || f16_traits->to_float == nullptr) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_WARN,
-            "canary_qwen: no f16 to_float trait — skipping conv promotion");
+        log_msg(TRANSCRIBE_LOG_LEVEL_WARN, "canary_qwen: no f16 to_float trait — skipping conv promotion");
         ggml_backend_buffer_free(m.conv_pw_f32_buffer);
         m.conv_pw_f32_buffer = nullptr;
         ggml_free(m.conv_pw_f32_ctx);
@@ -367,13 +367,15 @@ transcribe_status promote_conv_pw_to_f32_on_cpu(CanaryQwenModel & m) {
     std::vector<uint8_t> f16_staging;
     std::vector<float>   f32_staging;
     for (size_t i = 0; i < slots.size(); ++i) {
-        ggml_tensor * src = slots[i].src;
-        ggml_tensor * dst = replacements[i];
+        ggml_tensor * src       = slots[i].src;
+        ggml_tensor * dst       = replacements[i];
         const int64_t n_elem    = ggml_nelements(src);
         const size_t  f16_bytes = ggml_nbytes(src);
         const size_t  f32_bytes = static_cast<size_t>(n_elem) * sizeof(float);
 
-        if (f16_staging.size() < f16_bytes) f16_staging.resize(f16_bytes);
+        if (f16_staging.size() < f16_bytes) {
+            f16_staging.resize(f16_bytes);
+        }
         if (f32_staging.size() < static_cast<size_t>(n_elem)) {
             f32_staging.resize(n_elem);
         }
@@ -385,8 +387,7 @@ transcribe_status promote_conv_pw_to_f32_on_cpu(CanaryQwenModel & m) {
         *slots[i].dst_slot = dst;
     }
 
-    log_msg(TRANSCRIBE_LOG_LEVEL_INFO,
-        "canary_qwen: promoted %zu F16 conv weights to F32", slots.size());
+    log_msg(TRANSCRIBE_LOG_LEVEL_INFO, "canary_qwen: promoted %zu F16 conv weights to F32", slots.size());
     return TRANSCRIBE_OK;
 }
 
@@ -395,18 +396,20 @@ transcribe_status promote_conv_pw_to_f32_on_cpu(CanaryQwenModel & m) {
 // independently); graph builders read whatever dtype each tensor reports.
 // Non-CPU backends (Metal, Vulkan) keep their own BF16 paths.
 transcribe_status promote_linears_bf16_to_f32_on_cpu(CanaryQwenModel & m) {
-    if (m.plan.primary_kind != transcribe::BackendKind::Cpu ||
-        m.plan.primary == nullptr)
-    {
+    if (m.plan.primary_kind != transcribe::BackendKind::Cpu || m.plan.primary == nullptr) {
         return TRANSCRIBE_OK;
     }
 
     // Collect (slot_pointer, source_tensor) for every BF16 linear we own.
-    struct Slot { ggml_tensor ** dst_slot; ggml_tensor * src; };
+    struct Slot {
+        ggml_tensor ** dst_slot;
+        ggml_tensor *  src;
+    };
+
     std::vector<Slot> slots;
-    auto add = [&](ggml_tensor ** s) {
+    auto              add = [&](ggml_tensor ** s) {
         if (s != nullptr && *s != nullptr && (*s)->type == GGML_TYPE_BF16) {
-            slots.push_back({s, *s});
+            slots.push_back({ s, *s });
         }
     };
 
@@ -415,11 +418,15 @@ transcribe_status promote_linears_bf16_to_f32_on_cpu(CanaryQwenModel & m) {
 
     // Encoder blocks — every linear (FFs, Q/K/V/O/pos).
     for (auto & b : m.weights.blocks) {
-        add(&b.ff1_lin1_w); add(&b.ff1_lin2_w);
-        add(&b.attn_q_w);   add(&b.attn_k_w);
-        add(&b.attn_v_w);   add(&b.attn_out_w);
+        add(&b.ff1_lin1_w);
+        add(&b.ff1_lin2_w);
+        add(&b.attn_q_w);
+        add(&b.attn_k_w);
+        add(&b.attn_v_w);
+        add(&b.attn_out_w);
         add(&b.attn_pos_w);
-        add(&b.ff2_lin1_w); add(&b.ff2_lin2_w);
+        add(&b.ff2_lin1_w);
+        add(&b.ff2_lin2_w);
     }
 
     // Perception projection.
@@ -430,25 +437,31 @@ transcribe_status promote_linears_bf16_to_f32_on_cpu(CanaryQwenModel & m) {
 
     // Decoder blocks — Q/K/V/O + gate/up/down.
     for (auto & b : m.weights.dec_blocks) {
-        add(&b.attn_q_w); add(&b.attn_k_w);
-        add(&b.attn_v_w); add(&b.attn_o_w);
-        add(&b.ffn_gate_w); add(&b.ffn_up_w); add(&b.ffn_down_w);
+        add(&b.attn_q_w);
+        add(&b.attn_k_w);
+        add(&b.attn_v_w);
+        add(&b.attn_o_w);
+        add(&b.ffn_gate_w);
+        add(&b.ffn_up_w);
+        add(&b.ffn_down_w);
     }
 
-    if (slots.empty()) return TRANSCRIBE_OK;
+    if (slots.empty()) {
+        return TRANSCRIBE_OK;
+    }
 
     // Allocate a dedicated ctx + buffer for the F32 replacements.
-    const size_t ctx_size = slots.size() * ggml_tensor_overhead() + 256;
-    ggml_init_params init_params = {ctx_size, nullptr, true};
-    m.linear_f32_ctx = ggml_init(init_params);
-    if (m.linear_f32_ctx == nullptr) return TRANSCRIBE_ERR_BACKEND;
+    const size_t     ctx_size    = slots.size() * ggml_tensor_overhead() + 256;
+    ggml_init_params init_params = { ctx_size, nullptr, true };
+    m.linear_f32_ctx             = ggml_init(init_params);
+    if (m.linear_f32_ctx == nullptr) {
+        return TRANSCRIBE_ERR_BACKEND;
+    }
 
     std::vector<ggml_tensor *> replacements;
     replacements.reserve(slots.size());
     for (const auto & s : slots) {
-        ggml_tensor * r = ggml_new_tensor(
-            m.linear_f32_ctx, GGML_TYPE_F32,
-            ggml_n_dims(s.src), s.src->ne);
+        ggml_tensor * r = ggml_new_tensor(m.linear_f32_ctx, GGML_TYPE_F32, ggml_n_dims(s.src), s.src->ne);
         if (r == nullptr) {
             ggml_free(m.linear_f32_ctx);
             m.linear_f32_ctx = nullptr;
@@ -458,22 +471,18 @@ transcribe_status promote_linears_bf16_to_f32_on_cpu(CanaryQwenModel & m) {
         replacements.push_back(r);
     }
 
-    m.linear_f32_buffer = ggml_backend_alloc_ctx_tensors(
-        m.linear_f32_ctx, m.plan.primary);
+    m.linear_f32_buffer = ggml_backend_alloc_ctx_tensors(m.linear_f32_ctx, m.plan.primary);
     if (m.linear_f32_buffer == nullptr) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "canary_qwen: BF16→F32 linear promotion buffer alloc failed");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "canary_qwen: BF16→F32 linear promotion buffer alloc failed");
         ggml_free(m.linear_f32_ctx);
         m.linear_f32_ctx = nullptr;
         return TRANSCRIBE_ERR_BACKEND;
     }
-    ggml_backend_buffer_set_usage(
-        m.linear_f32_buffer, GGML_BACKEND_BUFFER_USAGE_WEIGHTS);
+    ggml_backend_buffer_set_usage(m.linear_f32_buffer, GGML_BACKEND_BUFFER_USAGE_WEIGHTS);
 
     const auto * bf16_traits = ggml_get_type_traits(GGML_TYPE_BF16);
     if (bf16_traits == nullptr || bf16_traits->to_float == nullptr) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_WARN,
-            "canary_qwen: no bf16 to_float trait — skipping linear promotion");
+        log_msg(TRANSCRIBE_LOG_LEVEL_WARN, "canary_qwen: no bf16 to_float trait — skipping linear promotion");
         ggml_backend_buffer_free(m.linear_f32_buffer);
         m.linear_f32_buffer = nullptr;
         ggml_free(m.linear_f32_ctx);
@@ -484,13 +493,15 @@ transcribe_status promote_linears_bf16_to_f32_on_cpu(CanaryQwenModel & m) {
     std::vector<uint8_t> bf16_staging;
     std::vector<float>   f32_staging;
     for (size_t i = 0; i < slots.size(); ++i) {
-        ggml_tensor * src = slots[i].src;
-        ggml_tensor * dst = replacements[i];
-        const int64_t n_elem    = ggml_nelements(src);
+        ggml_tensor * src        = slots[i].src;
+        ggml_tensor * dst        = replacements[i];
+        const int64_t n_elem     = ggml_nelements(src);
         const size_t  bf16_bytes = ggml_nbytes(src);
         const size_t  f32_bytes  = static_cast<size_t>(n_elem) * sizeof(float);
 
-        if (bf16_staging.size() < bf16_bytes) bf16_staging.resize(bf16_bytes);
+        if (bf16_staging.size() < bf16_bytes) {
+            bf16_staging.resize(bf16_bytes);
+        }
         if (f32_staging.size() < static_cast<size_t>(n_elem)) {
             f32_staging.resize(n_elem);
         }
@@ -502,28 +513,20 @@ transcribe_status promote_linears_bf16_to_f32_on_cpu(CanaryQwenModel & m) {
         *slots[i].dst_slot = dst;
     }
 
-    log_msg(TRANSCRIBE_LOG_LEVEL_INFO,
-        "canary_qwen: promoted %zu BF16 linear weights to F32 for CPU backend",
-        slots.size());
+    log_msg(TRANSCRIBE_LOG_LEVEL_INFO, "canary_qwen: promoted %zu BF16 linear weights to F32 for CPU backend",
+            slots.size());
     return TRANSCRIBE_OK;
 }
 
 // Loader entry points (forward-declared so we can register `arch` after).
-extern transcribe_status load        (Loader &, const transcribe_model_load_params *,
-                                      transcribe_model **);
-extern transcribe_status init_context(transcribe_model *, const transcribe_session_params *,
-                                      transcribe_session **);
-extern transcribe_status run         (transcribe_session *, const float *, int,
-                                      const transcribe_run_params *);
-
-transcribe_status load(
-    Loader &                          loader,
-    const transcribe_model_load_params *   params,
-    transcribe_model **               out_model)
-{
+extern transcribe_status load(Loader &, const transcribe_model_load_params *, transcribe_model **);
+extern transcribe_status init_context(transcribe_model *, const transcribe_session_params *, transcribe_session **);
+extern transcribe_status run(transcribe_session *, const float *, int, const transcribe_run_params *);
+
+transcribe_status load(Loader & loader, const transcribe_model_load_params * params, transcribe_model ** out_model) {
     const int64_t t_load_start = ggml_time_us();
 
-    auto m = std::make_unique<CanaryQwenModel>();
+    auto m       = std::make_unique<CanaryQwenModel>();
     m->arch      = &arch;
     m->t_load_us = 0;
     m->variant   = loader.variant().empty() ? k_default_variant : loader.variant();
@@ -533,13 +536,20 @@ transcribe_status load(
     m->caps.n_languages = 0;
     m->caps.languages   = nullptr;
 
-    if (auto st = read_capability_kv(loader.gguf(), m->caps); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_languages_kv (loader.gguf(), *m);       st != TRANSCRIBE_OK) return st;
+    if (auto st = read_capability_kv(loader.gguf(), m->caps); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_languages_kv(loader.gguf(), *m); st != TRANSCRIBE_OK) {
+        return st;
+    }
 
-    if (auto st = m->tok.load(loader.gguf()); st != TRANSCRIBE_OK) return st;
+    if (auto st = m->tok.load(loader.gguf()); st != TRANSCRIBE_OK) {
+        return st;
+    }
 
-    if (auto st = read_canary_qwen_hparams(loader.gguf(), m->hparams);
-        st != TRANSCRIBE_OK) return st;
+    if (auto st = read_canary_qwen_hparams(loader.gguf(), m->hparams); st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Publish the input-length ceiling now that the decoder context window
     // and frontend rate are known.
@@ -547,21 +557,18 @@ transcribe_status load(
 
     // Basis for transcribe_session_get_limits: the same constants
     // canary_qwen_max_audio_ms uses, so the limit recomputes at a lowered n_ctx.
-    if (m->hparams.dec_max_position > 0 &&
-        m->hparams.enc_subsampling_factor > 0 &&
-        m->hparams.fe_hop_length > 0 && m->hparams.fe_sample_rate > 0) {
-        m->limits.has_context_cap = true;
-        m->limits.model_max_ctx   = m->hparams.dec_max_position;
-        m->limits.prompt_overhead = 32;
-        m->limits.gen_reserve     = k_max_new;
+    if (m->hparams.dec_max_position > 0 && m->hparams.enc_subsampling_factor > 0 && m->hparams.fe_hop_length > 0 &&
+        m->hparams.fe_sample_rate > 0) {
+        m->limits.has_context_cap    = true;
+        m->limits.model_max_ctx      = m->hparams.dec_max_position;
+        m->limits.prompt_overhead    = 32;
+        m->limits.gen_reserve        = k_max_new;
         // audio_tokens ≈ mel_frames / subsampling_factor ;
         //   mel_frames = ms*sr/(hop*1000)
-        m->limits.ms_per_audio_token =
-            static_cast<double>(m->hparams.enc_subsampling_factor) *
-            m->hparams.fe_hop_length * 1000.0 / m->hparams.fe_sample_rate;
+        m->limits.ms_per_audio_token = static_cast<double>(m->hparams.enc_subsampling_factor) *
+                                       m->hparams.fe_hop_length * 1000.0 / m->hparams.fe_sample_rate;
         m->limits.kv_elems_per_ctx_token =
-            (int64_t) m->hparams.dec_n_kv_heads *
-            m->hparams.dec_head_dim * m->hparams.dec_n_layers * 2;
+            (int64_t) m->hparams.dec_n_kv_heads * m->hparams.dec_head_dim * m->hparams.dec_n_layers * 2;
     }
 
     m->hparams.vocab_size   = m->tok.n_tokens();
@@ -569,23 +576,25 @@ transcribe_status load(
     m->hparams.eos_token_id = m->tok.eos_id();
 
     if (m->hparams.vocab_size != m->hparams.dec_vocab_size) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "canary_qwen: tokenizer vocab (%d) != decoder vocab_size (%d)",
-                     m->hparams.vocab_size, m->hparams.dec_vocab_size);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "canary_qwen: tokenizer vocab (%d) != decoder vocab_size (%d)",
+                m->hparams.vocab_size, m->hparams.dec_vocab_size);
         return TRANSCRIBE_ERR_GGUF;
     }
     if (m->hparams.eos_token_id < 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "canary_qwen: GGUF tokenizer has no eos_token_id");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "canary_qwen: GGUF tokenizer has no eos_token_id");
         return TRANSCRIBE_ERR_GGUF;
     }
 
-    if (auto st = resolve_chat_tokens(m->tok, m->chat_tokens);   st != TRANSCRIBE_OK) return st;
-    if (auto st = build_static_prompt_segments(*m);              st != TRANSCRIBE_OK) return st;
+    if (auto st = resolve_chat_tokens(m->tok, m->chat_tokens); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = build_static_prompt_segments(*m); st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Mel frontend.
     {
-        transcribe::MelConfig cfg {};
+        transcribe::MelConfig cfg{};
         cfg.sample_rate  = m->hparams.fe_sample_rate;
         cfg.num_mels     = m->hparams.fe_num_mels;
         cfg.n_fft        = m->hparams.fe_n_fft;
@@ -602,21 +611,16 @@ transcribe_status load(
         cfg.normalize    = m->hparams.fe_normalize;
 
         // Pull baked filterbank/window from GGUF if present.
-        using R = load_common::ReadF32Result;
-        const size_t fb_elems = static_cast<size_t>(cfg.num_mels) *
-                                static_cast<size_t>(cfg.n_fft / 2 + 1);
-        const auto fb_rc = load_common::read_f32_tensor_checked(
-            loader.gguf(), loader.path(),
-            "frontend.mel_filterbank", fb_elems,
-            "canary_qwen", cfg.filterbank);
+        using R               = load_common::ReadF32Result;
+        const size_t fb_elems = static_cast<size_t>(cfg.num_mels) * static_cast<size_t>(cfg.n_fft / 2 + 1);
+        const auto fb_rc = load_common::read_f32_tensor_checked(loader.gguf(), loader.path(), "frontend.mel_filterbank",
+                                                                fb_elems, "canary_qwen", cfg.filterbank);
         if (fb_rc != R::Ok && fb_rc != R::Absent) {
             return TRANSCRIBE_ERR_GGUF;
         }
         const size_t win_elems = static_cast<size_t>(cfg.win_length);
-        const auto win_rc = load_common::read_f32_tensor_checked(
-            loader.gguf(), loader.path(),
-            "frontend.window", win_elems,
-            "canary_qwen", cfg.window);
+        const auto   win_rc    = load_common::read_f32_tensor_checked(loader.gguf(), loader.path(), "frontend.window",
+                                                                      win_elems, "canary_qwen", cfg.window);
         if (win_rc != R::Ok && win_rc != R::Absent) {
             return TRANSCRIBE_ERR_GGUF;
         }
@@ -625,90 +629,85 @@ transcribe_status load(
     }
 
     // Reopen GGUF with no_alloc to bind the tensor catalog.
-    gguf_init_params init_params {};
+    gguf_init_params init_params{};
     init_params.no_alloc = true;
     init_params.ctx      = &m->ctx_meta;
 
     gguf_context * gguf_data = gguf_init_from_file(loader.path().c_str(), init_params);
-    if (gguf_data == nullptr) return TRANSCRIBE_ERR_GGUF;
+    if (gguf_data == nullptr) {
+        return TRANSCRIBE_ERR_GGUF;
+    }
 
-    if (auto st = build_canary_qwen_weights(m->ctx_meta, m->hparams, m->weights);
-        st != TRANSCRIBE_OK)
-    {
+    if (auto st = build_canary_qwen_weights(m->ctx_meta, m->hparams, m->weights); st != TRANSCRIBE_OK) {
         gguf_free(gguf_data);
         return st;
     }
 
     // Backend plan + alloc + stream tensor data.
-    const transcribe_backend_request backend_req =
-        (params != nullptr) ? params->backend : TRANSCRIBE_BACKEND_AUTO;
-    if (auto st = load_common::init_backends(backend_req, (params != nullptr) ? params->gpu_device : 0, "canary_qwen", m->plan);
-        st != TRANSCRIBE_OK)
-    {
+    const transcribe_backend_request backend_req = (params != nullptr) ? params->backend : TRANSCRIBE_BACKEND_AUTO;
+    if (auto st = load_common::init_backends(backend_req, (params != nullptr) ? params->gpu_device : 0, "canary_qwen",
+                                             m->plan);
+        st != TRANSCRIBE_OK) {
         gguf_free(gguf_data);
         return st;
     }
-    m->backend = ggml_backend_name(m->plan.primary);
+    m->backend         = ggml_backend_name(m->plan.primary);
     m->primary_backend = m->plan.primary;
 
-    ggml_backend_buffer_t weights_buffer =
-        ggml_backend_alloc_ctx_tensors(m->ctx_meta, m->plan.primary);
+    ggml_backend_buffer_t weights_buffer = ggml_backend_alloc_ctx_tensors(m->ctx_meta, m->plan.primary);
     if (weights_buffer == nullptr) {
         gguf_free(gguf_data);
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "canary_qwen: ggml_backend_alloc_ctx_tensors failed");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "canary_qwen: ggml_backend_alloc_ctx_tensors failed");
         return TRANSCRIBE_ERR_GGUF;
     }
     m->backend_buffer = weights_buffer;
     ggml_backend_buffer_set_usage(weights_buffer, GGML_BACKEND_BUFFER_USAGE_WEIGHTS);
 
-    if (auto st = load_common::stream_tensor_data(
-            loader.path(), gguf_data, m->ctx_meta, "canary_qwen");
-        st != TRANSCRIBE_OK)
-    {
+    if (auto st = load_common::stream_tensor_data(loader.path(), gguf_data, m->ctx_meta, "canary_qwen");
+        st != TRANSCRIBE_OK) {
         gguf_free(gguf_data);
         return st;
     }
     gguf_free(gguf_data);
 
     // Post-load weight transformations.
-    if (auto st = fuse_batch_norm(*m); st != TRANSCRIBE_OK) return st;
-    if (auto st = promote_conv_pw_to_f32_on_cpu(*m); st != TRANSCRIBE_OK) return st;
-    if (auto st = promote_linears_bf16_to_f32_on_cpu(*m); st != TRANSCRIBE_OK) return st;
+    if (auto st = fuse_batch_norm(*m); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = promote_conv_pw_to_f32_on_cpu(*m); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = promote_linears_bf16_to_f32_on_cpu(*m); st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Pack gate + up into one tensor per layer (one mul_mat instead of two).
     {
         std::vector<transcribe::causal_lm::GateUpEntry> entries;
         entries.reserve(m->weights.dec_blocks.size());
         for (auto & b : m->weights.dec_blocks) {
-            entries.push_back({b.ffn_gate_w, b.ffn_up_w, &b.ffn_gate_up_w});
-        }
-        if (!transcribe::causal_lm::pack_gate_up(
-                m->plan.primary,
-                m->hparams.dec_hidden,
-                m->hparams.dec_intermediate,
-                entries,
-                m->packed_gate_up,
-                "canary_qwen"))
-        {
+            entries.push_back({ b.ffn_gate_w, b.ffn_up_w, &b.ffn_gate_up_w });
+        }
+        if (!transcribe::causal_lm::pack_gate_up(m->plan.primary, m->hparams.dec_hidden, m->hparams.dec_intermediate,
+                                                 entries, m->packed_gate_up, "canary_qwen")) {
             m->packed_gate_up.free();
             return TRANSCRIBE_ERR_GGUF;
         }
     }
 
     m->t_load_us = ggml_time_us() - t_load_start;
-    *out_model = m.release();
+    *out_model   = m.release();
     return TRANSCRIBE_OK;
 }
 
-transcribe_status init_context(
-    transcribe_model *                model,
-    const transcribe_session_params * params,
-    transcribe_session **             out_ctx)
-{
-    if (model->arch != &arch) return TRANSCRIBE_ERR_INVALID_ARG;
+transcribe_status init_context(transcribe_model *                model,
+                               const transcribe_session_params * params,
+                               transcribe_session **             out_ctx) {
+    if (model->arch != &arch) {
+        return TRANSCRIBE_ERR_INVALID_ARG;
+    }
 
-    auto cc = std::make_unique<CanaryQwenSession>();
+    auto cc       = std::make_unique<CanaryQwenSession>();
     cc->model     = model;
     cc->n_threads = params->n_threads;
     cc->kv_type   = params->kv_type;
@@ -720,26 +719,22 @@ transcribe_status init_context(
     // Metal). TRANSCRIBE_NO_FLASH / TRANSCRIBE_FORCE_FLASH override both stages.
     cc->encoder_use_flash = false;
     cc->decoder_use_flash = true;
-    transcribe::flash::apply_env_overrides(cc->encoder_use_flash,
-                                           cc->decoder_use_flash);
+    transcribe::flash::apply_env_overrides(cc->encoder_use_flash, cc->decoder_use_flash);
 
     auto * cm = static_cast<CanaryQwenModel *>(model);
     {
         ggml_type kv_type = GGML_TYPE_F16;
-        if (cc->kv_type == TRANSCRIBE_KV_TYPE_F32) kv_type = GGML_TYPE_F32;
+        if (cc->kv_type == TRANSCRIBE_KV_TYPE_F32) {
+            kv_type = GGML_TYPE_F32;
+        }
         if (!transcribe::causal_lm::kv_init(cc->kv_cache, cm->plan.primary,
-                                           /*n_ctx=*/2048,
-                                           cm->hparams.dec_n_kv_heads,
-                                           cm->hparams.dec_head_dim,
-                                           cm->hparams.dec_n_layers,
-                                           kv_type))
-        {
+                                            /*n_ctx=*/2048, cm->hparams.dec_n_kv_heads, cm->hparams.dec_head_dim,
+                                            cm->hparams.dec_n_layers, kv_type)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "canary_qwen init_context: KV cache allocation failed "
-                "(n_ctx=2048, %d kv-heads x %d head-dim x %d layers) — "
-                "out of memory.",
-                cm->hparams.dec_n_kv_heads, cm->hparams.dec_head_dim,
-                cm->hparams.dec_n_layers);
+                                "canary_qwen init_context: KV cache allocation failed "
+                                "(n_ctx=2048, %d kv-heads x %d head-dim x %d layers) — "
+                                "out of memory.",
+                                cm->hparams.dec_n_kv_heads, cm->hparams.dec_head_dim, cm->hparams.dec_n_layers);
             return TRANSCRIBE_ERR_OOM;
         }
     }
@@ -752,11 +747,7 @@ void apply_thread_policy(CanaryQwenSession * cc) {
     transcribe::configure_sched_n_threads(cc->sched, cc->n_threads);
 }
 
-void build_relpos_emb_host(std::vector<float> & pos_buf,
-                           std::vector<float> & div_term,
-                           int                  d_model,
-                           int                  T_enc)
-{
+void build_relpos_emb_host(std::vector<float> & pos_buf, std::vector<float> & div_term, int d_model, int T_enc) {
     // RelPositionalEncoding produces pos_emb of shape (1, 2*T_enc - 1, d_model).
     // The position values descend from (T_enc - 1) at index 0 down to
     // -(T_enc - 1) at index 2*T_enc - 2 (per NeMo's
@@ -769,25 +760,23 @@ void build_relpos_emb_host(std::vector<float> & pos_buf,
     const float ln_10000 = std::log(10000.0f);
     for (int k = 0; k < d_model / 2; ++k) {
         div_term[static_cast<size_t>(k)] =
-            std::exp(static_cast<float>(2 * k) *
-                     (-ln_10000 / static_cast<float>(d_model)));
+            std::exp(static_cast<float>(2 * k) * (-ln_10000 / static_cast<float>(d_model)));
     }
     for (int i = 0; i < pos_len; ++i) {
         const float pos = static_cast<float>((T_enc - 1) - i);
-        float * row = pos_buf.data() + static_cast<size_t>(i) * d_model;
+        float *     row = pos_buf.data() + static_cast<size_t>(i) * d_model;
         for (int k = 0; k < d_model / 2; ++k) {
             const float div = div_term[static_cast<size_t>(k)];
-            row[2 * k]     = std::sin(pos * div);
-            row[2 * k + 1] = std::cos(pos * div);
+            row[2 * k]      = std::sin(pos * div);
+            row[2 * k + 1]  = std::cos(pos * div);
         }
     }
 }
 
-transcribe_status run(transcribe_session *      context,
-                      const float *             pcm,
-                      int                       n_samples,
-                      const transcribe_run_params * params)
-{
+transcribe_status run(transcribe_session *          context,
+                      const float *                 pcm,
+                      int                           n_samples,
+                      const transcribe_run_params * params) {
     if (context == nullptr || pcm == nullptr || n_samples <= 0) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
@@ -797,9 +786,11 @@ transcribe_status run(transcribe_session *      context,
     if (cm == nullptr || cm->plan.scheduler_list.empty() || !cm->mel.has_value()) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
-    (void)params;
+    (void) params;
 
-    if (cc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
+    if (cc->poll_abort()) {
+        return TRANSCRIBE_ERR_ABORTED;
+    }
 
     transcribe::debug::init();
     cc->clear_result();
@@ -807,17 +798,14 @@ transcribe_status run(transcribe_session *      context,
     const auto & hp = cm->hparams;
 
     // ---- Mel frontend ----
-    const int64_t t_mel_start = ggml_time_us();
-    int mel_n_mels   = 0;
-    int mel_n_frames = 0;
-    if (auto mst = cm->mel->compute(pcm, static_cast<size_t>(n_samples),
-                                    cc->mel_buf, mel_n_mels, mel_n_frames,
-                                    cc->n_threads);
-        mst != TRANSCRIBE_OK)
-    {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "canary_qwen run: MelFrontend::compute failed (%s)",
-                     transcribe_status_string(mst));
+    const int64_t t_mel_start  = ggml_time_us();
+    int           mel_n_mels   = 0;
+    int           mel_n_frames = 0;
+    if (auto mst =
+            cm->mel->compute(pcm, static_cast<size_t>(n_samples), cc->mel_buf, mel_n_mels, mel_n_frames, cc->n_threads);
+        mst != TRANSCRIBE_OK) {
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "canary_qwen run: MelFrontend::compute failed (%s)",
+                transcribe_status_string(mst));
         return mst;
     }
     cc->t_mel_us = ggml_time_us() - t_mel_start;
@@ -828,10 +816,10 @@ transcribe_status run(transcribe_session *      context,
         cc->compute_ctx = nullptr;
     }
     {
-        ggml_init_params ip {};
-        ip.mem_size   = 32 * 1024 * 1024;
-        ip.mem_buffer = nullptr;
-        ip.no_alloc   = true;
+        ggml_init_params ip{};
+        ip.mem_size     = 32 * 1024 * 1024;
+        ip.mem_buffer   = nullptr;
+        ip.no_alloc     = true;
         cc->compute_ctx = ggml_init(ip);
         if (cc->compute_ctx == nullptr) {
             log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "canary_qwen run: ggml_init failed (encoder)");
@@ -839,38 +827,33 @@ transcribe_status run(transcribe_session *      context,
         }
     }
 
-    EncoderBuild eb = build_encoder_graph(
-        cc->compute_ctx, cm->weights, hp, mel_n_frames,
-        /*kv_type=*/GGML_TYPE_COUNT,
-        cc->encoder_use_flash, cm->backend.c_str());
-    if (eb.graph == nullptr || eb.out == nullptr) return TRANSCRIBE_ERR_GGUF;
+    EncoderBuild eb = build_encoder_graph(cc->compute_ctx, cm->weights, hp, mel_n_frames,
+                                          /*kv_type=*/GGML_TYPE_COUNT, cc->encoder_use_flash, cm->backend.c_str());
+    if (eb.graph == nullptr || eb.out == nullptr) {
+        return TRANSCRIBE_ERR_GGUF;
+    }
 
     if (cc->sched == nullptr) {
-        cc->sched = ggml_backend_sched_new(
-            cm->plan.scheduler_list.data(), nullptr,
-            static_cast<int>(cm->plan.scheduler_list.size()),
-            16384, /*parallel=*/false, /*op_offload=*/true);
+        cc->sched = ggml_backend_sched_new(cm->plan.scheduler_list.data(), nullptr,
+                                           static_cast<int>(cm->plan.scheduler_list.size()), 16384, /*parallel=*/false,
+                                           /*op_offload=*/true);
         if (cc->sched == nullptr) {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "canary_qwen run: ggml_backend_sched_new failed");
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "canary_qwen run: ggml_backend_sched_new failed");
             return TRANSCRIBE_ERR_GGUF;
         }
     }
     ggml_backend_sched_reset(cc->sched);
     if (!ggml_backend_sched_alloc_graph(cc->sched, eb.graph)) {
         transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "canary_qwen run: encoder graph allocation failed — out of memory.");
+                            "canary_qwen run: encoder graph allocation failed — out of memory.");
         return TRANSCRIBE_ERR_OOM;
     }
 
-    ggml_backend_tensor_set(eb.mel_in, cc->mel_buf.data(),
-                            0, cc->mel_buf.size() * sizeof(float));
+    ggml_backend_tensor_set(eb.mel_in, cc->mel_buf.data(), 0, cc->mel_buf.size() * sizeof(float));
     if (transcribe::debug::enabled()) {
         const long long shape[2] = { mel_n_mels, mel_n_frames };
-        transcribe::debug::dump_host_f32(
-            "enc.mel.in", cc->mel_buf.data(),
-            static_cast<long long>(cc->mel_buf.size()),
-            shape, 2, "frontend.mel.norm");
+        transcribe::debug::dump_host_f32("enc.mel.in", cc->mel_buf.data(), static_cast<long long>(cc->mel_buf.size()),
+                                         shape, 2, "frontend.mel.norm");
     }
 
     // Upload relative-position embedding.
@@ -879,33 +862,28 @@ transcribe_status run(transcribe_session *      context,
         const int pos_len = static_cast<int>(eb.pos_emb_in->ne[1]);
         const int T_enc   = (pos_len + 1) / 2;
         build_relpos_emb_host(cc->pos_buf, cc->pos_div_term, d_model, T_enc);
-        ggml_backend_tensor_set(eb.pos_emb_in, cc->pos_buf.data(),
-                                0, cc->pos_buf.size() * sizeof(float));
+        ggml_backend_tensor_set(eb.pos_emb_in, cc->pos_buf.data(), 0, cc->pos_buf.size() * sizeof(float));
         if (transcribe::debug::enabled()) {
-            transcribe::debug::dump_tensor("enc.pos_emb", eb.pos_emb_in,
-                                           "encoder.pos_emb");
+            transcribe::debug::dump_tensor("enc.pos_emb", eb.pos_emb_in, "encoder.pos_emb");
         }
     }
 
     apply_thread_policy(cc);
 
     const int64_t t_enc_start = ggml_time_us();
-    if (const ggml_status gs =
-            ggml_backend_sched_graph_compute(cc->sched, eb.graph);
-        gs != GGML_STATUS_SUCCESS)
-    {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "canary_qwen run: encoder compute failed (%d)",
-                     static_cast<int>(gs));
+    if (const ggml_status gs = ggml_backend_sched_graph_compute(cc->sched, eb.graph); gs != GGML_STATUS_SUCCESS) {
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "canary_qwen run: encoder compute failed (%d)", static_cast<int>(gs));
         return TRANSCRIBE_ERR_GGUF;
     }
     cc->t_encode_us = ggml_time_us() - t_enc_start;
 
     auto try_dump = [](const char * name, ggml_tensor * t, const char * stage) {
-        if (t != nullptr) transcribe::debug::dump_tensor(name, t, stage);
+        if (t != nullptr) {
+            transcribe::debug::dump_tensor(name, t, stage);
+        }
     };
-    try_dump("enc.pre_encode.out",  eb.dumps.pre_encode_out, "encoder.pre_encode");
-    try_dump("enc.block.0.out",     eb.dumps.block0_out,     "encoder.block0");
+    try_dump("enc.pre_encode.out", eb.dumps.pre_encode_out, "encoder.pre_encode");
+    try_dump("enc.block.0.out", eb.dumps.block0_out, "encoder.block0");
     if (eb.dumps.block_mid_out != nullptr) {
         char nm[64];
         std::snprintf(nm, sizeof(nm), "enc.block.%d.out", hp.enc_n_layers / 2);
@@ -916,31 +894,24 @@ transcribe_status run(transcribe_session *      context,
         std::snprintf(nm, sizeof(nm), "enc.block.%d.out", hp.enc_n_layers - 1);
         try_dump(nm, eb.dumps.block_last_out, "encoder.block_last");
     }
-    try_dump("enc.final",           eb.dumps.final_out,      "encoder.final");
+    try_dump("enc.final", eb.dumps.final_out, "encoder.final");
     try_dump("perception.proj.out", eb.dumps.perception_out, "perception.proj.out");
 
     // Read perception output to host.
     const int hidden = static_cast<int>(eb.out->ne[0]);
     const int T_enc  = static_cast<int>(eb.out->ne[1]);
-    cc->enc_host.resize(static_cast<size_t>(hidden) *
-                        static_cast<size_t>(T_enc));
-    ggml_backend_tensor_get(eb.out, cc->enc_host.data(), 0,
-                            cc->enc_host.size() * sizeof(float));
+    cc->enc_host.resize(static_cast<size_t>(hidden) * static_cast<size_t>(T_enc));
+    ggml_backend_tensor_get(eb.out, cc->enc_host.data(), 0, cc->enc_host.size() * sizeof(float));
 
     // Build prompt token-id list.
     std::vector<int32_t> prompt_ids;
-    prompt_ids.reserve(cm->prompt_prefix_ids.size() + T_enc +
-                       cm->prompt_suffix_ids.size());
-    prompt_ids.insert(prompt_ids.end(),
-                      cm->prompt_prefix_ids.begin(),
-                      cm->prompt_prefix_ids.end());
+    prompt_ids.reserve(cm->prompt_prefix_ids.size() + T_enc + cm->prompt_suffix_ids.size());
+    prompt_ids.insert(prompt_ids.end(), cm->prompt_prefix_ids.begin(), cm->prompt_prefix_ids.end());
     const int prefix_len = static_cast<int>(prompt_ids.size());
     for (int i = 0; i < T_enc; ++i) {
         prompt_ids.push_back(hp.audio_locator_id);
     }
-    prompt_ids.insert(prompt_ids.end(),
-                      cm->prompt_suffix_ids.begin(),
-                      cm->prompt_suffix_ids.end());
+    prompt_ids.insert(prompt_ids.end(), cm->prompt_suffix_ids.begin(), cm->prompt_suffix_ids.end());
     const int T_prompt   = static_cast<int>(prompt_ids.size());
     const int suffix_len = T_prompt - prefix_len - T_enc;
 
@@ -948,13 +919,12 @@ transcribe_status run(transcribe_session *      context,
     // context window. Reject an over-length clip here, before prefill/decode.
     const int ceiling = canary_qwen_context_ceiling(cc->n_ctx, hp);
     if (T_prompt + k_max_new > ceiling) {
-        transcribe::log_msg(
-            TRANSCRIBE_LOG_LEVEL_ERROR,
-            "canary_qwen run: input too long — %d audio + %d prompt tokens "
-            "leave no room for output within the %d-token context (need %d). "
-            "Shorten the audio (see transcribe_capabilities.max_audio_ms) or "
-            "split it into segments.",
-            T_enc, prefix_len + suffix_len, ceiling, T_prompt + k_max_new);
+        transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
+                            "canary_qwen run: input too long — %d audio + %d prompt tokens "
+                            "leave no room for output within the %d-token context (need %d). "
+                            "Shorten the audio (see transcribe_capabilities.max_audio_ms) or "
+                            "split it into segments.",
+                            T_enc, prefix_len + suffix_len, ceiling, T_prompt + k_max_new);
         return TRANSCRIBE_ERR_INPUT_TOO_LONG;
     }
 
@@ -963,27 +933,27 @@ transcribe_status run(transcribe_session *      context,
     // graph's flash-attn path wants pow2 attention width). A pre-allocated
     // smaller cache is freed and re-allocated.
     int want_n_ctx = 1024;
-    while (want_n_ctx < T_prompt + k_max_new) want_n_ctx *= 2;
-    if (want_n_ctx > ceiling) want_n_ctx = ceiling;
+    while (want_n_ctx < T_prompt + k_max_new) {
+        want_n_ctx *= 2;
+    }
+    if (want_n_ctx > ceiling) {
+        want_n_ctx = ceiling;
+    }
     if (cc->kv_cache.ctx != nullptr && cc->kv_cache.n_ctx < want_n_ctx) {
         cc->kv_cache.free();
     }
     if (cc->kv_cache.ctx == nullptr) {
         ggml_type kv_type = GGML_TYPE_F16;
-        if (cc->kv_type == TRANSCRIBE_KV_TYPE_F32) kv_type = GGML_TYPE_F32;
-        if (!transcribe::causal_lm::kv_init(cc->kv_cache, cm->plan.primary,
-                                           want_n_ctx,
-                                           hp.dec_n_kv_heads,
-                                           hp.dec_head_dim,
-                                           hp.dec_n_layers,
-                                           kv_type))
-        {
+        if (cc->kv_type == TRANSCRIBE_KV_TYPE_F32) {
+            kv_type = GGML_TYPE_F32;
+        }
+        if (!transcribe::causal_lm::kv_init(cc->kv_cache, cm->plan.primary, want_n_ctx, hp.dec_n_kv_heads,
+                                            hp.dec_head_dim, hp.dec_n_layers, kv_type)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "canary_qwen run: KV cache allocation failed (n_ctx=%d, "
-                "%d kv-heads x %d head-dim x %d layers) — out of memory. "
-                "Lower transcribe_session_params.n_ctx or shorten the audio.",
-                want_n_ctx, hp.dec_n_kv_heads, hp.dec_head_dim,
-                hp.dec_n_layers);
+                                "canary_qwen run: KV cache allocation failed (n_ctx=%d, "
+                                "%d kv-heads x %d head-dim x %d layers) — out of memory. "
+                                "Lower transcribe_session_params.n_ctx or shorten the audio.",
+                                want_n_ctx, hp.dec_n_kv_heads, hp.dec_head_dim, hp.dec_n_layers);
             return TRANSCRIBE_ERR_OOM;
         }
     } else {
@@ -1002,86 +972,79 @@ transcribe_status run(transcribe_session *      context,
         cc->compute_ctx = nullptr;
     }
     {
-        ggml_init_params ip {};
-        ip.mem_size   = 32 * 1024 * 1024;
-        ip.mem_buffer = nullptr;
-        ip.no_alloc   = true;
+        ggml_init_params ip{};
+        ip.mem_size     = 32 * 1024 * 1024;
+        ip.mem_buffer   = nullptr;
+        ip.no_alloc     = true;
         cc->compute_ctx = ggml_init(ip);
         if (cc->compute_ctx == nullptr) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "canary_qwen run: prefill compute context allocation failed — "
-                "out of memory.");
+                                "canary_qwen run: prefill compute context allocation failed — "
+                                "out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
     }
 
-    const bool dumps_on   = transcribe::debug::enabled();
-    const bool slice_last = !dumps_on;
-    PrefillBuild pb = build_prefill_graph(
-        cc->compute_ctx, cm->weights, hp,
-        cc->kv_cache, T_prompt, T_enc, prefix_len, suffix_len,
-        cc->decoder_use_flash, slice_last);
-    if (pb.graph == nullptr || pb.out == nullptr) return TRANSCRIBE_ERR_GGUF;
+    const bool   dumps_on   = transcribe::debug::enabled();
+    const bool   slice_last = !dumps_on;
+    PrefillBuild pb = build_prefill_graph(cc->compute_ctx, cm->weights, hp, cc->kv_cache, T_prompt, T_enc, prefix_len,
+                                          suffix_len, cc->decoder_use_flash, slice_last);
+    if (pb.graph == nullptr || pb.out == nullptr) {
+        return TRANSCRIBE_ERR_GGUF;
+    }
 
     ggml_backend_sched_reset(cc->sched);
     if (!ggml_backend_sched_alloc_graph(cc->sched, pb.graph)) {
         transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "canary_qwen run: prefill graph allocation failed (T_prompt=%d) — "
-            "out of memory. Lower transcribe_session_params.n_ctx or shorten "
-            "the audio.", T_prompt);
+                            "canary_qwen run: prefill graph allocation failed (T_prompt=%d) — "
+                            "out of memory. Lower transcribe_session_params.n_ctx or shorten "
+                            "the audio.",
+                            T_prompt);
         return TRANSCRIBE_ERR_OOM;
     }
 
-    ggml_backend_tensor_set(pb.input_ids_in, prompt_ids.data(),
-                            0, prompt_ids.size() * sizeof(int32_t));
+    ggml_backend_tensor_set(pb.input_ids_in, prompt_ids.data(), 0, prompt_ids.size() * sizeof(int32_t));
     if (T_enc > 0 && pb.audio_in != nullptr) {
-        ggml_backend_tensor_set(pb.audio_in, cc->enc_host.data(),
-                                0, cc->enc_host.size() * sizeof(float));
+        ggml_backend_tensor_set(pb.audio_in, cc->enc_host.data(), 0, cc->enc_host.size() * sizeof(float));
     }
     {
         std::vector<int32_t> positions(T_prompt);
-        for (int i = 0; i < T_prompt; ++i) positions[i] = i;
-        ggml_backend_tensor_set(pb.positions_in, positions.data(),
-                                0, positions.size() * sizeof(int32_t));
+        for (int i = 0; i < T_prompt; ++i) {
+            positions[i] = i;
+        }
+        ggml_backend_tensor_set(pb.positions_in, positions.data(), 0, positions.size() * sizeof(int32_t));
     }
     {
-        const ggml_fp16_t mask_zero    = ggml_fp32_to_fp16(0.0f);
-        const ggml_fp16_t mask_neg_inf = ggml_fp32_to_fp16(-INFINITY);
-        std::vector<ggml_fp16_t> mask(
-            static_cast<size_t>(T_prompt) * T_prompt, mask_neg_inf);
+        const ggml_fp16_t        mask_zero    = ggml_fp32_to_fp16(0.0f);
+        const ggml_fp16_t        mask_neg_inf = ggml_fp32_to_fp16(-INFINITY);
+        std::vector<ggml_fp16_t> mask(static_cast<size_t>(T_prompt) * T_prompt, mask_neg_inf);
         for (int r = 0; r < T_prompt; ++r) {
             for (int c = 0; c <= r; ++c) {
                 mask[static_cast<size_t>(r) * T_prompt + c] = mask_zero;
             }
         }
-        ggml_backend_tensor_set(pb.mask_in, mask.data(),
-                                0, mask.size() * sizeof(ggml_fp16_t));
+        ggml_backend_tensor_set(pb.mask_in, mask.data(), 0, mask.size() * sizeof(ggml_fp16_t));
     }
 
-    const bool profile_decode = transcribe::env::flag("TRANSCRIBE_PERF_DEBUG");
-    int64_t t_prefill_us = 0;
-    int64_t t_prefill_compute_us = 0;
+    const bool profile_decode       = transcribe::env::flag("TRANSCRIBE_PERF_DEBUG");
+    int64_t    t_prefill_us         = 0;
+    int64_t    t_prefill_compute_us = 0;
     {
         const int64_t t0 = ggml_time_us();
-        if (const ggml_status gs =
-                ggml_backend_sched_graph_compute(cc->sched, pb.graph);
-            gs != GGML_STATUS_SUCCESS)
-        {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "canary_qwen run: prefill compute failed (%d)",
-                         static_cast<int>(gs));
+        if (const ggml_status gs = ggml_backend_sched_graph_compute(cc->sched, pb.graph); gs != GGML_STATUS_SUCCESS) {
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "canary_qwen run: prefill compute failed (%d)", static_cast<int>(gs));
             return TRANSCRIBE_ERR_GGUF;
         }
         t_prefill_compute_us = ggml_time_us() - t0;
-        t_prefill_us = t_prefill_compute_us;
+        t_prefill_us         = t_prefill_compute_us;
     }
 
     cc->kv_cache.n    = T_prompt;
     cc->kv_cache.head = T_prompt;
 
-    try_dump("dec.token_emb",       pb.dumps.token_emb,       "decoder.token_emb");
-    try_dump("dec.audio_injected",  pb.dumps.audio_injected,  "decoder.audio_injected");
-    try_dump("dec.block.0.out",     pb.dumps.block_0_out,     "decoder.block0");
+    try_dump("dec.token_emb", pb.dumps.token_emb, "decoder.token_emb");
+    try_dump("dec.audio_injected", pb.dumps.audio_injected, "decoder.audio_injected");
+    try_dump("dec.block.0.out", pb.dumps.block_0_out, "decoder.block0");
     if (pb.dumps.block_mid_out != nullptr) {
         char nm[64];
         std::snprintf(nm, sizeof(nm), "dec.block.%d.out", hp.dec_n_layers / 2);
@@ -1093,105 +1056,111 @@ transcribe_status run(transcribe_session *      context,
         try_dump(nm, pb.dumps.block_last_out, "decoder.block_last");
     }
     try_dump("dec.out_before_head", pb.dumps.out_before_head, "decoder.out_before_head");
-    try_dump("dec.logits_raw.gen0", pb.dumps.logits_raw,      "decoder.logits.gen0");
+    try_dump("dec.logits_raw.gen0", pb.dumps.logits_raw, "decoder.logits.gen0");
 
     // ---- Read prefill logits + first argmax ----
-    const int vocab = hp.dec_vocab_size;
+    const int          vocab = hp.dec_vocab_size;
     std::vector<float> logits(vocab);
-    ggml_backend_tensor_get(pb.out, logits.data(), 0,
-                            logits.size() * sizeof(float));
+    ggml_backend_tensor_get(pb.out, logits.data(), 0, logits.size() * sizeof(float));
 
     auto argmax = [&](const std::vector<float> & v) -> int32_t {
-        int32_t best = 0;
+        int32_t best   = 0;
         float   best_v = v[0];
         for (int32_t i = 1; i < static_cast<int32_t>(v.size()); ++i) {
-            if (v[i] > best_v) { best_v = v[i]; best = i; }
+            if (v[i] > best_v) {
+                best_v = v[i];
+                best   = i;
+            }
         }
         return best;
     };
 
     std::vector<int32_t> generated_ids;
-    int32_t next_tok = argmax(logits);
+    int32_t              next_tok = argmax(logits);
     generated_ids.push_back(next_tok);
 
     // Step loop.
-    const int32_t eos_id = hp.eos_token_id;
-    const int max_new = k_max_new;
-    int cur_past = T_prompt;
+    const int32_t eos_id   = hp.eos_token_id;
+    const int     max_new  = k_max_new;
+    int           cur_past = T_prompt;
 
     int max_n_kv = 1024;
-    while (max_n_kv < T_prompt + max_new) max_n_kv *= 2;
-    if (max_n_kv > cc->kv_cache.n_ctx) max_n_kv = cc->kv_cache.n_ctx;
+    while (max_n_kv < T_prompt + max_new) {
+        max_n_kv *= 2;
+    }
+    if (max_n_kv > cc->kv_cache.n_ctx) {
+        max_n_kv = cc->kv_cache.n_ctx;
+    }
 
     if (cc->compute_ctx != nullptr) {
         ggml_free(cc->compute_ctx);
         cc->compute_ctx = nullptr;
     }
     {
-        ggml_init_params ip {};
-        ip.mem_size   = 16 * 1024 * 1024;
-        ip.mem_buffer = nullptr;
-        ip.no_alloc   = true;
+        ggml_init_params ip{};
+        ip.mem_size     = 16 * 1024 * 1024;
+        ip.mem_buffer   = nullptr;
+        ip.no_alloc     = true;
         cc->compute_ctx = ggml_init(ip);
         if (cc->compute_ctx == nullptr) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "canary_qwen step: compute context allocation failed — "
-                "out of memory.");
+                                "canary_qwen step: compute context allocation failed — "
+                                "out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
     }
-    StepBuild sb = build_step_graph(cc->compute_ctx, cm->weights, hp,
-                                    cc->kv_cache, max_n_kv,
-                                    cc->decoder_use_flash);
+    StepBuild sb = build_step_graph(cc->compute_ctx, cm->weights, hp, cc->kv_cache, max_n_kv, cc->decoder_use_flash);
 
     if (profile_decode && sb.graph != nullptr) {
-        const int n_nodes = ggml_graph_n_nodes(sb.graph);
-        int op_counts[GGML_OP_COUNT] = {0};
+        const int n_nodes                  = ggml_graph_n_nodes(sb.graph);
+        int       op_counts[GGML_OP_COUNT] = { 0 };
         for (int ni = 0; ni < n_nodes; ++ni) {
             ggml_tensor * t = ggml_graph_node(sb.graph, ni);
-            if (t != nullptr) op_counts[t->op] += 1;
+            if (t != nullptr) {
+                op_counts[t->op] += 1;
+            }
         }
         log_msg(TRANSCRIBE_LOG_LEVEL_DEBUG, "[profile_decode] step graph: n_nodes=%d", n_nodes);
         int shown = 0;
         for (int o = 0; o < GGML_OP_COUNT && shown < 12; ++o) {
             if (op_counts[o] > 0) {
-                log_msg(TRANSCRIBE_LOG_LEVEL_DEBUG,
-                    "[profile_decode]   op %-22s x %4d",
-                    ggml_op_name(static_cast<ggml_op>(o)), op_counts[o]);
+                log_msg(TRANSCRIBE_LOG_LEVEL_DEBUG, "[profile_decode]   op %-22s x %4d",
+                        ggml_op_name(static_cast<ggml_op>(o)), op_counts[o]);
                 ++shown;
             }
         }
     }
-    if (sb.graph == nullptr || sb.out == nullptr) return TRANSCRIBE_ERR_GGUF;
+    if (sb.graph == nullptr || sb.out == nullptr) {
+        return TRANSCRIBE_ERR_GGUF;
+    }
 
     ggml_backend_sched_reset(cc->sched);
     if (!ggml_backend_sched_alloc_graph(cc->sched, sb.graph)) {
         transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "canary_qwen step: decode graph allocation failed — out of memory. "
-            "Lower transcribe_session_params.n_ctx or shorten the audio.");
+                            "canary_qwen step: decode graph allocation failed — out of memory. "
+                            "Lower transcribe_session_params.n_ctx or shorten the audio.");
         return TRANSCRIBE_ERR_OOM;
     }
 
-    const ggml_fp16_t mask_zero    = ggml_fp32_to_fp16(0.0f);
-    const ggml_fp16_t mask_neg_inf = ggml_fp32_to_fp16(-INFINITY);
+    const ggml_fp16_t        mask_zero    = ggml_fp32_to_fp16(0.0f);
+    const ggml_fp16_t        mask_neg_inf = ggml_fp32_to_fp16(-INFINITY);
     std::vector<ggml_fp16_t> step_mask(max_n_kv, mask_neg_inf);
 
     // Mid-generation tensor coverage: `dec.logits_raw.gen8` is the logits for
     // the 9th lm_head call (= step iter 7; prefill = 1st call, iter K =
     // (K+2)th call).
     constexpr int gen_dump_step = 7;
-    int n_steps = 0;
+    int           n_steps       = 0;
 
-    int64_t t_step_input_set_us = 0;
-    int64_t t_step_compute_us   = 0;
-    int64_t t_step_argmax_get_us = 0;
+    int64_t              t_step_input_set_us  = 0;
+    int64_t              t_step_compute_us    = 0;
+    int64_t              t_step_argmax_get_us = 0;
     std::vector<int64_t> per_step_compute_us;
-    if (profile_decode) per_step_compute_us.reserve(64);
+    if (profile_decode) {
+        per_step_compute_us.reserve(64);
+    }
 
-    while (next_tok != eos_id &&
-           static_cast<int32_t>(generated_ids.size()) < max_new &&
-           cur_past + 1 <= max_n_kv)
-    {
+    while (next_tok != eos_id && static_cast<int32_t>(generated_ids.size()) < max_new && cur_past + 1 <= max_n_kv) {
         const int64_t t_in0 = profile_decode ? ggml_time_us() : 0;
         ggml_backend_tensor_set(sb.input_id_in, &next_tok, 0, sizeof(int32_t));
         const int32_t pos_val = cur_past;
@@ -1200,24 +1169,18 @@ transcribe_status run(transcribe_session *      context,
         ggml_backend_tensor_set(sb.kv_idx_in, &kv_idx_val, 0, sizeof(int64_t));
 
         if (cur_past == T_prompt) {
-            std::fill(step_mask.begin(),
-                      step_mask.begin() + cur_past + 1, mask_zero);
+            std::fill(step_mask.begin(), step_mask.begin() + cur_past + 1, mask_zero);
         } else {
             step_mask[cur_past] = mask_zero;
         }
-        ggml_backend_tensor_set(sb.mask_in, step_mask.data(), 0,
-                                static_cast<size_t>(max_n_kv) *
-                                sizeof(ggml_fp16_t));
-        if (profile_decode) t_step_input_set_us += ggml_time_us() - t_in0;
+        ggml_backend_tensor_set(sb.mask_in, step_mask.data(), 0, static_cast<size_t>(max_n_kv) * sizeof(ggml_fp16_t));
+        if (profile_decode) {
+            t_step_input_set_us += ggml_time_us() - t_in0;
+        }
 
         const int64_t t_c0 = profile_decode ? ggml_time_us() : 0;
-        if (const ggml_status gs =
-                ggml_backend_sched_graph_compute(cc->sched, sb.graph);
-            gs != GGML_STATUS_SUCCESS)
-        {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "canary_qwen run: step compute failed (%d)",
-                         static_cast<int>(gs));
+        if (const ggml_status gs = ggml_backend_sched_graph_compute(cc->sched, sb.graph); gs != GGML_STATUS_SUCCESS) {
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "canary_qwen run: step compute failed (%d)", static_cast<int>(gs));
             return TRANSCRIBE_ERR_GGUF;
         }
         if (profile_decode) {
@@ -1226,10 +1189,12 @@ transcribe_status run(transcribe_session *      context,
             per_step_compute_us.push_back(dt);
         }
 
-        const int64_t t_a0 = profile_decode ? ggml_time_us() : 0;
-        int32_t argmax_tok = 0;
+        const int64_t t_a0       = profile_decode ? ggml_time_us() : 0;
+        int32_t       argmax_tok = 0;
         ggml_backend_tensor_get(sb.out, &argmax_tok, 0, sizeof(int32_t));
-        if (profile_decode) t_step_argmax_get_us += ggml_time_us() - t_a0;
+        if (profile_decode) {
+            t_step_argmax_get_us += ggml_time_us() - t_a0;
+        }
         next_tok = argmax_tok;
         generated_ids.push_back(next_tok);
 
@@ -1238,62 +1203,55 @@ transcribe_status run(transcribe_session *      context,
         }
 
         cur_past += 1;
-        n_steps  += 1;
+        n_steps += 1;
     }
 
     // Decode stopped at EOS (complete) or the generation budget / context width
     // (truncated). Surface the latter via transcribe_was_truncated() + WARN.
     if (next_tok != eos_id) {
         cc->was_truncated = true;
-        transcribe::log_msg(
-            TRANSCRIBE_LOG_LEVEL_WARN,
-            "canary_qwen run: output truncated at %d tokens — decode reached "
-            "the generation budget before end-of-stream; the transcript may "
-            "be incomplete.",
-            static_cast<int>(generated_ids.size()));
+        transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_WARN,
+                            "canary_qwen run: output truncated at %d tokens — decode reached "
+                            "the generation budget before end-of-stream; the transcript may "
+                            "be incomplete.",
+                            static_cast<int>(generated_ids.size()));
     }
 
     if (profile_decode) {
         const int n = n_steps;
+        log_msg(TRANSCRIBE_LOG_LEVEL_DEBUG, "[profile_decode] T_prompt=%d max_n_kv=%d steps=%d use_flash=%d", T_prompt,
+                max_n_kv, n, cc->decoder_use_flash ? 1 : 0);
+        log_msg(TRANSCRIBE_LOG_LEVEL_DEBUG, "[profile_decode] prefill_compute=%.2f ms", t_prefill_compute_us / 1000.0);
         log_msg(TRANSCRIBE_LOG_LEVEL_DEBUG,
-            "[profile_decode] T_prompt=%d max_n_kv=%d steps=%d use_flash=%d",
-            T_prompt, max_n_kv, n, cc->decoder_use_flash ? 1 : 0);
-        log_msg(TRANSCRIBE_LOG_LEVEL_DEBUG,
-            "[profile_decode] prefill_compute=%.2f ms",
-            t_prefill_compute_us / 1000.0);
-        log_msg(TRANSCRIBE_LOG_LEVEL_DEBUG,
-            "[profile_decode] step totals: input_set=%.2f ms compute=%.2f ms argmax_get=%.2f ms",
-            t_step_input_set_us / 1000.0, t_step_compute_us / 1000.0,
-            t_step_argmax_get_us / 1000.0);
+                "[profile_decode] step totals: input_set=%.2f ms compute=%.2f ms argmax_get=%.2f ms",
+                t_step_input_set_us / 1000.0, t_step_compute_us / 1000.0, t_step_argmax_get_us / 1000.0);
         if (n > 0) {
             std::vector<int64_t> sorted = per_step_compute_us;
             std::sort(sorted.begin(), sorted.end());
             const auto pct = [&](double p) {
                 size_t idx = static_cast<size_t>(p * (n - 1));
-                if (idx >= sorted.size()) idx = sorted.size() - 1;
+                if (idx >= sorted.size()) {
+                    idx = sorted.size() - 1;
+                }
                 return sorted[idx] / 1000.0;
             };
             log_msg(TRANSCRIBE_LOG_LEVEL_DEBUG,
-                "[profile_decode] per-step compute ms: mean=%.2f p50=%.2f p90=%.2f p99=%.2f min=%.2f max=%.2f",
-                (t_step_compute_us / 1000.0) / n,
-                pct(0.50), pct(0.90), pct(0.99),
-                sorted.front() / 1000.0, sorted.back() / 1000.0);
-            log_msg(TRANSCRIBE_LOG_LEVEL_DEBUG,
-                "[profile_decode] per-step input_set ms: mean=%.3f",
-                (t_step_input_set_us / 1000.0) / n);
-            log_msg(TRANSCRIBE_LOG_LEVEL_DEBUG,
-                "[profile_decode] per-step argmax_get ms: mean=%.3f",
-                (t_step_argmax_get_us / 1000.0) / n);
+                    "[profile_decode] per-step compute ms: mean=%.2f p50=%.2f p90=%.2f p99=%.2f min=%.2f max=%.2f",
+                    (t_step_compute_us / 1000.0) / n, pct(0.50), pct(0.90), pct(0.99), sorted.front() / 1000.0,
+                    sorted.back() / 1000.0);
+            log_msg(TRANSCRIBE_LOG_LEVEL_DEBUG, "[profile_decode] per-step input_set ms: mean=%.3f",
+                    (t_step_input_set_us / 1000.0) / n);
+            log_msg(TRANSCRIBE_LOG_LEVEL_DEBUG, "[profile_decode] per-step argmax_get ms: mean=%.3f",
+                    (t_step_argmax_get_us / 1000.0) / n);
         }
     }
-    (void)n_steps;
+    (void) n_steps;
 
     if (!generated_ids.empty() && generated_ids.back() == eos_id) {
         generated_ids.pop_back();
     }
 
-    std::string transcript = cm->tok.decode(
-        generated_ids.data(), static_cast<int>(generated_ids.size()));
+    std::string transcript = cm->tok.decode(generated_ids.data(), static_cast<int>(generated_ids.size()));
 
     cc->t_decode_us = ggml_time_us() - t_dec_start;
 
@@ -1301,20 +1259,18 @@ transcribe_status run(transcribe_session *      context,
     cc->result_kind = TRANSCRIBE_TIMESTAMPS_NONE;
     cc->has_result  = true;
 
-    transcribe_session::SegmentEntry seg {};
+    transcribe_session::SegmentEntry seg{};
     seg.text  = transcript;
     seg.t0_ms = 0;
-    seg.t1_ms = static_cast<int64_t>(n_samples) * 1000
-              / static_cast<int64_t>(hp.fe_sample_rate);
+    seg.t1_ms = static_cast<int64_t>(n_samples) * 1000 / static_cast<int64_t>(hp.fe_sample_rate);
     cc->segments.push_back(std::move(seg));
 
     // A truncated decode returns OUTPUT_TRUNCATED; the partial transcript above
     // stays readable (like an aborted run).
-    return cc->was_truncated ? TRANSCRIBE_ERR_OUTPUT_TRUNCATED
-                             : TRANSCRIBE_OK;
+    return cc->was_truncated ? TRANSCRIBE_ERR_OUTPUT_TRUNCATED : TRANSCRIBE_OK;
 }
 
-} // namespace
+}  // namespace
 
 // ===========================================================================
 // Offline batched decode (transcribe_run_batch)
@@ -1331,100 +1287,113 @@ transcribe_status reset_ctx(CanaryQwenSession * cc, int mb) {
         ggml_free(cc->compute_ctx);
         cc->compute_ctx = nullptr;
     }
-    ggml_init_params ip {};
-    ip.mem_size   = static_cast<size_t>(mb) * 1024 * 1024;
-    ip.mem_buffer = nullptr;
-    ip.no_alloc   = true;
+    ggml_init_params ip{};
+    ip.mem_size     = static_cast<size_t>(mb) * 1024 * 1024;
+    ip.mem_buffer   = nullptr;
+    ip.no_alloc     = true;
     cc->compute_ctx = ggml_init(ip);
     return cc->compute_ctx != nullptr ? TRANSCRIBE_OK : TRANSCRIBE_ERR_GGUF;
 }
 
 // Conformer encoder (+ perception) for one utterance from a PRECOMPUTED mel
 // buffer (the mel is computed in parallel by the caller) → [hidden, T_enc].
-transcribe_status encode_one(
-    CanaryQwenSession * cc, CanaryQwenModel * cm,
-    const std::vector<float> & mel_buf, int mel_n_frames,
-    std::vector<float> & enc_out, int & T_enc_out,
-    int64_t & enc_us) {
+transcribe_status encode_one(CanaryQwenSession *        cc,
+                             CanaryQwenModel *          cm,
+                             const std::vector<float> & mel_buf,
+                             int                        mel_n_frames,
+                             std::vector<float> &       enc_out,
+                             int &                      T_enc_out,
+                             int64_t &                  enc_us) {
     const auto & hp = cm->hparams;
-    if (mel_n_frames <= 0) return TRANSCRIBE_ERR_GGUF;
+    if (mel_n_frames <= 0) {
+        return TRANSCRIBE_ERR_GGUF;
+    }
 
-    if (reset_ctx(cc, 32) != TRANSCRIBE_OK) return TRANSCRIBE_ERR_GGUF;
-    EncoderBuild eb = build_encoder_graph(
-        cc->compute_ctx, cm->weights, hp, mel_n_frames,
-        /*kv_type=*/GGML_TYPE_COUNT, cc->encoder_use_flash, cm->backend.c_str());
-    if (eb.graph == nullptr || eb.out == nullptr) return TRANSCRIBE_ERR_GGUF;
+    if (reset_ctx(cc, 32) != TRANSCRIBE_OK) {
+        return TRANSCRIBE_ERR_GGUF;
+    }
+    EncoderBuild eb = build_encoder_graph(cc->compute_ctx, cm->weights, hp, mel_n_frames,
+                                          /*kv_type=*/GGML_TYPE_COUNT, cc->encoder_use_flash, cm->backend.c_str());
+    if (eb.graph == nullptr || eb.out == nullptr) {
+        return TRANSCRIBE_ERR_GGUF;
+    }
 
     if (cc->sched == nullptr) {
-        cc->sched = ggml_backend_sched_new(
-            cm->plan.scheduler_list.data(), nullptr,
-            static_cast<int>(cm->plan.scheduler_list.size()),
-            16384, false, true);
-        if (cc->sched == nullptr) return TRANSCRIBE_ERR_GGUF;
+        cc->sched = ggml_backend_sched_new(cm->plan.scheduler_list.data(), nullptr,
+                                           static_cast<int>(cm->plan.scheduler_list.size()), 16384, false, true);
+        if (cc->sched == nullptr) {
+            return TRANSCRIBE_ERR_GGUF;
+        }
     }
     ggml_backend_sched_reset(cc->sched);
-    if (!ggml_backend_sched_alloc_graph(cc->sched, eb.graph)) return TRANSCRIBE_ERR_GGUF;
+    if (!ggml_backend_sched_alloc_graph(cc->sched, eb.graph)) {
+        return TRANSCRIBE_ERR_GGUF;
+    }
 
-    ggml_backend_tensor_set(eb.mel_in, mel_buf.data(),
-                            0, mel_buf.size() * sizeof(float));
+    ggml_backend_tensor_set(eb.mel_in, mel_buf.data(), 0, mel_buf.size() * sizeof(float));
     if (eb.pos_emb_in != nullptr) {
         const int d_model = hp.enc_d_model;
         const int pos_len = static_cast<int>(eb.pos_emb_in->ne[1]);
         const int T_enc   = (pos_len + 1) / 2;
         build_relpos_emb_host(cc->pos_buf, cc->pos_div_term, d_model, T_enc);
-        ggml_backend_tensor_set(eb.pos_emb_in, cc->pos_buf.data(),
-                                0, cc->pos_buf.size() * sizeof(float));
+        ggml_backend_tensor_set(eb.pos_emb_in, cc->pos_buf.data(), 0, cc->pos_buf.size() * sizeof(float));
     }
     apply_thread_policy(cc);
 
     const int64_t t_enc0 = ggml_time_us();
-    if (ggml_backend_sched_graph_compute(cc->sched, eb.graph) != GGML_STATUS_SUCCESS)
+    if (ggml_backend_sched_graph_compute(cc->sched, eb.graph) != GGML_STATUS_SUCCESS) {
         return TRANSCRIBE_ERR_GGUF;
+    }
     enc_us += ggml_time_us() - t_enc0;
 
     const int hidden = static_cast<int>(eb.out->ne[0]);
-    T_enc_out = static_cast<int>(eb.out->ne[1]);
+    T_enc_out        = static_cast<int>(eb.out->ne[1]);
     enc_out.resize(static_cast<size_t>(hidden) * T_enc_out);
     ggml_backend_tensor_get(eb.out, enc_out.data(), 0, enc_out.size() * sizeof(float));
     return TRANSCRIBE_OK;
 }
 
-transcribe_status run_batch_serial(CanaryQwenSession * cc,
-                                   const float * const * pcm,
-                                   const int * n_samples, int n,
+transcribe_status run_batch_serial(CanaryQwenSession *           cc,
+                                   const float * const *         pcm,
+                                   const int *                   n_samples,
+                                   int                           n,
                                    const transcribe_run_params * params) {
     for (int i = 0; i < n; ++i) {
-        if (cc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
-        const transcribe_status st =
-            (pcm[i] == nullptr || n_samples[i] <= 0)
-                ? TRANSCRIBE_ERR_INVALID_ARG
-                : run(cc, pcm[i], n_samples[i], params);
-        if (st == TRANSCRIBE_OK) cc->batch_results.push_back(cc->capture_result(st));
-        else {
-            transcribe_session::ResultSet rs; rs.status = st;
+        if (cc->poll_abort()) {
+            return TRANSCRIBE_ERR_ABORTED;
+        }
+        const transcribe_status st = (pcm[i] == nullptr || n_samples[i] <= 0) ? TRANSCRIBE_ERR_INVALID_ARG :
+                                                                                run(cc, pcm[i], n_samples[i], params);
+        if (st == TRANSCRIBE_OK) {
+            cc->batch_results.push_back(cc->capture_result(st));
+        } else {
+            transcribe_session::ResultSet rs;
+            rs.status = st;
             cc->batch_results.push_back(std::move(rs));
         }
     }
     return TRANSCRIBE_OK;
 }
 
-} // namespace
+}  // namespace
 
-transcribe_status run_batch(
-    transcribe_session *          session,
-    const float * const *         pcm,
-    const int *                   n_samples,
-    int                           n,
-    const transcribe_run_params * params) {
-    if (session == nullptr || pcm == nullptr || n_samples == nullptr || n <= 0)
+transcribe_status run_batch(transcribe_session *          session,
+                            const float * const *         pcm,
+                            const int *                   n_samples,
+                            int                           n,
+                            const transcribe_run_params * params) {
+    if (session == nullptr || pcm == nullptr || n_samples == nullptr || n <= 0) {
         return TRANSCRIBE_ERR_INVALID_ARG;
+    }
     auto * cc = static_cast<CanaryQwenSession *>(session);
     auto * cm = static_cast<CanaryQwenModel *>(cc->model);
-    if (cm == nullptr || cm->plan.scheduler_list.empty() || !cm->mel.has_value())
+    if (cm == nullptr || cm->plan.scheduler_list.empty() || !cm->mel.has_value()) {
         return TRANSCRIBE_ERR_INVALID_ARG;
+    }
 
-    if (!cc->decoder_use_flash || transcribe::debug::enabled() || n == 1)
+    if (!cc->decoder_use_flash || transcribe::debug::enabled() || n == 1) {
         return run_batch_serial(cc, pcm, n_samples, n, params);
+    }
 
     transcribe::debug::init();
     const auto & hp = cm->hparams;
@@ -1433,61 +1402,66 @@ transcribe_status run_batch(
     // single-utterance run() enforces.
     const int ceiling = canary_qwen_context_ceiling(cc->n_ctx, hp);
 
-    std::vector<char> valid(n, 0);
+    std::vector<char>                 valid(n, 0);
     // Per-utterance failure status. Defaults to INVALID_ARG (bad pcm/mel/
     // encode); the input-length gate upgrades it to INPUT_TOO_LONG.
-    std::vector<transcribe_status> fail_status(n, TRANSCRIBE_ERR_INVALID_ARG);
-    std::vector<std::vector<float>> enc_hosts(n);
-    std::vector<int> T_enc(n, 0);
+    std::vector<transcribe_status>    fail_status(n, TRANSCRIBE_ERR_INVALID_ARG);
+    std::vector<std::vector<float>>   enc_hosts(n);
+    std::vector<int>                  T_enc(n, 0);
     std::vector<std::vector<int32_t>> prompt_ids(n);
-    std::vector<int> T_prompt(n, 0);
-    int prefix_len = static_cast<int>(cm->prompt_prefix_ids.size());
-    int64_t mel_us = 0, enc_us = 0;
+    std::vector<int>                  T_prompt(n, 0);
+    int                               prefix_len = static_cast<int>(cm->prompt_prefix_ids.size());
+    int64_t                           mel_us = 0, enc_us = 0;
 
     // Pass 0: parallel mel (MelFrontend::compute is thread-safe).
     std::vector<std::vector<float>> mel_bufs(n);
-    std::vector<int> mel_nf(n, 0);
-    int n_mel_threads = cc->n_threads;
-    if (n_mel_threads <= 0)
+    std::vector<int>                mel_nf(n, 0);
+    int                             n_mel_threads = cc->n_threads;
+    if (n_mel_threads <= 0) {
         n_mel_threads = transcribe::default_n_threads();
+    }
     const int64_t t_mel0 = ggml_time_us();
     transcribe::parallel_for_all(n, n_mel_threads, [&](int b) {
-        if (pcm[b] == nullptr || n_samples[b] <= 0) return true;
+        if (pcm[b] == nullptr || n_samples[b] <= 0) {
+            return true;
+        }
         int nm = 0, nf = 0;
-        if (cm->mel->compute(pcm[b], static_cast<size_t>(n_samples[b]),
-                             mel_bufs[b], nm, nf, /*n_threads=*/1) == TRANSCRIBE_OK)
+        if (cm->mel->compute(pcm[b], static_cast<size_t>(n_samples[b]), mel_bufs[b], nm, nf, /*n_threads=*/1) ==
+            TRANSCRIBE_OK) {
             mel_nf[b] = nf;
+        }
         return true;
     });
     mel_us += ggml_time_us() - t_mel0;
 
     // Pass 1: per-utterance encoder (serial).
     for (int b = 0; b < n; ++b) {
-        if (cc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
-        if (mel_nf[b] <= 0) continue;
-        if (encode_one(cc, cm, mel_bufs[b], mel_nf[b],
-                       enc_hosts[b], T_enc[b], enc_us) != TRANSCRIBE_OK)
+        if (cc->poll_abort()) {
+            return TRANSCRIBE_ERR_ABORTED;
+        }
+        if (mel_nf[b] <= 0) {
             continue;
+        }
+        if (encode_one(cc, cm, mel_bufs[b], mel_nf[b], enc_hosts[b], T_enc[b], enc_us) != TRANSCRIBE_OK) {
+            continue;
+        }
         // Prompt: prefix + audio_locator * T_enc + suffix.
         prompt_ids[b] = cm->prompt_prefix_ids;
-        for (int i = 0; i < T_enc[b]; ++i)
+        for (int i = 0; i < T_enc[b]; ++i) {
             prompt_ids[b].push_back(hp.audio_locator_id);
-        prompt_ids[b].insert(prompt_ids[b].end(),
-                             cm->prompt_suffix_ids.begin(),
-                             cm->prompt_suffix_ids.end());
+        }
+        prompt_ids[b].insert(prompt_ids[b].end(), cm->prompt_suffix_ids.begin(), cm->prompt_suffix_ids.end());
         T_prompt[b] = static_cast<int>(prompt_ids[b].size());
 
         // Input-length gate (same as single-shot run()); reject this utterance,
         // the rest of the batch still runs.
         if (T_prompt[b] + k_max_new > ceiling) {
-            transcribe::log_msg(
-                TRANSCRIBE_LOG_LEVEL_ERROR,
-                "canary_qwen run_batch: utterance %d input too long — %d audio "
-                "+ %d prompt tokens leave no room for output within the "
-                "%d-token context (need %d). Shorten the audio (see "
-                "transcribe_capabilities.max_audio_ms) or split it.",
-                b, T_enc[b], T_prompt[b] - T_enc[b], ceiling,
-                T_prompt[b] + k_max_new);
+            transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
+                                "canary_qwen run_batch: utterance %d input too long — %d audio "
+                                "+ %d prompt tokens leave no room for output within the "
+                                "%d-token context (need %d). Shorten the audio (see "
+                                "transcribe_capabilities.max_audio_ms) or split it.",
+                                b, T_enc[b], T_prompt[b] - T_enc[b], ceiling, T_prompt[b] + k_max_new);
             fail_status[b] = TRANSCRIBE_ERR_INPUT_TOO_LONG;
             continue;
         }
@@ -1495,88 +1469,97 @@ transcribe_status run_batch(
     }
 
     int max_T_prompt = 0, T_enc_max = 0;
-    for (int b = 0; b < n; ++b) if (valid[b]) {
-        max_T_prompt = std::max(max_T_prompt, T_prompt[b]);
-        T_enc_max    = std::max(T_enc_max, T_enc[b]);
+    for (int b = 0; b < n; ++b) {
+        if (valid[b]) {
+            max_T_prompt = std::max(max_T_prompt, T_prompt[b]);
+            T_enc_max    = std::max(T_enc_max, T_enc[b]);
+        }
     }
     if (max_T_prompt == 0) {
         for (int b = 0; b < n; ++b) {
-            transcribe_session::ResultSet rs; rs.status = fail_status[b];
+            transcribe_session::ResultSet rs;
+            rs.status = fail_status[b];
             cc->batch_results.push_back(std::move(rs));
         }
         return TRANSCRIBE_OK;
     }
-    T_enc_max = std::max(1, T_enc_max);
-    const int max_new = k_max_new;
-    int max_n_kv = 1024;
-    while (max_n_kv < max_T_prompt + max_new) max_n_kv *= 2;
+    T_enc_max          = std::max(1, T_enc_max);
+    const int max_new  = k_max_new;
+    int       max_n_kv = 1024;
+    while (max_n_kv < max_T_prompt + max_new) {
+        max_n_kv *= 2;
+    }
     // Clamp the pow2 round-up to the ceiling (the per-utterance gate guarantees
     // every valid row still fits).
-    if (max_n_kv > ceiling) max_n_kv = ceiling;
+    if (max_n_kv > ceiling) {
+        max_n_kv = ceiling;
+    }
 
     // Allocate batched KV cache.
-    ggml_type kv_type = (cc->kv_type == TRANSCRIBE_KV_TYPE_F32)
-                      ? GGML_TYPE_F32 : GGML_TYPE_F16;
-    if (cc->kv_cache_batch.self_k == nullptr ||
-        cc->kv_batch_cap != n || cc->kv_batch_n_ctx != max_n_kv) {
+    ggml_type kv_type = (cc->kv_type == TRANSCRIBE_KV_TYPE_F32) ? GGML_TYPE_F32 : GGML_TYPE_F16;
+    if (cc->kv_cache_batch.self_k == nullptr || cc->kv_batch_cap != n || cc->kv_batch_n_ctx != max_n_kv) {
         cc->kv_cache_batch.free();
-        if (!transcribe::causal_lm::kv_init_batched(
-                cc->kv_cache_batch, cm->plan.primary, max_n_kv,
-                hp.dec_n_kv_heads, hp.dec_head_dim, hp.dec_n_layers, n, kv_type)) {
+        if (!transcribe::causal_lm::kv_init_batched(cc->kv_cache_batch, cm->plan.primary, max_n_kv, hp.dec_n_kv_heads,
+                                                    hp.dec_head_dim, hp.dec_n_layers, n, kv_type)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "canary_qwen run_batch: batched KV cache allocation failed "
-                "(n_ctx=%d x %d utterances) — out of memory. Lower "
-                "transcribe_session_params.n_ctx or the batch size.",
-                max_n_kv, n);
+                                "canary_qwen run_batch: batched KV cache allocation failed "
+                                "(n_ctx=%d x %d utterances) — out of memory. Lower "
+                                "transcribe_session_params.n_ctx or the batch size.",
+                                max_n_kv, n);
             return TRANSCRIBE_ERR_OOM;
         }
-        cc->kv_batch_cap = n; cc->kv_batch_n_ctx = max_n_kv;
+        cc->kv_batch_cap   = n;
+        cc->kv_batch_n_ctx = max_n_kv;
     } else if (cc->kv_cache_batch.buffer != nullptr) {
         ggml_backend_buffer_clear(cc->kv_cache_batch.buffer, 0);
     }
 
     // Pass 2: batched prefill.
-    std::vector<int32_t> next_tok(n, 0);
-    std::vector<int> n_past(n, 0);
+    std::vector<int32_t>              next_tok(n, 0);
+    std::vector<int>                  n_past(n, 0);
     std::vector<std::vector<int32_t>> generated(n);
     {
-        if (reset_ctx(cc, 32) != TRANSCRIBE_OK) return TRANSCRIBE_ERR_GGUF;
-        PrefillBuildBatched pb = build_prefill_graph_batched(
-            cc->compute_ctx, cm->weights, hp, cc->kv_cache_batch,
-            max_T_prompt, T_enc_max, n, cc->decoder_use_flash);
-        if (pb.graph == nullptr || pb.out == nullptr) return TRANSCRIBE_ERR_GGUF;
+        if (reset_ctx(cc, 32) != TRANSCRIBE_OK) {
+            return TRANSCRIBE_ERR_GGUF;
+        }
+        PrefillBuildBatched pb = build_prefill_graph_batched(cc->compute_ctx, cm->weights, hp, cc->kv_cache_batch,
+                                                             max_T_prompt, T_enc_max, n, cc->decoder_use_flash);
+        if (pb.graph == nullptr || pb.out == nullptr) {
+            return TRANSCRIBE_ERR_GGUF;
+        }
         ggml_backend_sched_reset(cc->sched);
-        if (!ggml_backend_sched_alloc_graph(cc->sched, pb.graph)) return TRANSCRIBE_ERR_GGUF;
+        if (!ggml_backend_sched_alloc_graph(cc->sched, pb.graph)) {
+            return TRANSCRIBE_ERR_GGUF;
+        }
 
-        const int hidden = hp.dec_hidden;
+        const int            hidden = hp.dec_hidden;
         std::vector<int32_t> ids(static_cast<size_t>(max_T_prompt) * n, 0);
         // Audio injection by elementwise blend (see decoder.h): audio_dense
         // holds each utterance's audio embeds scattered into their prompt
         // positions, keep is 0 there and 1 elsewhere.
-        std::vector<float> audio_dense(static_cast<size_t>(hidden) * max_T_prompt * n, 0.0f);
-        std::vector<float> keep(static_cast<size_t>(max_T_prompt) * n, 1.0f);
+        std::vector<float>   audio_dense(static_cast<size_t>(hidden) * max_T_prompt * n, 0.0f);
+        std::vector<float>   keep(static_cast<size_t>(max_T_prompt) * n, 1.0f);
         std::vector<int64_t> kidx(static_cast<size_t>(max_T_prompt) * n);
         std::vector<int32_t> lidx(n, 0);
         for (int b = 0; b < n; ++b) {
             const int ta = valid[b] ? T_enc[b] : 0;
             const int tp = valid[b] ? T_prompt[b] : 0;
             if (valid[b]) {
-                std::memcpy(ids.data() + static_cast<size_t>(b) * max_T_prompt,
-                            prompt_ids[b].data(),
+                std::memcpy(ids.data() + static_cast<size_t>(b) * max_T_prompt, prompt_ids[b].data(),
                             static_cast<size_t>(tp) * sizeof(int32_t));
                 // enc_hosts[b] is [hidden, ta] column-major; audio token j lands
                 // at prompt position prefix_len+j, flat column b*max_T_prompt+pos.
                 for (int j = 0; j < ta; ++j) {
-                    const size_t dst_col =
-                        static_cast<size_t>(b) * max_T_prompt + (prefix_len + j);
+                    const size_t dst_col = static_cast<size_t>(b) * max_T_prompt + (prefix_len + j);
                     std::memcpy(audio_dense.data() + dst_col * hidden,
                                 enc_hosts[b].data() + static_cast<size_t>(j) * hidden,
                                 static_cast<size_t>(hidden) * sizeof(float));
                     keep[dst_col] = 0.0f;
                 }
             }
-            for (int t = 0; t < max_T_prompt; ++t)
+            for (int t = 0; t < max_T_prompt; ++t) {
                 kidx[static_cast<size_t>(b) * max_T_prompt + t] = t;
+            }
             lidx[b] = valid[b] ? (tp - 1) : 0;
         }
         ggml_backend_tensor_set(pb.input_ids_in, ids.data(), 0, ids.size() * sizeof(int32_t));
@@ -1584,28 +1567,35 @@ transcribe_status run_batch(
         ggml_backend_tensor_set(pb.keep_mask_in, keep.data(), 0, keep.size() * sizeof(float));
         {
             std::vector<int32_t> pos(max_T_prompt);
-            for (int t = 0; t < max_T_prompt; ++t) pos[t] = t;
+            for (int t = 0; t < max_T_prompt; ++t) {
+                pos[t] = t;
+            }
             ggml_backend_tensor_set(pb.positions_in, pos.data(), 0, pos.size() * sizeof(int32_t));
         }
         {
-            const ggml_fp16_t mz = ggml_fp32_to_fp16(0.0f);
-            const ggml_fp16_t mn = ggml_fp32_to_fp16(-INFINITY);
+            const ggml_fp16_t        mz = ggml_fp32_to_fp16(0.0f);
+            const ggml_fp16_t        mn = ggml_fp32_to_fp16(-INFINITY);
             std::vector<ggml_fp16_t> mask(static_cast<size_t>(max_T_prompt) * max_T_prompt, mn);
-            for (int q = 0; q < max_T_prompt; ++q)
+            for (int q = 0; q < max_T_prompt; ++q) {
                 std::fill(mask.begin() + static_cast<size_t>(q) * max_T_prompt,
                           mask.begin() + static_cast<size_t>(q) * max_T_prompt + q + 1, mz);
+            }
             ggml_backend_tensor_set(pb.mask_in, mask.data(), 0, mask.size() * sizeof(ggml_fp16_t));
         }
         ggml_backend_tensor_set(pb.kv_idx_in, kidx.data(), 0, kidx.size() * sizeof(int64_t));
         ggml_backend_tensor_set(pb.last_idx_in, lidx.data(), 0, lidx.size() * sizeof(int32_t));
         apply_thread_policy(cc);
-        if (ggml_backend_sched_graph_compute(cc->sched, pb.graph) != GGML_STATUS_SUCCESS)
+        if (ggml_backend_sched_graph_compute(cc->sched, pb.graph) != GGML_STATUS_SUCCESS) {
             return TRANSCRIBE_ERR_GGUF;
+        }
         std::vector<int32_t> amax(n, 0);
         ggml_backend_tensor_get(pb.out, amax.data(), 0, amax.size() * sizeof(int32_t));
         for (int b = 0; b < n; ++b) {
-            if (!valid[b]) continue;
-            n_past[b] = T_prompt[b]; next_tok[b] = amax[b];
+            if (!valid[b]) {
+                continue;
+            }
+            n_past[b]   = T_prompt[b];
+            next_tok[b] = amax[b];
             generated[b].push_back(amax[b]);
         }
     }
@@ -1613,15 +1603,20 @@ transcribe_status run_batch(
     // Pass 3: batched step loop (shared causal_lm driver).
     const int32_t eos_id = cm->hparams.eos_token_id;
 
-    if (reset_ctx(cc, 16) != TRANSCRIBE_OK) return TRANSCRIBE_ERR_GGUF;
-    StepBuildBatched sb = build_step_graph_batched(
-        cc->compute_ctx, cm->weights, hp, cc->kv_cache_batch,
-        max_n_kv, n, cc->decoder_use_flash);
-    if (sb.graph == nullptr || sb.out == nullptr) return TRANSCRIBE_ERR_GGUF;
+    if (reset_ctx(cc, 16) != TRANSCRIBE_OK) {
+        return TRANSCRIBE_ERR_GGUF;
+    }
+    StepBuildBatched sb = build_step_graph_batched(cc->compute_ctx, cm->weights, hp, cc->kv_cache_batch, max_n_kv, n,
+                                                   cc->decoder_use_flash);
+    if (sb.graph == nullptr || sb.out == nullptr) {
+        return TRANSCRIBE_ERR_GGUF;
+    }
     ggml_backend_sched_reset(cc->sched);
-    if (!ggml_backend_sched_alloc_graph(cc->sched, sb.graph)) return TRANSCRIBE_ERR_GGUF;
+    if (!ggml_backend_sched_alloc_graph(cc->sched, sb.graph)) {
+        return TRANSCRIBE_ERR_GGUF;
+    }
 
-    transcribe::causal_lm::StepBatchedIO io {};
+    transcribe::causal_lm::StepBatchedIO io{};
     io.input_ids = sb.input_ids_in;
     io.positions = sb.position_in;
     io.kv_idx    = sb.kv_idx_in;
@@ -1635,43 +1630,45 @@ transcribe_status run_batch(
     step_state.n_past   = n_past;
 
     transcribe::causal_lm::StepLoopStats step_stats;
-    std::vector<char> truncated;
+    std::vector<char>                    truncated;
     if (const transcribe_status st = transcribe::causal_lm::run_batched_step_loop(
-            cc, cc->sched, io, n, max_n_kv, eos_id, max_new, step_state,
-            generated, &step_stats, &truncated); st != TRANSCRIBE_OK) {
+            cc, cc->sched, io, n, max_n_kv, eos_id, max_new, step_state, generated, &step_stats, &truncated);
+        st != TRANSCRIBE_OK) {
         return st;
     }
     const int64_t step_us = step_stats.step_us;
 
     // Capture results.
-    const int valid_count = std::max(1, static_cast<int>(
-        std::count(valid.begin(), valid.end(), char(1))));
+    const int valid_count = std::max(1, static_cast<int>(std::count(valid.begin(), valid.end(), char(1))));
     for (int b = 0; b < n; ++b) {
         if (!valid[b]) {
-            transcribe_session::ResultSet rs; rs.status = fail_status[b];
+            transcribe_session::ResultSet rs;
+            rs.status = fail_status[b];
             cc->batch_results.push_back(std::move(rs));
             continue;
         }
         std::vector<int32_t> gen = generated[b];
-        if (!gen.empty() && gen.back() == eos_id) gen.pop_back();
-        std::string transcript = cm->tok.decode(gen.data(), static_cast<int>(gen.size()));
+        if (!gen.empty() && gen.back() == eos_id) {
+            gen.pop_back();
+        }
+        std::string                   transcript = cm->tok.decode(gen.data(), static_cast<int>(gen.size()));
         transcribe_session::ResultSet rs;
-        rs.full_text = transcript;
+        rs.full_text   = transcript;
         rs.result_kind = TRANSCRIBE_TIMESTAMPS_NONE;
-        rs.has_result = true; rs.status = TRANSCRIBE_OK;
-        transcribe_session::SegmentEntry seg {};
-        seg.text = transcript; seg.t0_ms = 0;
-        seg.t1_ms = static_cast<int64_t>(n_samples[b]) * 1000
-                  / static_cast<int64_t>(hp.fe_sample_rate);
+        rs.has_result  = true;
+        rs.status      = TRANSCRIBE_OK;
+        transcribe_session::SegmentEntry seg{};
+        seg.text  = transcript;
+        seg.t0_ms = 0;
+        seg.t1_ms = static_cast<int64_t>(n_samples[b]) * 1000 / static_cast<int64_t>(hp.fe_sample_rate);
         rs.segments.push_back(std::move(seg));
         // Per-utterance truncation parity with single-shot run(). Only override
         // a TRANSCRIBE_OK status, never a worse one.
-        if (b < static_cast<int>(truncated.size()) && truncated[b] &&
-            rs.status == TRANSCRIBE_OK) {
+        if (b < static_cast<int>(truncated.size()) && truncated[b] && rs.status == TRANSCRIBE_OK) {
             cc->was_truncated = true;
-            rs.status = TRANSCRIBE_ERR_OUTPUT_TRUNCATED;
+            rs.status         = TRANSCRIBE_ERR_OUTPUT_TRUNCATED;
         }
-        rs.t_mel_us = mel_us / valid_count;
+        rs.t_mel_us    = mel_us / valid_count;
         rs.t_encode_us = enc_us / valid_count;
         rs.t_decode_us = step_us / valid_count;
         cc->batch_results.push_back(std::move(rs));
@@ -1693,4 +1690,4 @@ extern const Arch arch = {
     /* .accepts_ext_kind = */ nullptr,
 };
 
-} // namespace transcribe::canary_qwen
+}  // namespace transcribe::canary_qwen
diff --git a/src/arch/canary_qwen/weights.cpp b/src/arch/canary_qwen/weights.cpp
index c887edb0..df162f63 100644
--- a/src/arch/canary_qwen/weights.cpp
+++ b/src/arch/canary_qwen/weights.cpp
@@ -9,12 +9,11 @@
 
 #include "weights.h"
 
-#include "transcribe-meta.h"
-#include "transcribe-weights-util.h"
-#include "transcribe-log.h"
-
 #include "ggml.h"
 #include "gguf.h"
+#include "transcribe-log.h"
+#include "transcribe-meta.h"
+#include "transcribe-weights-util.h"
 
 #include <cstdio>
 #include <cstring>
@@ -25,123 +24,179 @@ namespace {
 
 constexpr const char * kFamilyTag = "canary_qwen";
 
-} // namespace
+}  // namespace
 
-transcribe_status read_canary_qwen_hparams(gguf_context *      gguf,
-                                           CanaryQwenHParams & hp)
-{
+transcribe_status read_canary_qwen_hparams(gguf_context * gguf, CanaryQwenHParams & hp) {
     if (gguf == nullptr) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
 
     // Encoder.
-    if (auto st = read_required_u32_kv(gguf, "stt.canary_qwen.encoder.n_layers",
-                                       kFamilyTag, hp.enc_n_layers); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.canary_qwen.encoder.d_model",
-                                       kFamilyTag, hp.enc_d_model); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.canary_qwen.encoder.n_heads",
-                                       kFamilyTag, hp.enc_n_heads); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.canary_qwen.encoder.d_ff",
-                                       kFamilyTag, hp.enc_d_ff); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.canary_qwen.encoder.conv_kernel",
-                                       kFamilyTag, hp.enc_conv_kernel); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.canary_qwen.encoder.subsampling_factor",
-                                       kFamilyTag, hp.enc_subsampling_factor); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.canary_qwen.encoder.subsampling_channels",
-                                       kFamilyTag, hp.enc_subsampling_chans); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.canary_qwen.encoder.pos_emb_max_len",
-                                       kFamilyTag, hp.enc_pos_emb_max_len); st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_u32_kv(gguf, "stt.canary_qwen.encoder.n_layers", kFamilyTag, hp.enc_n_layers);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.canary_qwen.encoder.d_model", kFamilyTag, hp.enc_d_model);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.canary_qwen.encoder.n_heads", kFamilyTag, hp.enc_n_heads);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.canary_qwen.encoder.d_ff", kFamilyTag, hp.enc_d_ff);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.canary_qwen.encoder.conv_kernel", kFamilyTag, hp.enc_conv_kernel);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.canary_qwen.encoder.subsampling_factor", kFamilyTag,
+                                       hp.enc_subsampling_factor);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.canary_qwen.encoder.subsampling_channels", kFamilyTag,
+                                       hp.enc_subsampling_chans);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st =
+            read_required_u32_kv(gguf, "stt.canary_qwen.encoder.pos_emb_max_len", kFamilyTag, hp.enc_pos_emb_max_len);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Perception (audio adapter -> LM input).
-    if (auto st = read_required_u32_kv(gguf, "stt.canary_qwen.perception.output_dim",
-                                       kFamilyTag, hp.perception_output_dim);
-        st != TRANSCRIBE_OK)
-    {
+    if (auto st =
+            read_required_u32_kv(gguf, "stt.canary_qwen.perception.output_dim", kFamilyTag, hp.perception_output_dim);
+        st != TRANSCRIBE_OK) {
         // Older converters may not have written output_dim; fall back to LM hidden.
         hp.perception_output_dim = 0;
     }
 
     // Audio locator id (single Qwen2 BPE special token id).
     {
-        int v = -1;
+        int        v = -1;
         const auto r = read_token_id_kv(gguf, "stt.canary_qwen.perception.audio_locator_id", v);
         if (r == KvResult::Ok) {
             hp.audio_locator_id = v;
         } else {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "%s: missing or invalid stt.canary_qwen.perception.audio_locator_id",
-                         kFamilyTag);
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: missing or invalid stt.canary_qwen.perception.audio_locator_id",
+                    kFamilyTag);
             return TRANSCRIBE_ERR_GGUF;
         }
     }
 
     // Decoder (Qwen3-1.7B).
-    if (auto st = read_required_u32_kv(gguf, "stt.canary_qwen.decoder.n_layers",
-                                       kFamilyTag, hp.dec_n_layers); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.canary_qwen.decoder.hidden_size",
-                                       kFamilyTag, hp.dec_hidden); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.canary_qwen.decoder.intermediate_size",
-                                       kFamilyTag, hp.dec_intermediate); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.canary_qwen.decoder.n_heads",
-                                       kFamilyTag, hp.dec_n_heads); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.canary_qwen.decoder.n_kv_heads",
-                                       kFamilyTag, hp.dec_n_kv_heads); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.canary_qwen.decoder.head_dim",
-                                       kFamilyTag, hp.dec_head_dim); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.canary_qwen.decoder.max_position_embeddings",
-                                       kFamilyTag, hp.dec_max_position); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.canary_qwen.decoder.vocab_size",
-                                       kFamilyTag, hp.dec_vocab_size); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf, "stt.canary_qwen.decoder.rms_norm_eps",
-                                       kFamilyTag, hp.dec_rms_norm_eps); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf, "stt.canary_qwen.decoder.rope_theta",
-                                       kFamilyTag, hp.dec_rope_theta); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_bool_kv(gguf, "stt.canary_qwen.decoder.tie_word_embeddings",
-                                        kFamilyTag, true, hp.dec_tie_word_embeddings);
-        st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_u32_kv(gguf, "stt.canary_qwen.decoder.n_layers", kFamilyTag, hp.dec_n_layers);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.canary_qwen.decoder.hidden_size", kFamilyTag, hp.dec_hidden);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st =
+            read_required_u32_kv(gguf, "stt.canary_qwen.decoder.intermediate_size", kFamilyTag, hp.dec_intermediate);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.canary_qwen.decoder.n_heads", kFamilyTag, hp.dec_n_heads);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.canary_qwen.decoder.n_kv_heads", kFamilyTag, hp.dec_n_kv_heads);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.canary_qwen.decoder.head_dim", kFamilyTag, hp.dec_head_dim);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.canary_qwen.decoder.max_position_embeddings", kFamilyTag,
+                                       hp.dec_max_position);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.canary_qwen.decoder.vocab_size", kFamilyTag, hp.dec_vocab_size);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.canary_qwen.decoder.rms_norm_eps", kFamilyTag, hp.dec_rms_norm_eps);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.canary_qwen.decoder.rope_theta", kFamilyTag, hp.dec_rope_theta);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_bool_kv(gguf, "stt.canary_qwen.decoder.tie_word_embeddings", kFamilyTag, true,
+                                        hp.dec_tie_word_embeddings);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     if (hp.perception_output_dim == 0) {
         hp.perception_output_dim = hp.dec_hidden;
     }
 
     // Frontend.
-    if (auto st = read_required_u32_kv(gguf, "stt.frontend.sample_rate",
-                                       kFamilyTag, hp.fe_sample_rate); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.frontend.num_mels",
-                                       kFamilyTag, hp.fe_num_mels); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.frontend.n_fft",
-                                       kFamilyTag, hp.fe_n_fft); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.frontend.win_length",
-                                       kFamilyTag, hp.fe_win_length); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.frontend.hop_length",
-                                       kFamilyTag, hp.fe_hop_length); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf, "stt.frontend.pre_emphasis",
-                                       kFamilyTag, hp.fe_pre_emphasis); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf, "stt.frontend.f_min",
-                                       kFamilyTag, hp.fe_f_min); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf, "stt.frontend.f_max",
-                                       kFamilyTag, hp.fe_f_max); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.frontend.pad_mode",
-                                          kFamilyTag, hp.fe_pad_mode); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.frontend.normalize",
-                                          kFamilyTag, hp.fe_normalize); st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.sample_rate", kFamilyTag, hp.fe_sample_rate);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.num_mels", kFamilyTag, hp.fe_num_mels);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.n_fft", kFamilyTag, hp.fe_n_fft); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.win_length", kFamilyTag, hp.fe_win_length);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.hop_length", kFamilyTag, hp.fe_hop_length);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.frontend.pre_emphasis", kFamilyTag, hp.fe_pre_emphasis);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.frontend.f_min", kFamilyTag, hp.fe_f_min); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.frontend.f_max", kFamilyTag, hp.fe_f_max); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_string_kv(gguf, "stt.frontend.pad_mode", kFamilyTag, hp.fe_pad_mode);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_string_kv(gguf, "stt.frontend.normalize", kFamilyTag, hp.fe_normalize);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Cross-field validation.
     if (hp.dec_n_heads % hp.dec_n_kv_heads != 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: dec.n_heads (%d) must be divisible by dec.n_kv_heads (%d)",
-                     kFamilyTag, hp.dec_n_heads, hp.dec_n_kv_heads);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: dec.n_heads (%d) must be divisible by dec.n_kv_heads (%d)", kFamilyTag,
+                hp.dec_n_heads, hp.dec_n_kv_heads);
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.dec_n_heads * hp.dec_head_dim != hp.dec_hidden) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: dec.n_heads(%d) * dec.head_dim(%d) != dec.hidden(%d)",
-                     kFamilyTag, hp.dec_n_heads, hp.dec_head_dim, hp.dec_hidden);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: dec.n_heads(%d) * dec.head_dim(%d) != dec.hidden(%d)", kFamilyTag,
+                hp.dec_n_heads, hp.dec_head_dim, hp.dec_hidden);
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.perception_output_dim != hp.dec_hidden) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "%s: perception.output_dim(%d) must equal dec.hidden(%d) "
-                     "for direct concat into LM embedding stream",
-                     kFamilyTag, hp.perception_output_dim, hp.dec_hidden);
+                "%s: perception.output_dim(%d) must equal dec.hidden(%d) "
+                "for direct concat into LM embedding stream",
+                kFamilyTag, hp.perception_output_dim, hp.dec_hidden);
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.audio_locator_id < 0) {
@@ -149,9 +204,8 @@ transcribe_status read_canary_qwen_hparams(gguf_context *      gguf,
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.enc_subsampling_factor != 8 || hp.fe_num_mels != 128) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "%s: only subsampling_factor=8 num_mels=128 supported (got %d, %d)",
-                     kFamilyTag, hp.enc_subsampling_factor, hp.fe_num_mels);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: only subsampling_factor=8 num_mels=128 supported (got %d, %d)",
+                kFamilyTag, hp.enc_subsampling_factor, hp.fe_num_mels);
         return TRANSCRIBE_ERR_GGUF;
     }
 
@@ -166,41 +220,38 @@ namespace {
 
 using transcribe::weights::lname;
 
-#define GET_F32(slot, name, ...) \
-    do { \
-        ggml_tensor * _t = transcribe::weights::find_tensor( \
-            ctx_meta, (name), \
-            {GGML_TYPE_F32}, {__VA_ARGS__}, kFamilyTag); \
-        if (_t == nullptr) return TRANSCRIBE_ERR_GGUF; \
-        (slot) = _t; \
+#define GET_F32(slot, name, ...)                                                                                \
+    do {                                                                                                        \
+        ggml_tensor * _t =                                                                                      \
+            transcribe::weights::find_tensor(ctx_meta, (name), { GGML_TYPE_F32 }, { __VA_ARGS__ }, kFamilyTag); \
+        if (_t == nullptr)                                                                                      \
+            return TRANSCRIBE_ERR_GGUF;                                                                         \
+        (slot) = _t;                                                                                            \
     } while (0)
 
-#define GET_CONV(slot, name, ...) \
-    do { \
-        ggml_tensor * _t = transcribe::weights::find_tensor( \
-            ctx_meta, (name), \
-            {TRANSCRIBE_QUANT_CONV_TYPES}, \
-            {__VA_ARGS__}, kFamilyTag); \
-        if (_t == nullptr) return TRANSCRIBE_ERR_GGUF; \
-        (slot) = _t; \
+#define GET_CONV(slot, name, ...)                                                                              \
+    do {                                                                                                       \
+        ggml_tensor * _t = transcribe::weights::find_tensor(ctx_meta, (name), { TRANSCRIBE_QUANT_CONV_TYPES }, \
+                                                            { __VA_ARGS__ }, kFamilyTag);                      \
+        if (_t == nullptr)                                                                                     \
+            return TRANSCRIBE_ERR_GGUF;                                                                        \
+        (slot) = _t;                                                                                           \
     } while (0)
 
-#define GET_LIN(slot, name, ...) \
-    do { \
-        ggml_tensor * _t = transcribe::weights::find_tensor( \
-            ctx_meta, (name), \
-            {TRANSCRIBE_QUANT_LINEAR_TYPES}, \
-            {__VA_ARGS__}, kFamilyTag); \
-        if (_t == nullptr) return TRANSCRIBE_ERR_GGUF; \
-        (slot) = _t; \
+#define GET_LIN(slot, name, ...)                                                                                 \
+    do {                                                                                                         \
+        ggml_tensor * _t = transcribe::weights::find_tensor(ctx_meta, (name), { TRANSCRIBE_QUANT_LINEAR_TYPES }, \
+                                                            { __VA_ARGS__ }, kFamilyTag);                        \
+        if (_t == nullptr)                                                                                       \
+            return TRANSCRIBE_ERR_GGUF;                                                                          \
+        (slot) = _t;                                                                                             \
     } while (0)
 
-} // namespace
+}  // namespace
 
-transcribe_status build_canary_qwen_weights(ggml_context *           ctx_meta,
+transcribe_status build_canary_qwen_weights(ggml_context *            ctx_meta,
                                             const CanaryQwenHParams & hp,
-                                            CanaryQwenWeights &      weights)
-{
+                                            CanaryQwenWeights &       weights) {
     if (ctx_meta == nullptr) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
@@ -223,17 +274,17 @@ transcribe_status build_canary_qwen_weights(ggml_context *           ctx_meta,
 
     // ---------- pre_encode ----------
     GET_CONV(weights.pre_encode.conv0_w, "enc.pre_encode.conv.0.weight", 3, 3, 1, channels);
-    GET_F32 (weights.pre_encode.conv0_b, "enc.pre_encode.conv.0.bias", channels);
+    GET_F32(weights.pre_encode.conv0_b, "enc.pre_encode.conv.0.bias", channels);
     GET_CONV(weights.pre_encode.conv2_w, "enc.pre_encode.conv.2.weight", 3, 3, 1, channels);
-    GET_F32 (weights.pre_encode.conv2_b, "enc.pre_encode.conv.2.bias", channels);
+    GET_F32(weights.pre_encode.conv2_b, "enc.pre_encode.conv.2.bias", channels);
     GET_CONV(weights.pre_encode.conv3_w, "enc.pre_encode.conv.3.weight", 1, 1, channels, channels);
-    GET_F32 (weights.pre_encode.conv3_b, "enc.pre_encode.conv.3.bias", channels);
+    GET_F32(weights.pre_encode.conv3_b, "enc.pre_encode.conv.3.bias", channels);
     GET_CONV(weights.pre_encode.conv5_w, "enc.pre_encode.conv.5.weight", 3, 3, 1, channels);
-    GET_F32 (weights.pre_encode.conv5_b, "enc.pre_encode.conv.5.bias", channels);
+    GET_F32(weights.pre_encode.conv5_b, "enc.pre_encode.conv.5.bias", channels);
     GET_CONV(weights.pre_encode.conv6_w, "enc.pre_encode.conv.6.weight", 1, 1, channels, channels);
-    GET_F32 (weights.pre_encode.conv6_b, "enc.pre_encode.conv.6.bias", channels);
-    GET_LIN (weights.pre_encode.out_w,   "enc.pre_encode.out.weight", pre_encode_in, d_enc);
-    GET_F32 (weights.pre_encode.out_b,   "enc.pre_encode.out.bias", d_enc);
+    GET_F32(weights.pre_encode.conv6_b, "enc.pre_encode.conv.6.bias", channels);
+    GET_LIN(weights.pre_encode.out_w, "enc.pre_encode.out.weight", pre_encode_in, d_enc);
+    GET_F32(weights.pre_encode.out_b, "enc.pre_encode.out.bias", d_enc);
 
     // ---------- encoder blocks (every linear has a bias) ----------
     weights.blocks.assign(hp.enc_n_layers, EncBlockSlots{});
@@ -241,64 +292,64 @@ transcribe_status build_canary_qwen_weights(ggml_context *           ctx_meta,
         auto & b = weights.blocks[i];
 
         GET_F32(b.norm_ff1_w, lname("enc.blocks.%d.norm_ff1.weight", i), d_enc);
-        GET_F32(b.norm_ff1_b, lname("enc.blocks.%d.norm_ff1.bias",   i), d_enc);
+        GET_F32(b.norm_ff1_b, lname("enc.blocks.%d.norm_ff1.bias", i), d_enc);
         GET_LIN(b.ff1_lin1_w, lname("enc.blocks.%d.ff1.linear1.weight", i), d_enc, d_ff_e);
-        GET_F32(b.ff1_lin1_b, lname("enc.blocks.%d.ff1.linear1.bias",   i), d_ff_e);
+        GET_F32(b.ff1_lin1_b, lname("enc.blocks.%d.ff1.linear1.bias", i), d_ff_e);
         GET_LIN(b.ff1_lin2_w, lname("enc.blocks.%d.ff1.linear2.weight", i), d_ff_e, d_enc);
-        GET_F32(b.ff1_lin2_b, lname("enc.blocks.%d.ff1.linear2.bias",   i), d_enc);
+        GET_F32(b.ff1_lin2_b, lname("enc.blocks.%d.ff1.linear2.bias", i), d_enc);
 
         GET_F32(b.norm_attn_w, lname("enc.blocks.%d.norm_attn.weight", i), d_enc);
-        GET_F32(b.norm_attn_b, lname("enc.blocks.%d.norm_attn.bias",   i), d_enc);
-        GET_LIN(b.attn_q_w,    lname("enc.blocks.%d.attn.linear_q.weight",   i), d_enc, d_enc);
-        GET_F32(b.attn_q_b,    lname("enc.blocks.%d.attn.linear_q.bias",     i), d_enc);
-        GET_LIN(b.attn_k_w,    lname("enc.blocks.%d.attn.linear_k.weight",   i), d_enc, d_enc);
-        GET_F32(b.attn_k_b,    lname("enc.blocks.%d.attn.linear_k.bias",     i), d_enc);
-        GET_LIN(b.attn_v_w,    lname("enc.blocks.%d.attn.linear_v.weight",   i), d_enc, d_enc);
-        GET_F32(b.attn_v_b,    lname("enc.blocks.%d.attn.linear_v.bias",     i), d_enc);
-        GET_LIN(b.attn_out_w,  lname("enc.blocks.%d.attn.linear_out.weight", i), d_enc, d_enc);
-        GET_F32(b.attn_out_b,  lname("enc.blocks.%d.attn.linear_out.bias",   i), d_enc);
-        GET_LIN(b.attn_pos_w,  lname("enc.blocks.%d.attn.linear_pos.weight", i), d_enc, d_enc);
-        GET_F32(b.attn_pos_u,  lname("enc.blocks.%d.attn.pos_bias_u",        i), head_dim, n_heads);
-        GET_F32(b.attn_pos_v,  lname("enc.blocks.%d.attn.pos_bias_v",        i), head_dim, n_heads);
-
-        GET_F32 (b.norm_conv_w, lname("enc.blocks.%d.norm_conv.weight", i), d_enc);
-        GET_F32 (b.norm_conv_b, lname("enc.blocks.%d.norm_conv.bias",   i), d_enc);
-        GET_CONV(b.conv_pw1_w,  lname("enc.blocks.%d.conv.pointwise1.weight", i), 1, d_enc, 2 * d_enc);
-        GET_F32 (b.conv_pw1_b,  lname("enc.blocks.%d.conv.pointwise1.bias",   i), 2 * d_enc);
-        GET_CONV(b.conv_dw_w,   lname("enc.blocks.%d.conv.depthwise.weight",  i), k, 1,    d_enc);
-        GET_F32 (b.conv_dw_b,   lname("enc.blocks.%d.conv.depthwise.bias",    i), d_enc);
-        GET_CONV(b.conv_pw2_w,  lname("enc.blocks.%d.conv.pointwise2.weight", i), 1, d_enc, d_enc);
-        GET_F32 (b.conv_pw2_b,  lname("enc.blocks.%d.conv.pointwise2.bias",   i), d_enc);
-        GET_F32 (b.conv_bn_w,   lname("enc.blocks.%d.conv.bn.weight",       i), d_enc);
-        GET_F32 (b.conv_bn_b,   lname("enc.blocks.%d.conv.bn.bias",         i), d_enc);
-        GET_F32 (b.conv_bn_rm,  lname("enc.blocks.%d.conv.bn.running_mean", i), d_enc);
-        GET_F32 (b.conv_bn_rv,  lname("enc.blocks.%d.conv.bn.running_var",  i), d_enc);
+        GET_F32(b.norm_attn_b, lname("enc.blocks.%d.norm_attn.bias", i), d_enc);
+        GET_LIN(b.attn_q_w, lname("enc.blocks.%d.attn.linear_q.weight", i), d_enc, d_enc);
+        GET_F32(b.attn_q_b, lname("enc.blocks.%d.attn.linear_q.bias", i), d_enc);
+        GET_LIN(b.attn_k_w, lname("enc.blocks.%d.attn.linear_k.weight", i), d_enc, d_enc);
+        GET_F32(b.attn_k_b, lname("enc.blocks.%d.attn.linear_k.bias", i), d_enc);
+        GET_LIN(b.attn_v_w, lname("enc.blocks.%d.attn.linear_v.weight", i), d_enc, d_enc);
+        GET_F32(b.attn_v_b, lname("enc.blocks.%d.attn.linear_v.bias", i), d_enc);
+        GET_LIN(b.attn_out_w, lname("enc.blocks.%d.attn.linear_out.weight", i), d_enc, d_enc);
+        GET_F32(b.attn_out_b, lname("enc.blocks.%d.attn.linear_out.bias", i), d_enc);
+        GET_LIN(b.attn_pos_w, lname("enc.blocks.%d.attn.linear_pos.weight", i), d_enc, d_enc);
+        GET_F32(b.attn_pos_u, lname("enc.blocks.%d.attn.pos_bias_u", i), head_dim, n_heads);
+        GET_F32(b.attn_pos_v, lname("enc.blocks.%d.attn.pos_bias_v", i), head_dim, n_heads);
+
+        GET_F32(b.norm_conv_w, lname("enc.blocks.%d.norm_conv.weight", i), d_enc);
+        GET_F32(b.norm_conv_b, lname("enc.blocks.%d.norm_conv.bias", i), d_enc);
+        GET_CONV(b.conv_pw1_w, lname("enc.blocks.%d.conv.pointwise1.weight", i), 1, d_enc, 2 * d_enc);
+        GET_F32(b.conv_pw1_b, lname("enc.blocks.%d.conv.pointwise1.bias", i), 2 * d_enc);
+        GET_CONV(b.conv_dw_w, lname("enc.blocks.%d.conv.depthwise.weight", i), k, 1, d_enc);
+        GET_F32(b.conv_dw_b, lname("enc.blocks.%d.conv.depthwise.bias", i), d_enc);
+        GET_CONV(b.conv_pw2_w, lname("enc.blocks.%d.conv.pointwise2.weight", i), 1, d_enc, d_enc);
+        GET_F32(b.conv_pw2_b, lname("enc.blocks.%d.conv.pointwise2.bias", i), d_enc);
+        GET_F32(b.conv_bn_w, lname("enc.blocks.%d.conv.bn.weight", i), d_enc);
+        GET_F32(b.conv_bn_b, lname("enc.blocks.%d.conv.bn.bias", i), d_enc);
+        GET_F32(b.conv_bn_rm, lname("enc.blocks.%d.conv.bn.running_mean", i), d_enc);
+        GET_F32(b.conv_bn_rv, lname("enc.blocks.%d.conv.bn.running_var", i), d_enc);
 
         GET_F32(b.norm_ff2_w, lname("enc.blocks.%d.norm_ff2.weight", i), d_enc);
-        GET_F32(b.norm_ff2_b, lname("enc.blocks.%d.norm_ff2.bias",   i), d_enc);
+        GET_F32(b.norm_ff2_b, lname("enc.blocks.%d.norm_ff2.bias", i), d_enc);
         GET_LIN(b.ff2_lin1_w, lname("enc.blocks.%d.ff2.linear1.weight", i), d_enc, d_ff_e);
-        GET_F32(b.ff2_lin1_b, lname("enc.blocks.%d.ff2.linear1.bias",   i), d_ff_e);
+        GET_F32(b.ff2_lin1_b, lname("enc.blocks.%d.ff2.linear1.bias", i), d_ff_e);
         GET_LIN(b.ff2_lin2_w, lname("enc.blocks.%d.ff2.linear2.weight", i), d_ff_e, d_enc);
-        GET_F32(b.ff2_lin2_b, lname("enc.blocks.%d.ff2.linear2.bias",   i), d_enc);
+        GET_F32(b.ff2_lin2_b, lname("enc.blocks.%d.ff2.linear2.bias", i), d_enc);
 
         GET_F32(b.norm_out_w, lname("enc.blocks.%d.norm_out.weight", i), d_enc);
-        GET_F32(b.norm_out_b, lname("enc.blocks.%d.norm_out.bias",   i), d_enc);
+        GET_F32(b.norm_out_b, lname("enc.blocks.%d.norm_out.bias", i), d_enc);
     }
 
     // ---------- perception projection ----------
     GET_LIN(weights.perception_proj.weight, "enc.proj.weight", d_enc, out_dim);
-    GET_F32(weights.perception_proj.bias,   "enc.proj.bias", out_dim);
+    GET_F32(weights.perception_proj.bias, "enc.proj.bias", out_dim);
 
     // ---------- decoder ----------
     GET_LIN(weights.dec_embed.token_w, "dec.token_embd.weight", hidden, vocab);
-    GET_F32(weights.dec_final.norm_w,  "dec.output_norm.weight", hidden);
+    GET_F32(weights.dec_final.norm_w, "dec.output_norm.weight", hidden);
 
     weights.dec_blocks.assign(hp.dec_n_layers, DecBlockSlots{});
     for (int i = 0; i < hp.dec_n_layers; ++i) {
         auto & b = weights.dec_blocks[i];
 
         GET_F32(b.norm_attn_w, lname("dec.blocks.%d.norm_attn.weight", i), hidden);
-        GET_F32(b.norm_ffn_w,  lname("dec.blocks.%d.norm_ffn.weight",  i), hidden);
+        GET_F32(b.norm_ffn_w, lname("dec.blocks.%d.norm_ffn.weight", i), hidden);
 
         GET_LIN(b.attn_q_w, lname("dec.blocks.%d.attn.q.weight", i), hidden, hidden);
         GET_LIN(b.attn_k_w, lname("dec.blocks.%d.attn.k.weight", i), hidden, kv_dim);
@@ -309,11 +360,11 @@ transcribe_status build_canary_qwen_weights(ggml_context *           ctx_meta,
         GET_F32(b.attn_k_norm, lname("dec.blocks.%d.attn.k_norm.weight", i), hp.dec_head_dim);
 
         GET_LIN(b.ffn_gate_w, lname("dec.blocks.%d.ffn.gate.weight", i), hidden, inter);
-        GET_LIN(b.ffn_up_w,   lname("dec.blocks.%d.ffn.up.weight",   i), hidden, inter);
+        GET_LIN(b.ffn_up_w, lname("dec.blocks.%d.ffn.up.weight", i), hidden, inter);
         GET_LIN(b.ffn_down_w, lname("dec.blocks.%d.ffn.down.weight", i), inter, hidden);
     }
 
     return TRANSCRIBE_OK;
 }
 
-} // namespace transcribe::canary_qwen
+}  // namespace transcribe::canary_qwen
diff --git a/src/arch/canary_qwen/weights.h b/src/arch/canary_qwen/weights.h
index e76ba540..bebe264a 100644
--- a/src/arch/canary_qwen/weights.h
+++ b/src/arch/canary_qwen/weights.h
@@ -43,50 +43,50 @@ namespace transcribe::canary_qwen {
 
 struct CanaryQwenHParams {
     // Encoder (FastConformer; matches canary-1b-flash).
-    int32_t enc_n_layers           = 0;   // 32
-    int32_t enc_d_model            = 0;   // 1024
-    int32_t enc_n_heads            = 0;   // 8 (-> head_dim = 128)
-    int32_t enc_d_ff               = 0;   // 4096
-    int32_t enc_conv_kernel        = 0;   // 9
-    int32_t enc_subsampling_factor = 0;   // 8
-    int32_t enc_subsampling_chans  = 0;   // 256
-    int32_t enc_pos_emb_max_len    = 0;   // 5000
+    int32_t enc_n_layers           = 0;  // 32
+    int32_t enc_d_model            = 0;  // 1024
+    int32_t enc_n_heads            = 0;  // 8 (-> head_dim = 128)
+    int32_t enc_d_ff               = 0;  // 4096
+    int32_t enc_conv_kernel        = 0;  // 9
+    int32_t enc_subsampling_factor = 0;  // 8
+    int32_t enc_subsampling_chans  = 0;  // 256
+    int32_t enc_pos_emb_max_len    = 0;  // 5000
 
     // Perception projection.
-    int32_t perception_output_dim  = 0;   // 2048 (must equal dec_hidden)
+    int32_t perception_output_dim = 0;  // 2048 (must equal dec_hidden)
 
     // Audio locator placeholder id (single Qwen2 BPE special token).
-    int32_t audio_locator_id       = -1;  // 151669 = "<|audioplaceholder|>"
+    int32_t audio_locator_id = -1;  // 151669 = "<|audioplaceholder|>"
 
     // Decoder (Qwen3-1.7B).
-    int32_t dec_n_layers           = 0;   // 28
-    int32_t dec_hidden             = 0;   // 2048
-    int32_t dec_intermediate       = 0;   // 6144
-    int32_t dec_n_heads            = 0;   // 16
-    int32_t dec_n_kv_heads         = 0;   // 8
-    int32_t dec_head_dim           = 0;   // 128
-    int32_t dec_max_position       = 0;   // 40960
-    int32_t dec_vocab_size         = 0;   // 151936
-    float   dec_rms_norm_eps       = 0.0f; // 1e-6
-    float   dec_rope_theta         = 0.0f; // 1e6
+    int32_t dec_n_layers            = 0;     // 28
+    int32_t dec_hidden              = 0;     // 2048
+    int32_t dec_intermediate        = 0;     // 6144
+    int32_t dec_n_heads             = 0;     // 16
+    int32_t dec_n_kv_heads          = 0;     // 8
+    int32_t dec_head_dim            = 0;     // 128
+    int32_t dec_max_position        = 0;     // 40960
+    int32_t dec_vocab_size          = 0;     // 151936
+    float   dec_rms_norm_eps        = 0.0f;  // 1e-6
+    float   dec_rope_theta          = 0.0f;  // 1e6
     bool    dec_tie_word_embeddings = true;
 
     // Tokenizer-derived.
-    int32_t vocab_size             = 0;   // matches dec_vocab_size
-    int32_t bos_token_id           = -1;
-    int32_t eos_token_id           = -1;  // 151645 = "<|im_end|>"
+    int32_t vocab_size   = 0;   // matches dec_vocab_size
+    int32_t bos_token_id = -1;
+    int32_t eos_token_id = -1;  // 151645 = "<|im_end|>"
 
     // Frontend (NeMo AudioToMelSpectrogramPreprocessor cfg).
-    int32_t fe_sample_rate         = 0;   // 16000
-    int32_t fe_num_mels            = 0;   // 128
-    int32_t fe_n_fft               = 0;   // 512
-    int32_t fe_win_length          = 0;   // 400
-    int32_t fe_hop_length          = 0;   // 160
-    float   fe_pre_emphasis        = 0.0f; // 0.97
-    float   fe_f_min               = 0.0f; // 0.0
-    float   fe_f_max               = 0.0f; // 8000.0
-    std::string fe_pad_mode;              // "reflect"
-    std::string fe_normalize;             // "per_feature"
+    int32_t     fe_sample_rate  = 0;     // 16000
+    int32_t     fe_num_mels     = 0;     // 128
+    int32_t     fe_n_fft        = 0;     // 512
+    int32_t     fe_win_length   = 0;     // 400
+    int32_t     fe_hop_length   = 0;     // 160
+    float       fe_pre_emphasis = 0.0f;  // 0.97
+    float       fe_f_min        = 0.0f;  // 0.0
+    float       fe_f_max        = 0.0f;  // 8000.0
+    std::string fe_pad_mode;             // "reflect"
+    std::string fe_normalize;            // "per_feature"
 };
 
 // ---------------------------------------------------------------------------
@@ -102,59 +102,83 @@ struct PreEncodeSlots {
     //   conv2d(1->256, 3x3 stride 2)   -> ReLU
     //   conv2d(256->256, 1x1)
     //   linear(reduced_feat_in -> d_model=1024) + bias
-    ggml_tensor * conv0_w = nullptr; ggml_tensor * conv0_b = nullptr;
-    ggml_tensor * conv2_w = nullptr; ggml_tensor * conv2_b = nullptr;
-    ggml_tensor * conv3_w = nullptr; ggml_tensor * conv3_b = nullptr;
-    ggml_tensor * conv5_w = nullptr; ggml_tensor * conv5_b = nullptr;
-    ggml_tensor * conv6_w = nullptr; ggml_tensor * conv6_b = nullptr;
-    ggml_tensor * out_w   = nullptr; ggml_tensor * out_b   = nullptr;
+    ggml_tensor * conv0_w = nullptr;
+    ggml_tensor * conv0_b = nullptr;
+    ggml_tensor * conv2_w = nullptr;
+    ggml_tensor * conv2_b = nullptr;
+    ggml_tensor * conv3_w = nullptr;
+    ggml_tensor * conv3_b = nullptr;
+    ggml_tensor * conv5_w = nullptr;
+    ggml_tensor * conv5_b = nullptr;
+    ggml_tensor * conv6_w = nullptr;
+    ggml_tensor * conv6_b = nullptr;
+    ggml_tensor * out_w   = nullptr;
+    ggml_tensor * out_b   = nullptr;
 };
 
 struct EncBlockSlots {
     // Macaron FF1
-    ggml_tensor * norm_ff1_w = nullptr; ggml_tensor * norm_ff1_b = nullptr;
-    ggml_tensor * ff1_lin1_w = nullptr; ggml_tensor * ff1_lin1_b = nullptr;
-    ggml_tensor * ff1_lin2_w = nullptr; ggml_tensor * ff1_lin2_b = nullptr;
+    ggml_tensor * norm_ff1_w = nullptr;
+    ggml_tensor * norm_ff1_b = nullptr;
+    ggml_tensor * ff1_lin1_w = nullptr;
+    ggml_tensor * ff1_lin1_b = nullptr;
+    ggml_tensor * ff1_lin2_w = nullptr;
+    ggml_tensor * ff1_lin2_b = nullptr;
 
     // Self-attention with relative position
-    ggml_tensor * norm_attn_w = nullptr; ggml_tensor * norm_attn_b = nullptr;
-    ggml_tensor * attn_q_w    = nullptr; ggml_tensor * attn_q_b    = nullptr;
-    ggml_tensor * attn_k_w    = nullptr; ggml_tensor * attn_k_b    = nullptr;
-    ggml_tensor * attn_v_w    = nullptr; ggml_tensor * attn_v_b    = nullptr;
-    ggml_tensor * attn_out_w  = nullptr; ggml_tensor * attn_out_b  = nullptr;
-    ggml_tensor * attn_pos_w  = nullptr;   // linear_pos has no bias
-    ggml_tensor * attn_pos_u  = nullptr;   // (n_heads, head_dim)
-    ggml_tensor * attn_pos_v  = nullptr;   // (n_heads, head_dim)
+    ggml_tensor * norm_attn_w = nullptr;
+    ggml_tensor * norm_attn_b = nullptr;
+    ggml_tensor * attn_q_w    = nullptr;
+    ggml_tensor * attn_q_b    = nullptr;
+    ggml_tensor * attn_k_w    = nullptr;
+    ggml_tensor * attn_k_b    = nullptr;
+    ggml_tensor * attn_v_w    = nullptr;
+    ggml_tensor * attn_v_b    = nullptr;
+    ggml_tensor * attn_out_w  = nullptr;
+    ggml_tensor * attn_out_b  = nullptr;
+    ggml_tensor * attn_pos_w  = nullptr;  // linear_pos has no bias
+    ggml_tensor * attn_pos_u  = nullptr;  // (n_heads, head_dim)
+    ggml_tensor * attn_pos_v  = nullptr;  // (n_heads, head_dim)
 
     // Convolution module: pw1 -> GLU -> dw -> BN -> SiLU -> pw2
-    ggml_tensor * norm_conv_w = nullptr; ggml_tensor * norm_conv_b = nullptr;
-    ggml_tensor * conv_pw1_w  = nullptr; ggml_tensor * conv_pw1_b  = nullptr;
-    ggml_tensor * conv_dw_w   = nullptr; ggml_tensor * conv_dw_b   = nullptr;
-    ggml_tensor * conv_pw2_w  = nullptr; ggml_tensor * conv_pw2_b  = nullptr;
+    ggml_tensor * norm_conv_w = nullptr;
+    ggml_tensor * norm_conv_b = nullptr;
+    ggml_tensor * conv_pw1_w  = nullptr;
+    ggml_tensor * conv_pw1_b  = nullptr;
+    ggml_tensor * conv_dw_w   = nullptr;
+    ggml_tensor * conv_dw_b   = nullptr;
+    ggml_tensor * conv_pw2_w  = nullptr;
+    ggml_tensor * conv_pw2_b  = nullptr;
 
     // BatchNorm (raw weights from GGUF).
-    ggml_tensor * conv_bn_w   = nullptr; ggml_tensor * conv_bn_b   = nullptr;
-    ggml_tensor * conv_bn_rm  = nullptr; ggml_tensor * conv_bn_rv  = nullptr;
+    ggml_tensor * conv_bn_w  = nullptr;
+    ggml_tensor * conv_bn_b  = nullptr;
+    ggml_tensor * conv_bn_rm = nullptr;
+    ggml_tensor * conv_bn_rv = nullptr;
 
     // BN fused at load time into (scale, bias). Owned by m.bn_fused_ctx.
     ggml_tensor * conv_bn_fused_scale = nullptr;
     ggml_tensor * conv_bn_fused_bias  = nullptr;
 
     // Macaron FF2
-    ggml_tensor * norm_ff2_w = nullptr; ggml_tensor * norm_ff2_b = nullptr;
-    ggml_tensor * ff2_lin1_w = nullptr; ggml_tensor * ff2_lin1_b = nullptr;
-    ggml_tensor * ff2_lin2_w = nullptr; ggml_tensor * ff2_lin2_b = nullptr;
+    ggml_tensor * norm_ff2_w = nullptr;
+    ggml_tensor * norm_ff2_b = nullptr;
+    ggml_tensor * ff2_lin1_w = nullptr;
+    ggml_tensor * ff2_lin1_b = nullptr;
+    ggml_tensor * ff2_lin2_w = nullptr;
+    ggml_tensor * ff2_lin2_b = nullptr;
 
     // Final per-block LayerNorm
-    ggml_tensor * norm_out_w = nullptr; ggml_tensor * norm_out_b = nullptr;
+    ggml_tensor * norm_out_w = nullptr;
+    ggml_tensor * norm_out_b = nullptr;
 };
 
 struct PerceptionProjSlots {
-    ggml_tensor * weight = nullptr;   // (in=1024, out=2048) row-major as
-                                      // stored by ggml: nb0=stride along
-                                      // in-dim. ggml_mul_mat(W, x) where
-                                      // x has shape (in, T) yields (out, T).
-    ggml_tensor * bias   = nullptr;   // (2048,)
+    ggml_tensor * weight = nullptr;  // (in=1024, out=2048) row-major as
+                                     // stored by ggml: nb0=stride along
+                                     // in-dim. ggml_mul_mat(W, x) where
+                                     // x has shape (in, T) yields (out, T).
+    ggml_tensor * bias   = nullptr;  // (2048,)
 };
 
 struct DecEmbedSlots {
@@ -169,33 +193,33 @@ struct DecBlockSlots {
     ggml_tensor * norm_ffn_w  = nullptr;
 
     // Self-attention (no biases)
-    ggml_tensor * attn_q_w    = nullptr;
-    ggml_tensor * attn_k_w    = nullptr;
-    ggml_tensor * attn_v_w    = nullptr;
-    ggml_tensor * attn_o_w    = nullptr;
+    ggml_tensor * attn_q_w = nullptr;
+    ggml_tensor * attn_k_w = nullptr;
+    ggml_tensor * attn_v_w = nullptr;
+    ggml_tensor * attn_o_w = nullptr;
 
     // Per-head Q/K RMSNorm (acts on head_dim)
-    ggml_tensor * attn_q_norm = nullptr;   // (head_dim,)
-    ggml_tensor * attn_k_norm = nullptr;   // (head_dim,)
+    ggml_tensor * attn_q_norm = nullptr;  // (head_dim,)
+    ggml_tensor * attn_k_norm = nullptr;  // (head_dim,)
 
     // SwiGLU MLP — packed gate+up at load time
-    ggml_tensor * ffn_gate_w     = nullptr;
-    ggml_tensor * ffn_up_w       = nullptr;
-    ggml_tensor * ffn_gate_up_w  = nullptr;   // packed [hidden, 2*intermediate]
-    ggml_tensor * ffn_down_w     = nullptr;
+    ggml_tensor * ffn_gate_w    = nullptr;
+    ggml_tensor * ffn_up_w      = nullptr;
+    ggml_tensor * ffn_gate_up_w = nullptr;  // packed [hidden, 2*intermediate]
+    ggml_tensor * ffn_down_w    = nullptr;
 };
 
 struct DecFinalSlots {
-    ggml_tensor * norm_w = nullptr;          // dec.output_norm.weight
+    ggml_tensor * norm_w = nullptr;  // dec.output_norm.weight
 };
 
 struct CanaryQwenWeights {
     PreEncodeSlots             pre_encode;
-    std::vector<EncBlockSlots> blocks;          // size = enc_n_layers
+    std::vector<EncBlockSlots> blocks;  // size = enc_n_layers
     PerceptionProjSlots        perception_proj;
 
     DecEmbedSlots              dec_embed;
-    std::vector<DecBlockSlots> dec_blocks;      // size = dec_n_layers
+    std::vector<DecBlockSlots> dec_blocks;  // size = dec_n_layers
     DecFinalSlots              dec_final;
 };
 
@@ -203,13 +227,8 @@ struct CanaryQwenWeights {
 // Loader entry points
 // ---------------------------------------------------------------------------
 
-transcribe_status read_canary_qwen_hparams(
-    gguf_context * gguf_ctx,
-    CanaryQwenHParams & out);
+transcribe_status read_canary_qwen_hparams(gguf_context * gguf_ctx, CanaryQwenHParams & out);
 
-transcribe_status build_canary_qwen_weights(
-    ggml_context * ctx,
-    const CanaryQwenHParams & hp,
-    CanaryQwenWeights & out);
+transcribe_status build_canary_qwen_weights(ggml_context * ctx, const CanaryQwenHParams & hp, CanaryQwenWeights & out);
 
-} // namespace transcribe::canary_qwen
+}  // namespace transcribe::canary_qwen
diff --git a/src/arch/cohere/capabilities.cpp b/src/arch/cohere/capabilities.cpp
index 8a8bb88e..af8ed020 100644
--- a/src/arch/cohere/capabilities.cpp
+++ b/src/arch/cohere/capabilities.cpp
@@ -17,4 +17,4 @@ void apply_family_invariants(transcribe_model & model) {
     transcribe::set_feature(&model, TRANSCRIBE_FEATURE_CANCELLATION, true);
 }
 
-} // namespace transcribe::cohere
+}  // namespace transcribe::cohere
diff --git a/src/arch/cohere/cohere.h b/src/arch/cohere/cohere.h
index 79b64f55..3b369405 100644
--- a/src/arch/cohere/cohere.h
+++ b/src/arch/cohere/cohere.h
@@ -6,16 +6,15 @@
 
 #pragma once
 
+#include "ggml-backend.h"
+#include "ggml.h"
 #include "transcribe-backend.h"
-#include "transcribe-session.h"
 #include "transcribe-mel.h"
 #include "transcribe-model.h"
+#include "transcribe-session.h"
 #include "transcribe-tokenizer.h"
 #include "weights.h"
 
-#include "ggml.h"
-#include "ggml-backend.h"
-
 #include <cstdint>
 #include <optional>
 #include <string>
@@ -86,13 +85,13 @@ struct CohereKvCache {
             ggml_free(ctx);
             ctx = nullptr;
         }
-        self_k = nullptr;
-        self_v = nullptr;
-        cross_k = nullptr;
-        cross_v = nullptr;
-        n = 0;
-        head = 0;
-        n_batch = 1;
+        self_k          = nullptr;
+        self_v          = nullptr;
+        cross_k         = nullptr;
+        cross_v         = nullptr;
+        n               = 0;
+        head            = 0;
+        n_batch         = 1;
         cross_populated = false;
     }
 };
@@ -125,10 +124,10 @@ bool kv_cache_init_batched(CohereKvCache & cache,
                            ggml_type       kv_type);
 
 struct CohereModel final : public transcribe_model {
-    Tokenizer       tok;
-    CohereHParams   hparams;
-    CohereWeights   weights;
-    ggml_context *  ctx_meta = nullptr;
+    Tokenizer      tok;
+    CohereHParams  hparams;
+    CohereWeights  weights;
+    ggml_context * ctx_meta = nullptr;
 
     // Runtime backend plan — see transcribe-backend.h. scheduler_list
     // holds the backend handles plus a classified primary kind.
@@ -136,14 +135,14 @@ struct CohereModel final : public transcribe_model {
     ggml_backend_buffer_t   backend_buffer = nullptr;
 
     // Fused BN parameters (same as Parakeet).
-    ggml_context *          bn_fused_ctx    = nullptr;
-    ggml_backend_buffer_t   bn_fused_buffer = nullptr;
+    ggml_context *        bn_fused_ctx    = nullptr;
+    ggml_backend_buffer_t bn_fused_buffer = nullptr;
 
     // On CPU primary backend, the conformer 1×1 pointwise conv weights
     // are dequantized F16->F32 at load time (Zen 2 has no native F16
     // compute). Tensors live here; CohereBlock slots point at them.
-    ggml_context *          conv_pw_f32_ctx    = nullptr;
-    ggml_backend_buffer_t   conv_pw_f32_buffer = nullptr;
+    ggml_context *        conv_pw_f32_ctx    = nullptr;
+    ggml_backend_buffer_t conv_pw_f32_buffer = nullptr;
 
     std::optional<transcribe::MelFrontend> mel;
 
@@ -154,9 +153,9 @@ struct CohereModel final : public transcribe_model {
 };
 
 struct CohereSession final : public transcribe_session {
-    ggml_context *        compute_ctx    = nullptr;
-    ggml_backend_sched_t  sched          = nullptr;
-    ggml_tensor *         encoder_out    = nullptr;
+    ggml_context *       compute_ctx = nullptr;
+    ggml_backend_sched_t sched       = nullptr;
+    ggml_tensor *        encoder_out = nullptr;
 
     // KV cache for the decoder.
     CohereKvCache kv_cache;
@@ -166,16 +165,15 @@ struct CohereSession final : public transcribe_session {
     std::vector<float> pos_div_term;
     std::vector<float> enc_host;
 
-
     // Flash-attn is per-stage: encoder dk=160 has no Metal flash_attn_ext
     // kernel (default OFF on Metal; manual path ties anyway); decoder
     // dk=128 works everywhere (default ON). TRANSCRIBE_NO_FLASH /
     // TRANSCRIBE_FORCE_FLASH apply to both stages at once.
-    bool               encoder_use_flash = true;
-    bool               decoder_use_flash = true;
+    bool encoder_use_flash = true;
+    bool decoder_use_flash = true;
 
     CohereSession() = default;
     ~CohereSession() override;
 };
 
-} // namespace transcribe::cohere
+}  // namespace transcribe::cohere
diff --git a/src/arch/cohere/decoder.cpp b/src/arch/cohere/decoder.cpp
index 77a437f7..4ef7d112 100644
--- a/src/arch/cohere/decoder.cpp
+++ b/src/arch/cohere/decoder.cpp
@@ -14,12 +14,10 @@
 #include "decoder.h"
 
 #include "cohere.h"
-#include "weights.h"
-
+#include "ggml.h"
 #include "transcribe-debug.h"
 #include "transcribe-log.h"
-
-#include "ggml.h"
+#include "weights.h"
 
 #include <cmath>
 #include <cstdio>
@@ -32,18 +30,18 @@ namespace {
 constexpr float kLayerNormEps = 1e-5f;
 
 ggml_tensor * named(ggml_tensor * t, const char * name) {
-    if (t != nullptr) ggml_set_name(t, name);
+    if (t != nullptr) {
+        ggml_set_name(t, name);
+    }
     return t;
 }
 
-ggml_tensor * layer_norm(ggml_context * ctx,
-                         ggml_tensor *  x,
-                         ggml_tensor *  gamma,
-                         ggml_tensor *  beta)
-{
+ggml_tensor * layer_norm(ggml_context * ctx, ggml_tensor * x, ggml_tensor * gamma, ggml_tensor * beta) {
     ggml_tensor * y = ggml_norm(ctx, x, kLayerNormEps);
-    y = ggml_mul(ctx, y, gamma);
-    if (beta != nullptr) y = ggml_add(ctx, y, beta);
+    y               = ggml_mul(ctx, y, gamma);
+    if (beta != nullptr) {
+        y = ggml_add(ctx, y, beta);
+    }
     return y;
 }
 
@@ -58,28 +56,37 @@ ggml_tensor * mha(ggml_context * ctx,
                   ggml_tensor *  x,
                   ggml_tensor *  context,
                   ggml_tensor *  mask,
-                  ggml_tensor *  q_w, ggml_tensor * q_b,
-                  ggml_tensor *  k_w, ggml_tensor * k_b,
-                  ggml_tensor *  v_w, ggml_tensor * v_b,
-                  ggml_tensor *  out_w, ggml_tensor * out_b,
+                  ggml_tensor *  q_w,
+                  ggml_tensor *  q_b,
+                  ggml_tensor *  k_w,
+                  ggml_tensor *  k_b,
+                  ggml_tensor *  v_w,
+                  ggml_tensor *  v_b,
+                  ggml_tensor *  out_w,
+                  ggml_tensor *  out_b,
                   int            n_heads,
                   int            hidden,
-                  bool           use_flash)
-{
-    const int head_dim = hidden / n_heads;
-    const float scale  = 1.0f / std::sqrt(static_cast<float>(head_dim));
-    const int64_t T_q  = x->ne[1];
+                  bool           use_flash) {
+    const int     head_dim = hidden / n_heads;
+    const float   scale    = 1.0f / std::sqrt(static_cast<float>(head_dim));
+    const int64_t T_q      = x->ne[1];
 
     ggml_tensor * source = (context != nullptr) ? context : x;
-    const int64_t T_k = source->ne[1];
+    const int64_t T_k    = source->ne[1];
 
     // Q, K, V projections with bias.
     ggml_tensor * q = ggml_mul_mat(ctx, q_w, x);
-    if (q_b != nullptr) q = ggml_add(ctx, q, q_b);
+    if (q_b != nullptr) {
+        q = ggml_add(ctx, q, q_b);
+    }
     ggml_tensor * k = ggml_mul_mat(ctx, k_w, source);
-    if (k_b != nullptr) k = ggml_add(ctx, k, k_b);
+    if (k_b != nullptr) {
+        k = ggml_add(ctx, k, k_b);
+    }
     ggml_tensor * v = ggml_mul_mat(ctx, v_w, source);
-    if (v_b != nullptr) v = ggml_add(ctx, v, v_b);
+    if (v_b != nullptr) {
+        v = ggml_add(ctx, v, v_b);
+    }
 
     // Split into heads: [head_dim, n_heads, T, 1] -> permute to
     // [head_dim, T, n_heads, 1] for flash_attn / standard.
@@ -107,14 +114,12 @@ ggml_tensor * mha(ggml_context * ctx,
         // soft_max_ext fuses scale + optional mask into softmax. Mask
         // shape must be [T_k, T_q] (or broadcastable); the caller
         // already prepared it as f16 at that shape.
-        ggml_tensor * kq_soft = ggml_soft_max_ext(ctx, kq, mask,
-                                                   scale, 0.0f);
+        ggml_tensor * kq_soft = ggml_soft_max_ext(ctx, kq, mask, scale, 0.0f);
 
         // V needs transposing for the value matmul.
         //   V is [head_dim, T_k, n_heads, 1]; we need
         //        [T_k, head_dim, n_heads, 1].
-        ggml_tensor * v_t = ggml_cont(ctx,
-                                       ggml_permute(ctx, v, 1, 0, 2, 3));
+        ggml_tensor * v_t = ggml_cont(ctx, ggml_permute(ctx, v, 1, 0, 2, 3));
 
         // attn_weights @ V -> [head_dim, T_q, n_heads, 1]
         o = ggml_mul_mat(ctx, v_t, kq_soft);
@@ -130,7 +135,9 @@ ggml_tensor * mha(ggml_context * ctx,
 
     // Output projection with bias.
     o = ggml_mul_mat(ctx, out_w, o);
-    if (out_b != nullptr) o = ggml_add(ctx, o, out_b);
+    if (out_b != nullptr) {
+        o = ggml_add(ctx, o, out_b);
+    }
     return o;
 }
 
@@ -146,77 +153,81 @@ ggml_tensor * mha(ggml_context * ctx,
 //
 // Writes new K/V into cache, reads full [0..n_past+n_tokens) for attn.
 // Returns: [hidden, n_tokens]
-ggml_tensor * mha_self_cached(
-    ggml_context * ctx,
-    ggml_cgraph *  gf,
-    ggml_tensor *  x,
-    CohereKvCache & kv_cache,
-    ggml_tensor *  mask,
-    ggml_tensor *  q_w, ggml_tensor * q_b,
-    ggml_tensor *  k_w, ggml_tensor * k_b,
-    ggml_tensor *  v_w, ggml_tensor * v_b,
-    ggml_tensor *  out_w, ggml_tensor * out_b,
-    int            n_heads,
-    int            hidden,
-    int            il,
-    int            n_past,
-    int            n_tokens,
-    bool           use_flash)
-{
-    const int head_dim = hidden / n_heads;
-    const float scale  = 1.0f / std::sqrt(static_cast<float>(head_dim));
-    const int n_ctx    = kv_cache.n_ctx;
-    const int n_kv     = n_past + n_tokens;
+ggml_tensor * mha_self_cached(ggml_context *  ctx,
+                              ggml_cgraph *   gf,
+                              ggml_tensor *   x,
+                              CohereKvCache & kv_cache,
+                              ggml_tensor *   mask,
+                              ggml_tensor *   q_w,
+                              ggml_tensor *   q_b,
+                              ggml_tensor *   k_w,
+                              ggml_tensor *   k_b,
+                              ggml_tensor *   v_w,
+                              ggml_tensor *   v_b,
+                              ggml_tensor *   out_w,
+                              ggml_tensor *   out_b,
+                              int             n_heads,
+                              int             hidden,
+                              int             il,
+                              int             n_past,
+                              int             n_tokens,
+                              bool            use_flash) {
+    const int   head_dim = hidden / n_heads;
+    const float scale    = 1.0f / std::sqrt(static_cast<float>(head_dim));
+    const int   n_ctx    = kv_cache.n_ctx;
+    const int   n_kv     = n_past + n_tokens;
 
     // Q, K, V projections from new tokens.
     ggml_tensor * Qcur = ggml_mul_mat(ctx, q_w, x);
-    if (q_b != nullptr) Qcur = ggml_add(ctx, Qcur, q_b);
+    if (q_b != nullptr) {
+        Qcur = ggml_add(ctx, Qcur, q_b);
+    }
 
     ggml_tensor * Kcur = ggml_mul_mat(ctx, k_w, x);
-    if (k_b != nullptr) Kcur = ggml_add(ctx, Kcur, k_b);
+    if (k_b != nullptr) {
+        Kcur = ggml_add(ctx, Kcur, k_b);
+    }
 
     ggml_tensor * Vcur = ggml_mul_mat(ctx, v_w, x);
-    if (v_b != nullptr) Vcur = ggml_add(ctx, Vcur, v_b);
+    if (v_b != nullptr) {
+        Vcur = ggml_add(ctx, Vcur, v_b);
+    }
 
     // Build Q for attention: [head_dim, n_tokens, n_heads].
     ggml_tensor * Q = ggml_reshape_3d(ctx, Qcur, head_dim, n_heads, n_tokens);
-    Q = ggml_permute(ctx, Q, 0, 2, 1, 3);
+    Q               = ggml_permute(ctx, Q, 0, 2, 1, 3);
     // Q is now [head_dim, n_tokens, n_heads, 1]
 
     // Write new K/V into cache. Layout: per-layer [hidden, n_ctx] contiguous
     // (n_state per position); layer il at flat offset il*n_ctx*hidden.
     {
-        ggml_tensor * k_dst = ggml_view_1d(ctx, kv_cache.self_k,
-            static_cast<int64_t>(n_tokens) * hidden,
-            ggml_element_size(kv_cache.self_k) * static_cast<size_t>(
-                static_cast<int64_t>(il) * n_ctx * hidden +
-                static_cast<int64_t>(n_past) * hidden));
-
-        ggml_tensor * v_dst = ggml_view_1d(ctx, kv_cache.self_v,
-            static_cast<int64_t>(n_tokens) * hidden,
-            ggml_element_size(kv_cache.self_v) * static_cast<size_t>(
-                static_cast<int64_t>(il) * n_ctx * hidden +
-                static_cast<int64_t>(n_past) * hidden));
+        ggml_tensor * k_dst = ggml_view_1d(
+            ctx, kv_cache.self_k, static_cast<int64_t>(n_tokens) * hidden,
+            ggml_element_size(kv_cache.self_k) *
+                static_cast<size_t>(static_cast<int64_t>(il) * n_ctx * hidden + static_cast<int64_t>(n_past) * hidden));
+
+        ggml_tensor * v_dst = ggml_view_1d(
+            ctx, kv_cache.self_v, static_cast<int64_t>(n_tokens) * hidden,
+            ggml_element_size(kv_cache.self_v) *
+                static_cast<size_t>(static_cast<int64_t>(il) * n_ctx * hidden + static_cast<int64_t>(n_past) * hidden));
 
         ggml_build_forward_expand(gf, ggml_cpy(ctx, Kcur, k_dst));
         ggml_build_forward_expand(gf, ggml_cpy(ctx, Vcur, v_dst));
     }
 
     // Read K from cache: [head_dim, n_kv, n_heads].
-    ggml_tensor * K = ggml_view_3d(ctx, kv_cache.self_k,
-        head_dim, n_kv, n_heads,
-        ggml_element_size(kv_cache.self_k) * hidden,       // nb1: stride between positions
-        ggml_element_size(kv_cache.self_k) * head_dim,     // nb2: stride between heads
-        ggml_element_size(kv_cache.self_k) * static_cast<size_t>(
-            static_cast<int64_t>(il) * n_ctx * hidden));   // offset to layer
+    ggml_tensor * K =
+        ggml_view_3d(ctx, kv_cache.self_k, head_dim, n_kv, n_heads,
+                     ggml_element_size(kv_cache.self_k) * hidden,    // nb1: stride between positions
+                     ggml_element_size(kv_cache.self_k) * head_dim,  // nb2: stride between heads
+                     ggml_element_size(kv_cache.self_k) *
+                         static_cast<size_t>(static_cast<int64_t>(il) * n_ctx * hidden));  // offset to layer
 
     // Read V from cache: [head_dim, n_kv, n_heads].
-    ggml_tensor * V = ggml_view_3d(ctx, kv_cache.self_v,
-        head_dim, n_kv, n_heads,
-        ggml_element_size(kv_cache.self_v) * hidden,
+    ggml_tensor * V = ggml_view_3d(
+        ctx, kv_cache.self_v, head_dim, n_kv, n_heads, ggml_element_size(kv_cache.self_v) * hidden,
         ggml_element_size(kv_cache.self_v) * head_dim,
-        ggml_element_size(kv_cache.self_v) * static_cast<size_t>(
-            static_cast<int64_t>(il) * n_ctx * hidden));
+        ggml_element_size(kv_cache.self_v) * static_cast<size_t>(static_cast<int64_t>(il) * n_ctx * hidden));
 
     // Flash path is fused; manual path is the mul_mat + soft_max_ext +
     // mul_mat triple (see `mha` above for the shape walkthrough).
@@ -227,20 +238,20 @@ ggml_tensor * mha_self_cached(
     } else {
         // Manual path — see `mha` for the shape walkthrough.
         // K: [head_dim, n_kv, n_heads, 1]; V transposed for the value matmul.
-        ggml_tensor * kq = ggml_mul_mat(ctx, K, Q);
-        ggml_tensor * kq_soft = ggml_soft_max_ext(ctx, kq, mask,
-                                                   scale, 0.0f);
-        ggml_tensor * v_t = ggml_cont(ctx,
-                                       ggml_permute(ctx, V, 1, 0, 2, 3));
-        o = ggml_mul_mat(ctx, v_t, kq_soft);
-        o = ggml_permute(ctx, o, 0, 2, 1, 3);
-        o = ggml_cont(ctx, o);
-        o = ggml_reshape_2d(ctx, o, hidden, n_tokens);
+        ggml_tensor * kq      = ggml_mul_mat(ctx, K, Q);
+        ggml_tensor * kq_soft = ggml_soft_max_ext(ctx, kq, mask, scale, 0.0f);
+        ggml_tensor * v_t     = ggml_cont(ctx, ggml_permute(ctx, V, 1, 0, 2, 3));
+        o                     = ggml_mul_mat(ctx, v_t, kq_soft);
+        o                     = ggml_permute(ctx, o, 0, 2, 1, 3);
+        o                     = ggml_cont(ctx, o);
+        o                     = ggml_reshape_2d(ctx, o, hidden, n_tokens);
     }
 
     // Output projection.
     o = ggml_mul_mat(ctx, out_w, o);
-    if (out_b != nullptr) o = ggml_add(ctx, o, out_b);
+    if (out_b != nullptr) {
+        o = ggml_add(ctx, o, out_b);
+    }
     return o;
 }
 
@@ -248,101 +259,97 @@ ggml_tensor * mha_self_cached(
 // go through ggml_set_rows at runtime row index `kv_idx`; reads span
 // the full [0, max_n_kv) window with `mask` gating valid positions.
 // n_tokens is implicitly 1.
-ggml_tensor * mha_self_step(
-    ggml_context * ctx,
-    ggml_cgraph *  gf,
-    ggml_tensor *  x,
-    CohereKvCache & kv_cache,
-    ggml_tensor *  mask,
-    ggml_tensor *  kv_idx,
-    ggml_tensor *  q_w, ggml_tensor * q_b,
-    ggml_tensor *  k_w, ggml_tensor * k_b,
-    ggml_tensor *  v_w, ggml_tensor * v_b,
-    ggml_tensor *  out_w, ggml_tensor * out_b,
-    int            n_heads,
-    int            hidden,
-    int            il,
-    int            max_n_kv,
-    bool           use_flash)
-{
-    const int head_dim = hidden / n_heads;
-    const float scale  = 1.0f / std::sqrt(static_cast<float>(head_dim));
-    const int n_ctx    = kv_cache.n_ctx;
+ggml_tensor * mha_self_step(ggml_context *  ctx,
+                            ggml_cgraph *   gf,
+                            ggml_tensor *   x,
+                            CohereKvCache & kv_cache,
+                            ggml_tensor *   mask,
+                            ggml_tensor *   kv_idx,
+                            ggml_tensor *   q_w,
+                            ggml_tensor *   q_b,
+                            ggml_tensor *   k_w,
+                            ggml_tensor *   k_b,
+                            ggml_tensor *   v_w,
+                            ggml_tensor *   v_b,
+                            ggml_tensor *   out_w,
+                            ggml_tensor *   out_b,
+                            int             n_heads,
+                            int             hidden,
+                            int             il,
+                            int             max_n_kv,
+                            bool            use_flash) {
+    const int   head_dim = hidden / n_heads;
+    const float scale    = 1.0f / std::sqrt(static_cast<float>(head_dim));
+    const int   n_ctx    = kv_cache.n_ctx;
 
     ggml_tensor * Qcur = ggml_mul_mat(ctx, q_w, x);
-    if (q_b != nullptr) Qcur = ggml_add(ctx, Qcur, q_b);
+    if (q_b != nullptr) {
+        Qcur = ggml_add(ctx, Qcur, q_b);
+    }
 
     ggml_tensor * Kcur = ggml_mul_mat(ctx, k_w, x);
-    if (k_b != nullptr) Kcur = ggml_add(ctx, Kcur, k_b);
+    if (k_b != nullptr) {
+        Kcur = ggml_add(ctx, Kcur, k_b);
+    }
 
     ggml_tensor * Vcur = ggml_mul_mat(ctx, v_w, x);
-    if (v_b != nullptr) Vcur = ggml_add(ctx, Vcur, v_b);
+    if (v_b != nullptr) {
+        Vcur = ggml_add(ctx, Vcur, v_b);
+    }
 
     ggml_tensor * Q = ggml_reshape_3d(ctx, Qcur, head_dim, n_heads, /*n_tokens=*/1);
-    Q = ggml_permute(ctx, Q, 0, 2, 1, 3);
+    Q               = ggml_permute(ctx, Q, 0, 2, 1, 3);
 
     // KV cache write via ggml_set_rows. Static topology — only kv_idx's
     // value changes per step. Per-layer view spans [hidden, n_ctx], and
     // we write a single [hidden, 1] row at the kv_idx position.
     {
-        const size_t k_elem = ggml_element_size(kv_cache.self_k);
-        const size_t v_elem = ggml_element_size(kv_cache.self_v);
-        const size_t layer_off_k = k_elem * static_cast<size_t>(
-            static_cast<int64_t>(il) * n_ctx * hidden);
-        const size_t layer_off_v = v_elem * static_cast<size_t>(
-            static_cast<int64_t>(il) * n_ctx * hidden);
-
-        ggml_tensor * k_layer = ggml_view_2d(
-            ctx, kv_cache.self_k,
-            hidden, n_ctx,
-            k_elem * hidden, layer_off_k);
-        ggml_tensor * v_layer = ggml_view_2d(
-            ctx, kv_cache.self_v,
-            hidden, n_ctx,
-            v_elem * hidden, layer_off_v);
+        const size_t k_elem      = ggml_element_size(kv_cache.self_k);
+        const size_t v_elem      = ggml_element_size(kv_cache.self_v);
+        const size_t layer_off_k = k_elem * static_cast<size_t>(static_cast<int64_t>(il) * n_ctx * hidden);
+        const size_t layer_off_v = v_elem * static_cast<size_t>(static_cast<int64_t>(il) * n_ctx * hidden);
+
+        ggml_tensor * k_layer = ggml_view_2d(ctx, kv_cache.self_k, hidden, n_ctx, k_elem * hidden, layer_off_k);
+        ggml_tensor * v_layer = ggml_view_2d(ctx, kv_cache.self_v, hidden, n_ctx, v_elem * hidden, layer_off_v);
 
         ggml_tensor * K_row = ggml_reshape_2d(ctx, Kcur, hidden, 1);
         ggml_tensor * V_row = ggml_reshape_2d(ctx, Vcur, hidden, 1);
 
-        ggml_build_forward_expand(
-            gf, ggml_set_rows(ctx, k_layer, K_row, kv_idx));
-        ggml_build_forward_expand(
-            gf, ggml_set_rows(ctx, v_layer, V_row, kv_idx));
+        ggml_build_forward_expand(gf, ggml_set_rows(ctx, k_layer, K_row, kv_idx));
+        ggml_build_forward_expand(gf, ggml_set_rows(ctx, v_layer, V_row, kv_idx));
     }
 
     // Static read across [0, max_n_kv); mask zeros valid positions and
     // -inf's the rest, so flash-attn ignores empty/future slots. Costs
     // some bandwidth at low n_past — caller picks max_n_kv to bound it.
-    ggml_tensor * K = ggml_view_3d(ctx, kv_cache.self_k,
-        head_dim, max_n_kv, n_heads,
-        ggml_element_size(kv_cache.self_k) * hidden,
+    ggml_tensor * K = ggml_view_3d(
+        ctx, kv_cache.self_k, head_dim, max_n_kv, n_heads, ggml_element_size(kv_cache.self_k) * hidden,
         ggml_element_size(kv_cache.self_k) * head_dim,
-        ggml_element_size(kv_cache.self_k) * static_cast<size_t>(
-            static_cast<int64_t>(il) * n_ctx * hidden));
+        ggml_element_size(kv_cache.self_k) * static_cast<size_t>(static_cast<int64_t>(il) * n_ctx * hidden));
 
-    ggml_tensor * V = ggml_view_3d(ctx, kv_cache.self_v,
-        head_dim, max_n_kv, n_heads,
-        ggml_element_size(kv_cache.self_v) * hidden,
+    ggml_tensor * V = ggml_view_3d(
+        ctx, kv_cache.self_v, head_dim, max_n_kv, n_heads, ggml_element_size(kv_cache.self_v) * hidden,
         ggml_element_size(kv_cache.self_v) * head_dim,
-        ggml_element_size(kv_cache.self_v) * static_cast<size_t>(
-            static_cast<int64_t>(il) * n_ctx * hidden));
+        ggml_element_size(kv_cache.self_v) * static_cast<size_t>(static_cast<int64_t>(il) * n_ctx * hidden));
 
     ggml_tensor * o;
     if (use_flash) {
         o = ggml_flash_attn_ext(ctx, Q, K, V, mask, scale, 0.0f, 0.0f);
         o = ggml_reshape_2d(ctx, o, hidden, 1);
     } else {
-        ggml_tensor * kq = ggml_mul_mat(ctx, K, Q);
+        ggml_tensor * kq      = ggml_mul_mat(ctx, K, Q);
         ggml_tensor * kq_soft = ggml_soft_max_ext(ctx, kq, mask, scale, 0.0f);
-        ggml_tensor * v_t = ggml_cont(ctx, ggml_permute(ctx, V, 1, 0, 2, 3));
-        o = ggml_mul_mat(ctx, v_t, kq_soft);
-        o = ggml_permute(ctx, o, 0, 2, 1, 3);
-        o = ggml_cont(ctx, o);
-        o = ggml_reshape_2d(ctx, o, hidden, 1);
+        ggml_tensor * v_t     = ggml_cont(ctx, ggml_permute(ctx, V, 1, 0, 2, 3));
+        o                     = ggml_mul_mat(ctx, v_t, kq_soft);
+        o                     = ggml_permute(ctx, o, 0, 2, 1, 3);
+        o                     = ggml_cont(ctx, o);
+        o                     = ggml_reshape_2d(ctx, o, hidden, 1);
     }
 
     o = ggml_mul_mat(ctx, out_w, o);
-    if (out_b != nullptr) o = ggml_add(ctx, o, out_b);
+    if (out_b != nullptr) {
+        o = ggml_add(ctx, o, out_b);
+    }
     return o;
 }
 
@@ -354,93 +361,89 @@ ggml_tensor * mha_self_step(
 // T_enc:    number of encoder frames
 //
 // Returns: [hidden, n_tokens]
-ggml_tensor * mha_cross_cached(
-    ggml_context * ctx,
-    ggml_tensor *  x,
-    CohereKvCache & kv_cache,
-    ggml_tensor *  q_w, ggml_tensor * q_b,
-    ggml_tensor *  out_w, ggml_tensor * out_b,
-    int            n_heads,
-    int            hidden,
-    int            il,
-    int            T_enc,
-    bool           use_flash)
-{
-    const int head_dim = hidden / n_heads;
-    const float scale  = 1.0f / std::sqrt(static_cast<float>(head_dim));
+ggml_tensor * mha_cross_cached(ggml_context *  ctx,
+                               ggml_tensor *   x,
+                               CohereKvCache & kv_cache,
+                               ggml_tensor *   q_w,
+                               ggml_tensor *   q_b,
+                               ggml_tensor *   out_w,
+                               ggml_tensor *   out_b,
+                               int             n_heads,
+                               int             hidden,
+                               int             il,
+                               int             T_enc,
+                               bool            use_flash) {
+    const int     head_dim = hidden / n_heads;
+    const float   scale    = 1.0f / std::sqrt(static_cast<float>(head_dim));
     const int64_t n_tokens = x->ne[1];
 
     // Only Q is computed from current input. K/V come from cache.
     ggml_tensor * Qcur = ggml_mul_mat(ctx, q_w, x);
-    if (q_b != nullptr) Qcur = ggml_add(ctx, Qcur, q_b);
+    if (q_b != nullptr) {
+        Qcur = ggml_add(ctx, Qcur, q_b);
+    }
 
     ggml_tensor * Q = ggml_reshape_3d(ctx, Qcur, head_dim, n_heads, n_tokens);
-    Q = ggml_permute(ctx, Q, 0, 2, 1, 3);
+    Q               = ggml_permute(ctx, Q, 0, 2, 1, 3);
 
     // Read K from cross cache: [head_dim, T_enc, n_heads].
-    ggml_tensor * K = ggml_view_3d(ctx, kv_cache.cross_k,
-        head_dim, T_enc, n_heads,
-        ggml_element_size(kv_cache.cross_k) * hidden,
+    ggml_tensor * K = ggml_view_3d(
+        ctx, kv_cache.cross_k, head_dim, T_enc, n_heads, ggml_element_size(kv_cache.cross_k) * hidden,
         ggml_element_size(kv_cache.cross_k) * head_dim,
-        ggml_element_size(kv_cache.cross_k) * static_cast<size_t>(
-            static_cast<int64_t>(il) * T_enc * hidden));
+        ggml_element_size(kv_cache.cross_k) * static_cast<size_t>(static_cast<int64_t>(il) * T_enc * hidden));
 
     // Read V from cross cache: [head_dim, T_enc, n_heads].
-    ggml_tensor * V = ggml_view_3d(ctx, kv_cache.cross_v,
-        head_dim, T_enc, n_heads,
-        ggml_element_size(kv_cache.cross_v) * hidden,
+    ggml_tensor * V = ggml_view_3d(
+        ctx, kv_cache.cross_v, head_dim, T_enc, n_heads, ggml_element_size(kv_cache.cross_v) * hidden,
         ggml_element_size(kv_cache.cross_v) * head_dim,
-        ggml_element_size(kv_cache.cross_v) * static_cast<size_t>(
-            static_cast<int64_t>(il) * T_enc * hidden));
+        ggml_element_size(kv_cache.cross_v) * static_cast<size_t>(static_cast<int64_t>(il) * T_enc * hidden));
 
     // No mask for cross-attention.
     ggml_tensor * o;
     if (use_flash) {
-        o = ggml_flash_attn_ext(ctx, Q, K, V, nullptr,
-                                scale, 0.0f, 0.0f);
+        o = ggml_flash_attn_ext(ctx, Q, K, V, nullptr, scale, 0.0f, 0.0f);
         o = ggml_reshape_2d(ctx, o, hidden, n_tokens);
     } else {
         // Manual path — see `mha` for the shape walkthrough.
         // K: [head_dim, T_enc, n_heads, 1]; V transposed for the value matmul.
-        ggml_tensor * kq = ggml_mul_mat(ctx, K, Q);
-        ggml_tensor * kq_soft = ggml_soft_max_ext(ctx, kq, nullptr,
-                                                   scale, 0.0f);
-        ggml_tensor * v_t = ggml_cont(ctx,
-                                       ggml_permute(ctx, V, 1, 0, 2, 3));
-        o = ggml_mul_mat(ctx, v_t, kq_soft);
-        o = ggml_permute(ctx, o, 0, 2, 1, 3);
-        o = ggml_cont(ctx, o);
-        o = ggml_reshape_2d(ctx, o, hidden, n_tokens);
+        ggml_tensor * kq      = ggml_mul_mat(ctx, K, Q);
+        ggml_tensor * kq_soft = ggml_soft_max_ext(ctx, kq, nullptr, scale, 0.0f);
+        ggml_tensor * v_t     = ggml_cont(ctx, ggml_permute(ctx, V, 1, 0, 2, 3));
+        o                     = ggml_mul_mat(ctx, v_t, kq_soft);
+        o                     = ggml_permute(ctx, o, 0, 2, 1, 3);
+        o                     = ggml_cont(ctx, o);
+        o                     = ggml_reshape_2d(ctx, o, hidden, n_tokens);
     }
 
     // Output projection.
     o = ggml_mul_mat(ctx, out_w, o);
-    if (out_b != nullptr) o = ggml_add(ctx, o, out_b);
+    if (out_b != nullptr) {
+        o = ggml_add(ctx, o, out_b);
+    }
     return o;
 }
 
-} // namespace
+}  // namespace
 
 // Original non-cached prompt-pass graph (kept for reference/validation).
-DecoderBuild build_decoder_graph(ggml_context *         ctx,
-                                 const CohereWeights &  w,
-                                 const CohereHParams &  hp,
-                                 int                    seq_len,
-                                 int                    T_enc,
-                                 bool                   use_flash)
-{
-    DecoderBuild db {};
+DecoderBuild build_decoder_graph(ggml_context *        ctx,
+                                 const CohereWeights & w,
+                                 const CohereHParams & hp,
+                                 int                   seq_len,
+                                 int                   T_enc,
+                                 bool                  use_flash) {
+    DecoderBuild db{};
 
     if (ctx == nullptr || seq_len <= 0 || T_enc <= 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "cohere decoder: invalid arg "
-                     "(ctx=%p, seq_len=%d, T_enc=%d)",
-                     static_cast<void *>(ctx), seq_len, T_enc);
+                "cohere decoder: invalid arg "
+                "(ctx=%p, seq_len=%d, T_enc=%d)",
+                static_cast<void *>(ctx), seq_len, T_enc);
         return db;
     }
 
-    const int64_t hidden   = hp.dec_hidden;
-    const int     n_heads  = hp.dec_n_heads;
+    const int64_t hidden  = hp.dec_hidden;
+    const int     n_heads = hp.dec_n_heads;
 
     // Input tensors.
     db.token_ids_in = ggml_new_tensor_1d(ctx, GGML_TYPE_I32, seq_len);
@@ -456,23 +459,21 @@ DecoderBuild build_decoder_graph(ggml_context *         ctx,
     ggml_set_input(db.encoder_out_in);
 
     // Token embedding: get_rows over [hidden, vocab_size] -> [hidden, seq_len].
-    ggml_tensor * tok_emb = ggml_get_rows(ctx, w.dec_embed.token_w,
-                                          db.token_ids_in);
-    tok_emb = named(tok_emb, "dec.token_emb");
+    ggml_tensor * tok_emb = ggml_get_rows(ctx, w.dec_embed.token_w, db.token_ids_in);
+    tok_emb               = named(tok_emb, "dec.token_emb");
     ggml_set_output(tok_emb);
     db.dumps.token_emb = tok_emb;
 
     // Positional embedding: get_rows over [hidden, max_seq].
-    ggml_tensor * pos_emb = ggml_get_rows(ctx, w.dec_embed.pos_enc,
-                                          db.pos_ids_in);
-    pos_emb = named(pos_emb, "dec.pos_emb");
+    ggml_tensor * pos_emb = ggml_get_rows(ctx, w.dec_embed.pos_enc, db.pos_ids_in);
+    pos_emb               = named(pos_emb, "dec.pos_emb");
     ggml_set_output(pos_emb);
     db.dumps.pos_emb = pos_emb;
 
     // x = LayerNorm(tok_emb + pos_emb)
     ggml_tensor * x = ggml_add(ctx, tok_emb, pos_emb);
-    x = layer_norm(ctx, x, w.dec_embed.norm_w, w.dec_embed.norm_b);
-    x = named(x, "dec.embed_norm");
+    x               = layer_norm(ctx, x, w.dec_embed.norm_w, w.dec_embed.norm_b);
+    x               = named(x, "dec.embed_norm");
     ggml_set_output(x);
     db.dumps.embed_norm = x;
 
@@ -480,8 +481,7 @@ DecoderBuild build_decoder_graph(ggml_context *         ctx,
     // -inf. Driver fills the F32 input; cast to F16 for flash_attn.
     ggml_tensor * causal_mask = nullptr;
     if (seq_len > 1) {
-        causal_mask = ggml_new_tensor_2d(ctx, GGML_TYPE_F32,
-                                         seq_len, seq_len);
+        causal_mask = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, seq_len, seq_len);
         ggml_set_name(causal_mask, "dec.causal_mask");
         ggml_set_input(causal_mask);
         causal_mask = ggml_cast(ctx, causal_mask, GGML_TYPE_F16);
@@ -493,52 +493,45 @@ DecoderBuild build_decoder_graph(ggml_context *         ctx,
 
         // Pre-LN self-attention with causal mask.
         {
-            ggml_tensor * x_norm = layer_norm(ctx, x,
-                                              blk.norm_self_w, blk.norm_self_b);
-            ggml_tensor * self_out = mha(ctx, x_norm, nullptr, causal_mask,
-                                         blk.self_q_w, blk.self_q_b,
-                                         blk.self_k_w, blk.self_k_b,
-                                         blk.self_v_w, blk.self_v_b,
-                                         blk.self_out_w, blk.self_out_b,
-                                         n_heads, static_cast<int>(hidden),
-                                         use_flash);
-            x = ggml_add(ctx, x, self_out);
+            ggml_tensor * x_norm   = layer_norm(ctx, x, blk.norm_self_w, blk.norm_self_b);
+            ggml_tensor * self_out = mha(ctx, x_norm, nullptr, causal_mask, blk.self_q_w, blk.self_q_b, blk.self_k_w,
+                                         blk.self_k_b, blk.self_v_w, blk.self_v_b, blk.self_out_w, blk.self_out_b,
+                                         n_heads, static_cast<int>(hidden), use_flash);
+            x                      = ggml_add(ctx, x, self_out);
         }
 
         // Pre-LN cross-attention (encoder output as K/V, no mask).
         {
-            ggml_tensor * x_norm = layer_norm(ctx, x,
-                                              blk.norm_cross_w, blk.norm_cross_b);
-            ggml_tensor * cross_out = mha(ctx, x_norm, db.encoder_out_in, nullptr,
-                                          blk.cross_q_w, blk.cross_q_b,
-                                          blk.cross_k_w, blk.cross_k_b,
-                                          blk.cross_v_w, blk.cross_v_b,
-                                          blk.cross_out_w, blk.cross_out_b,
-                                          n_heads, static_cast<int>(hidden),
-                                          use_flash);
-            x = ggml_add(ctx, x, cross_out);
+            ggml_tensor * x_norm    = layer_norm(ctx, x, blk.norm_cross_w, blk.norm_cross_b);
+            ggml_tensor * cross_out = mha(ctx, x_norm, db.encoder_out_in, nullptr, blk.cross_q_w, blk.cross_q_b,
+                                          blk.cross_k_w, blk.cross_k_b, blk.cross_v_w, blk.cross_v_b, blk.cross_out_w,
+                                          blk.cross_out_b, n_heads, static_cast<int>(hidden), use_flash);
+            x                       = ggml_add(ctx, x, cross_out);
         }
 
         // Pre-LN FFN with ReLU (or silu).
         {
-            ggml_tensor * x_norm = layer_norm(ctx, x,
-                                              blk.norm_ff_w, blk.norm_ff_b);
-            ggml_tensor * ff = ggml_mul_mat(ctx, blk.ff_in_w, x_norm);
-            if (blk.ff_in_b != nullptr) ff = ggml_add(ctx, ff, blk.ff_in_b);
+            ggml_tensor * x_norm = layer_norm(ctx, x, blk.norm_ff_w, blk.norm_ff_b);
+            ggml_tensor * ff     = ggml_mul_mat(ctx, blk.ff_in_w, x_norm);
+            if (blk.ff_in_b != nullptr) {
+                ff = ggml_add(ctx, ff, blk.ff_in_b);
+            }
             if (hp.dec_activation == "relu") {
                 ff = ggml_relu(ctx, ff);
             } else {
                 ff = ggml_silu(ctx, ff);
             }
             ff = ggml_mul_mat(ctx, blk.ff_out_w, ff);
-            if (blk.ff_out_b != nullptr) ff = ggml_add(ctx, ff, blk.ff_out_b);
+            if (blk.ff_out_b != nullptr) {
+                ff = ggml_add(ctx, ff, blk.ff_out_b);
+            }
             x = ggml_add(ctx, x, ff);
         }
     }
 
     // Final LayerNorm.
-    x = layer_norm(ctx, x, w.dec_final.norm_w, w.dec_final.norm_b);
-    x = named(x, "dec.out_before_head");
+    x                        = layer_norm(ctx, x, w.dec_final.norm_w, w.dec_final.norm_b);
+    x                        = named(x, "dec.out_before_head");
     db.dumps.out_before_head = x;
 
     // Head: tied weight (the [hidden, vocab_size] token embedding) + bias +
@@ -551,7 +544,7 @@ DecoderBuild build_decoder_graph(ggml_context *         ctx,
     if (hp.head_log_softmax) {
         logits = ggml_log(ctx, ggml_soft_max(ctx, logits));
     }
-    logits = named(logits, "dec.logits");
+    logits          = named(logits, "dec.logits");
     db.dumps.logits = logits;
 
     db.out = logits;
@@ -560,8 +553,7 @@ DecoderBuild build_decoder_graph(ggml_context *         ctx,
     // Build the forward graph.
     db.graph = ggml_new_graph_custom(ctx, 8192, false);
     if (db.graph == nullptr) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "cohere decoder: ggml_new_graph_custom failed");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "cohere decoder: ggml_new_graph_custom failed");
         return db;
     }
     ggml_build_forward_expand(db.graph, db.out);
@@ -570,22 +562,20 @@ DecoderBuild build_decoder_graph(ggml_context *         ctx,
 }
 
 // Cross-attention KV computation graph.
-DecoderBuild build_cross_kv_graph(ggml_context *         ctx,
-                                  const CohereWeights &  w,
-                                  const CohereHParams &  hp,
-                                  CohereKvCache &        kv_cache,
-                                  int                    T_enc)
-{
-    DecoderBuild db {};
+DecoderBuild build_cross_kv_graph(ggml_context *        ctx,
+                                  const CohereWeights & w,
+                                  const CohereHParams & hp,
+                                  CohereKvCache &       kv_cache,
+                                  int                   T_enc) {
+    DecoderBuild db{};
 
     if (ctx == nullptr || T_enc <= 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "cohere cross_kv: invalid arg (ctx=%p, T_enc=%d)",
-                     static_cast<void *>(ctx), T_enc);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "cohere cross_kv: invalid arg (ctx=%p, T_enc=%d)", static_cast<void *>(ctx),
+                T_enc);
         return db;
     }
 
-    const int64_t hidden  = hp.dec_hidden;
+    const int64_t hidden = hp.dec_hidden;
 
     // Input: encoder output [hidden, T_enc].
     db.encoder_out_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, hidden, T_enc);
@@ -594,8 +584,7 @@ DecoderBuild build_cross_kv_graph(ggml_context *         ctx,
 
     db.graph = ggml_new_graph_custom(ctx, 4096, false);
     if (db.graph == nullptr) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "cohere cross_kv: ggml_new_graph_custom failed");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "cohere cross_kv: ggml_new_graph_custom failed");
         return db;
     }
 
@@ -604,28 +593,24 @@ DecoderBuild build_cross_kv_graph(ggml_context *         ctx,
     for (int il = 0; il < hp.dec_n_layers; ++il) {
         const auto & blk = w.dec_blocks[il];
 
-        ggml_tensor * Kcross = ggml_mul_mat(ctx, blk.cross_k_w,
-                                            db.encoder_out_in);
+        ggml_tensor * Kcross = ggml_mul_mat(ctx, blk.cross_k_w, db.encoder_out_in);
         if (blk.cross_k_b != nullptr) {
             Kcross = ggml_add(ctx, Kcross, blk.cross_k_b);
         }
 
-        ggml_tensor * Vcross = ggml_mul_mat(ctx, blk.cross_v_w,
-                                            db.encoder_out_in);
+        ggml_tensor * Vcross = ggml_mul_mat(ctx, blk.cross_v_w, db.encoder_out_in);
         if (blk.cross_v_b != nullptr) {
             Vcross = ggml_add(ctx, Vcross, blk.cross_v_b);
         }
 
         // Write into cross cache. Layout: flat [hidden * T_enc] per layer.
-        ggml_tensor * k_dst = ggml_view_1d(ctx, kv_cache.cross_k,
-            static_cast<int64_t>(T_enc) * hidden,
-            ggml_element_size(kv_cache.cross_k) * static_cast<size_t>(
-                static_cast<int64_t>(il) * T_enc * hidden));
+        ggml_tensor * k_dst = ggml_view_1d(
+            ctx, kv_cache.cross_k, static_cast<int64_t>(T_enc) * hidden,
+            ggml_element_size(kv_cache.cross_k) * static_cast<size_t>(static_cast<int64_t>(il) * T_enc * hidden));
 
-        ggml_tensor * v_dst = ggml_view_1d(ctx, kv_cache.cross_v,
-            static_cast<int64_t>(T_enc) * hidden,
-            ggml_element_size(kv_cache.cross_v) * static_cast<size_t>(
-                static_cast<int64_t>(il) * T_enc * hidden));
+        ggml_tensor * v_dst = ggml_view_1d(
+            ctx, kv_cache.cross_v, static_cast<int64_t>(T_enc) * hidden,
+            ggml_element_size(kv_cache.cross_v) * static_cast<size_t>(static_cast<int64_t>(il) * T_enc * hidden));
 
         ggml_build_forward_expand(db.graph, ggml_cpy(ctx, Kcross, k_dst));
         ggml_build_forward_expand(db.graph, ggml_cpy(ctx, Vcross, v_dst));
@@ -635,23 +620,22 @@ DecoderBuild build_cross_kv_graph(ggml_context *         ctx,
 }
 
 // KV-cached decoder graph (prompt + step passes).
-DecoderBuild build_decoder_graph_kv(ggml_context *         ctx,
-                                    const CohereWeights &  w,
-                                    const CohereHParams &  hp,
-                                    CohereKvCache &        kv_cache,
-                                    int                    n_tokens,
-                                    int                    n_past,
-                                    int                    T_enc,
-                                    bool                   skip_log_softmax,
-                                    bool                   use_flash)
-{
-    DecoderBuild db {};
+DecoderBuild build_decoder_graph_kv(ggml_context *        ctx,
+                                    const CohereWeights & w,
+                                    const CohereHParams & hp,
+                                    CohereKvCache &       kv_cache,
+                                    int                   n_tokens,
+                                    int                   n_past,
+                                    int                   T_enc,
+                                    bool                  skip_log_softmax,
+                                    bool                  use_flash) {
+    DecoderBuild db{};
 
     if (ctx == nullptr || n_tokens <= 0 || T_enc <= 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "cohere decoder_kv: invalid arg "
-                     "(ctx=%p, n_tokens=%d, T_enc=%d)",
-                     static_cast<void *>(ctx), n_tokens, T_enc);
+                "cohere decoder_kv: invalid arg "
+                "(ctx=%p, n_tokens=%d, T_enc=%d)",
+                static_cast<void *>(ctx), n_tokens, T_enc);
         return db;
     }
 
@@ -668,22 +652,20 @@ DecoderBuild build_decoder_graph_kv(ggml_context *         ctx,
     ggml_set_name(db.pos_ids_in, "dec.pos_ids");
     ggml_set_input(db.pos_ids_in);
 
-    ggml_tensor * tok_emb = ggml_get_rows(ctx, w.dec_embed.token_w,
-                                          db.token_ids_in);
-    tok_emb = named(tok_emb, "dec.token_emb");
+    ggml_tensor * tok_emb = ggml_get_rows(ctx, w.dec_embed.token_w, db.token_ids_in);
+    tok_emb               = named(tok_emb, "dec.token_emb");
     ggml_set_output(tok_emb);
     db.dumps.token_emb = tok_emb;
 
-    ggml_tensor * pos_emb = ggml_get_rows(ctx, w.dec_embed.pos_enc,
-                                          db.pos_ids_in);
-    pos_emb = named(pos_emb, "dec.pos_emb");
+    ggml_tensor * pos_emb = ggml_get_rows(ctx, w.dec_embed.pos_enc, db.pos_ids_in);
+    pos_emb               = named(pos_emb, "dec.pos_emb");
     ggml_set_output(pos_emb);
     db.dumps.pos_emb = pos_emb;
 
     // x = LayerNorm(tok_emb + pos_emb)
     ggml_tensor * x = ggml_add(ctx, tok_emb, pos_emb);
-    x = layer_norm(ctx, x, w.dec_embed.norm_w, w.dec_embed.norm_b);
-    x = named(x, "dec.embed_norm");
+    x               = layer_norm(ctx, x, w.dec_embed.norm_w, w.dec_embed.norm_b);
+    x               = named(x, "dec.embed_norm");
     ggml_set_output(x);
     db.dumps.embed_norm = x;
 
@@ -701,8 +683,7 @@ DecoderBuild build_decoder_graph_kv(ggml_context *         ctx,
     // ggml_build_forward_expand on it.
     db.graph = ggml_new_graph_custom(ctx, 8192, false);
     if (db.graph == nullptr) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "cohere decoder_kv: ggml_new_graph_custom failed");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "cohere decoder_kv: ggml_new_graph_custom failed");
         return db;
     }
 
@@ -712,47 +693,39 @@ DecoderBuild build_decoder_graph_kv(ggml_context *         ctx,
 
         // Pre-LN self-attention with KV cache.
         {
-            ggml_tensor * x_norm = layer_norm(ctx, x,
-                                              blk.norm_self_w, blk.norm_self_b);
-            ggml_tensor * self_out = mha_self_cached(
-                ctx, db.graph, x_norm, kv_cache, causal_mask,
-                blk.self_q_w, blk.self_q_b,
-                blk.self_k_w, blk.self_k_b,
-                blk.self_v_w, blk.self_v_b,
-                blk.self_out_w, blk.self_out_b,
-                n_heads, static_cast<int>(hidden),
-                i, n_past, n_tokens,
-                use_flash);
+            ggml_tensor * x_norm = layer_norm(ctx, x, blk.norm_self_w, blk.norm_self_b);
+            ggml_tensor * self_out =
+                mha_self_cached(ctx, db.graph, x_norm, kv_cache, causal_mask, blk.self_q_w, blk.self_q_b, blk.self_k_w,
+                                blk.self_k_b, blk.self_v_w, blk.self_v_b, blk.self_out_w, blk.self_out_b, n_heads,
+                                static_cast<int>(hidden), i, n_past, n_tokens, use_flash);
             x = ggml_add(ctx, x, self_out);
         }
 
         // Pre-LN cross-attention reading from cached K/V.
         {
-            ggml_tensor * x_norm = layer_norm(ctx, x,
-                                              blk.norm_cross_w, blk.norm_cross_b);
-            ggml_tensor * cross_out = mha_cross_cached(
-                ctx, x_norm, kv_cache,
-                blk.cross_q_w, blk.cross_q_b,
-                blk.cross_out_w, blk.cross_out_b,
-                n_heads, static_cast<int>(hidden),
-                i, T_enc,
-                use_flash);
+            ggml_tensor * x_norm = layer_norm(ctx, x, blk.norm_cross_w, blk.norm_cross_b);
+            ggml_tensor * cross_out =
+                mha_cross_cached(ctx, x_norm, kv_cache, blk.cross_q_w, blk.cross_q_b, blk.cross_out_w, blk.cross_out_b,
+                                 n_heads, static_cast<int>(hidden), i, T_enc, use_flash);
             x = ggml_add(ctx, x, cross_out);
         }
 
         // Pre-LN FFN.
         {
-            ggml_tensor * x_norm = layer_norm(ctx, x,
-                                              blk.norm_ff_w, blk.norm_ff_b);
-            ggml_tensor * ff = ggml_mul_mat(ctx, blk.ff_in_w, x_norm);
-            if (blk.ff_in_b != nullptr) ff = ggml_add(ctx, ff, blk.ff_in_b);
+            ggml_tensor * x_norm = layer_norm(ctx, x, blk.norm_ff_w, blk.norm_ff_b);
+            ggml_tensor * ff     = ggml_mul_mat(ctx, blk.ff_in_w, x_norm);
+            if (blk.ff_in_b != nullptr) {
+                ff = ggml_add(ctx, ff, blk.ff_in_b);
+            }
             if (hp.dec_activation == "relu") {
                 ff = ggml_relu(ctx, ff);
             } else {
                 ff = ggml_silu(ctx, ff);
             }
             ff = ggml_mul_mat(ctx, blk.ff_out_w, ff);
-            if (blk.ff_out_b != nullptr) ff = ggml_add(ctx, ff, blk.ff_out_b);
+            if (blk.ff_out_b != nullptr) {
+                ff = ggml_add(ctx, ff, blk.ff_out_b);
+            }
             x = ggml_add(ctx, x, ff);
         }
 
@@ -767,8 +740,8 @@ DecoderBuild build_decoder_graph_kv(ggml_context *         ctx,
     }
 
     // Final LayerNorm.
-    x = layer_norm(ctx, x, w.dec_final.norm_w, w.dec_final.norm_b);
-    x = named(x, "dec.out_before_head");
+    x                        = layer_norm(ctx, x, w.dec_final.norm_w, w.dec_final.norm_b);
+    x                        = named(x, "dec.out_before_head");
     db.dumps.out_before_head = x;
 
     // Head: tied weight + bias + optional log-softmax.
@@ -785,7 +758,7 @@ DecoderBuild build_decoder_graph_kv(ggml_context *         ctx,
     if (hp.head_log_softmax && !skip_log_softmax) {
         logits = ggml_log(ctx, ggml_soft_max(ctx, logits));
     }
-    logits = named(logits, "dec.logits");
+    logits          = named(logits, "dec.logits");
     db.dumps.logits = logits;
 
     db.out = logits;
@@ -797,14 +770,10 @@ DecoderBuild build_decoder_graph_kv(ggml_context *         ctx,
     if (skip_log_softmax) {
         ggml_tensor * last_logits = logits;
         if (n_tokens > 1) {
-            const int64_t vocab = logits->ne[0];
-            const size_t  row_bytes =
-                ggml_element_size(logits) * vocab;
-            last_logits = ggml_view_2d(ctx, logits,
-                                       vocab, /*n=*/1,
-                                       row_bytes,
-                                       row_bytes * (n_tokens - 1));
-            last_logits = ggml_cont(ctx, last_logits);
+            const int64_t vocab     = logits->ne[0];
+            const size_t  row_bytes = ggml_element_size(logits) * vocab;
+            last_logits             = ggml_view_2d(ctx, logits, vocab, /*n=*/1, row_bytes, row_bytes * (n_tokens - 1));
+            last_logits             = ggml_cont(ctx, last_logits);
         }
         db.argmax_out = ggml_argmax(ctx, last_logits);
         ggml_set_name(db.argmax_out, "dec.argmax");
@@ -818,27 +787,23 @@ DecoderBuild build_decoder_graph_kv(ggml_context *         ctx,
 }
 
 // Static-topology single-token step graph (GPU dispatch path).
-StepBuild build_step_graph(ggml_context *         ctx,
-                           const CohereWeights &  w,
-                           const CohereHParams &  hp,
-                           CohereKvCache &        kv_cache,
-                           int                    max_n_kv,
-                           int                    T_enc,
-                           bool                   use_flash)
-{
-    StepBuild sb {};
+StepBuild build_step_graph(ggml_context *        ctx,
+                           const CohereWeights & w,
+                           const CohereHParams & hp,
+                           CohereKvCache &       kv_cache,
+                           int                   max_n_kv,
+                           int                   T_enc,
+                           bool                  use_flash) {
+    StepBuild sb{};
     sb.max_n_kv = max_n_kv;
 
     if (ctx == nullptr || max_n_kv <= 0 || T_enc <= 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "cohere step: invalid arg (max_n_kv=%d, T_enc=%d)",
-                     max_n_kv, T_enc);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "cohere step: invalid arg (max_n_kv=%d, T_enc=%d)", max_n_kv, T_enc);
         return sb;
     }
     if (max_n_kv > kv_cache.n_ctx) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "cohere step: max_n_kv=%d exceeds kv_cache.n_ctx=%d",
-                     max_n_kv, kv_cache.n_ctx);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "cohere step: max_n_kv=%d exceeds kv_cache.n_ctx=%d", max_n_kv,
+                kv_cache.n_ctx);
         return sb;
     }
 
@@ -869,8 +834,8 @@ StepBuild build_step_graph(ggml_context *         ctx,
 
     ggml_tensor * tok_emb = ggml_get_rows(ctx, w.dec_embed.token_w, sb.token_id_in);
     ggml_tensor * pos_emb = ggml_get_rows(ctx, w.dec_embed.pos_enc, sb.pos_id_in);
-    ggml_tensor * x = ggml_add(ctx, tok_emb, pos_emb);
-    x = layer_norm(ctx, x, w.dec_embed.norm_w, w.dec_embed.norm_b);
+    ggml_tensor * x       = ggml_add(ctx, tok_emb, pos_emb);
+    x                     = layer_norm(ctx, x, w.dec_embed.norm_w, w.dec_embed.norm_b);
 
     for (int i = 0; i < hp.dec_n_layers; ++i) {
         const auto & blk = w.dec_blocks[i];
@@ -878,15 +843,10 @@ StepBuild build_step_graph(ggml_context *         ctx,
         // Pre-LN self-attention with set_rows-based KV write.
         {
             ggml_tensor * x_norm = layer_norm(ctx, x, blk.norm_self_w, blk.norm_self_b);
-            ggml_tensor * self_out = mha_self_step(
-                ctx, sb.graph, x_norm, kv_cache, sb.mask_in, sb.kv_idx_in,
-                blk.self_q_w, blk.self_q_b,
-                blk.self_k_w, blk.self_k_b,
-                blk.self_v_w, blk.self_v_b,
-                blk.self_out_w, blk.self_out_b,
-                n_heads, static_cast<int>(hidden),
-                i, max_n_kv,
-                use_flash);
+            ggml_tensor * self_out =
+                mha_self_step(ctx, sb.graph, x_norm, kv_cache, sb.mask_in, sb.kv_idx_in, blk.self_q_w, blk.self_q_b,
+                              blk.self_k_w, blk.self_k_b, blk.self_v_w, blk.self_v_b, blk.self_out_w, blk.self_out_b,
+                              n_heads, static_cast<int>(hidden), i, max_n_kv, use_flash);
             x = ggml_add(ctx, x, self_out);
         }
 
@@ -894,28 +854,28 @@ StepBuild build_step_graph(ggml_context *         ctx,
         // are pre-populated full T_enc, no n_past dependency.
         {
             ggml_tensor * x_norm = layer_norm(ctx, x, blk.norm_cross_w, blk.norm_cross_b);
-            ggml_tensor * cross_out = mha_cross_cached(
-                ctx, x_norm, kv_cache,
-                blk.cross_q_w, blk.cross_q_b,
-                blk.cross_out_w, blk.cross_out_b,
-                n_heads, static_cast<int>(hidden),
-                i, T_enc,
-                use_flash);
+            ggml_tensor * cross_out =
+                mha_cross_cached(ctx, x_norm, kv_cache, blk.cross_q_w, blk.cross_q_b, blk.cross_out_w, blk.cross_out_b,
+                                 n_heads, static_cast<int>(hidden), i, T_enc, use_flash);
             x = ggml_add(ctx, x, cross_out);
         }
 
         // Pre-LN FFN.
         {
             ggml_tensor * x_norm = layer_norm(ctx, x, blk.norm_ff_w, blk.norm_ff_b);
-            ggml_tensor * ff = ggml_mul_mat(ctx, blk.ff_in_w, x_norm);
-            if (blk.ff_in_b != nullptr) ff = ggml_add(ctx, ff, blk.ff_in_b);
+            ggml_tensor * ff     = ggml_mul_mat(ctx, blk.ff_in_w, x_norm);
+            if (blk.ff_in_b != nullptr) {
+                ff = ggml_add(ctx, ff, blk.ff_in_b);
+            }
             if (hp.dec_activation == "relu") {
                 ff = ggml_relu(ctx, ff);
             } else {
                 ff = ggml_silu(ctx, ff);
             }
             ff = ggml_mul_mat(ctx, blk.ff_out_w, ff);
-            if (blk.ff_out_b != nullptr) ff = ggml_add(ctx, ff, blk.ff_out_b);
+            if (blk.ff_out_b != nullptr) {
+                ff = ggml_add(ctx, ff, blk.ff_out_b);
+            }
             x = ggml_add(ctx, x, ff);
         }
     }
@@ -942,118 +902,136 @@ namespace {
 // Batched self-attention step. x: [hidden, B] (one token per utterance).
 // Mirrors mha_self_step but threads an utterance batch on the trailing
 // flash axis (ne[3]); KV slab per (layer) is [hidden, n_ctx, B].
-ggml_tensor * mha_self_step_batched(
-    ggml_context * ctx, ggml_cgraph * gf,
-    ggml_tensor * x, CohereKvCache & kv_cache,
-    ggml_tensor * mask, ggml_tensor * kv_idx,
-    ggml_tensor * q_w, ggml_tensor * q_b,
-    ggml_tensor * k_w, ggml_tensor * k_b,
-    ggml_tensor * v_w, ggml_tensor * v_b,
-    ggml_tensor * out_w, ggml_tensor * out_b,
-    int n_heads, int hidden, int il, int max_n_kv, int B)
-{
-    const int head_dim = hidden / n_heads;
-    const float scale  = 1.0f / std::sqrt(static_cast<float>(head_dim));
-    const int64_t n_ctx = kv_cache.n_ctx;
-    const size_t k_elem = ggml_element_size(kv_cache.self_k);
-    const size_t v_elem = ggml_element_size(kv_cache.self_v);
+ggml_tensor * mha_self_step_batched(ggml_context *  ctx,
+                                    ggml_cgraph *   gf,
+                                    ggml_tensor *   x,
+                                    CohereKvCache & kv_cache,
+                                    ggml_tensor *   mask,
+                                    ggml_tensor *   kv_idx,
+                                    ggml_tensor *   q_w,
+                                    ggml_tensor *   q_b,
+                                    ggml_tensor *   k_w,
+                                    ggml_tensor *   k_b,
+                                    ggml_tensor *   v_w,
+                                    ggml_tensor *   v_b,
+                                    ggml_tensor *   out_w,
+                                    ggml_tensor *   out_b,
+                                    int             n_heads,
+                                    int             hidden,
+                                    int             il,
+                                    int             max_n_kv,
+                                    int             B) {
+    const int     head_dim = hidden / n_heads;
+    const float   scale    = 1.0f / std::sqrt(static_cast<float>(head_dim));
+    const int64_t n_ctx    = kv_cache.n_ctx;
+    const size_t  k_elem   = ggml_element_size(kv_cache.self_k);
+    const size_t  v_elem   = ggml_element_size(kv_cache.self_v);
 
     ggml_tensor * Qcur = ggml_mul_mat(ctx, q_w, x);
-    if (q_b != nullptr) Qcur = ggml_add(ctx, Qcur, q_b);
+    if (q_b != nullptr) {
+        Qcur = ggml_add(ctx, Qcur, q_b);
+    }
     ggml_tensor * Kcur = ggml_mul_mat(ctx, k_w, x);
-    if (k_b != nullptr) Kcur = ggml_add(ctx, Kcur, k_b);
+    if (k_b != nullptr) {
+        Kcur = ggml_add(ctx, Kcur, k_b);
+    }
     ggml_tensor * Vcur = ggml_mul_mat(ctx, v_w, x);
-    if (v_b != nullptr) Vcur = ggml_add(ctx, Vcur, v_b);
+    if (v_b != nullptr) {
+        Vcur = ggml_add(ctx, Vcur, v_b);
+    }
 
     ggml_tensor * Q = ggml_reshape_3d(ctx, Qcur, head_dim, n_heads, B);
 
     // KV write: per-layer slab [hidden, n_ctx, B]; one set_rows writes B
     // rows at B independent indices kv_idx[b].
     {
-        const size_t layer_off_k =
-            k_elem * static_cast<size_t>(il) * n_ctx * hidden * B;
-        const size_t layer_off_v =
-            v_elem * static_cast<size_t>(il) * n_ctx * hidden * B;
-        ggml_tensor * k_layer = ggml_view_3d(ctx, kv_cache.self_k,
-            hidden, n_ctx, B, k_elem * hidden, k_elem * hidden * n_ctx, layer_off_k);
-        ggml_tensor * v_layer = ggml_view_3d(ctx, kv_cache.self_v,
-            hidden, n_ctx, B, v_elem * hidden, v_elem * hidden * n_ctx, layer_off_v);
+        const size_t  layer_off_k = k_elem * static_cast<size_t>(il) * n_ctx * hidden * B;
+        const size_t  layer_off_v = v_elem * static_cast<size_t>(il) * n_ctx * hidden * B;
+        ggml_tensor * k_layer =
+            ggml_view_3d(ctx, kv_cache.self_k, hidden, n_ctx, B, k_elem * hidden, k_elem * hidden * n_ctx, layer_off_k);
+        ggml_tensor * v_layer =
+            ggml_view_3d(ctx, kv_cache.self_v, hidden, n_ctx, B, v_elem * hidden, v_elem * hidden * n_ctx, layer_off_v);
         ggml_tensor * K_row = ggml_reshape_3d(ctx, Kcur, hidden, 1, B);
         ggml_tensor * V_row = ggml_reshape_3d(ctx, Vcur, hidden, 1, B);
         ggml_build_forward_expand(gf, ggml_set_rows(ctx, k_layer, K_row, kv_idx));
         ggml_build_forward_expand(gf, ggml_set_rows(ctx, v_layer, V_row, kv_idx));
     }
 
-    const size_t layer_off_k =
-        k_elem * static_cast<size_t>(il) * n_ctx * hidden * B;
-    const size_t layer_off_v =
-        v_elem * static_cast<size_t>(il) * n_ctx * hidden * B;
-    ggml_tensor * K = ggml_view_4d(ctx, kv_cache.self_k,
-        head_dim, max_n_kv, n_heads, B,
-        k_elem * hidden, k_elem * head_dim, k_elem * hidden * n_ctx, layer_off_k);
-    ggml_tensor * V = ggml_view_4d(ctx, kv_cache.self_v,
-        head_dim, max_n_kv, n_heads, B,
-        v_elem * hidden, v_elem * head_dim, v_elem * hidden * n_ctx, layer_off_v);
+    const size_t  layer_off_k = k_elem * static_cast<size_t>(il) * n_ctx * hidden * B;
+    const size_t  layer_off_v = v_elem * static_cast<size_t>(il) * n_ctx * hidden * B;
+    ggml_tensor * K           = ggml_view_4d(ctx, kv_cache.self_k, head_dim, max_n_kv, n_heads, B, k_elem * hidden,
+                                             k_elem * head_dim, k_elem * hidden * n_ctx, layer_off_k);
+    ggml_tensor * V           = ggml_view_4d(ctx, kv_cache.self_v, head_dim, max_n_kv, n_heads, B, v_elem * hidden,
+                                             v_elem * head_dim, v_elem * hidden * n_ctx, layer_off_v);
 
     // Q [head_dim, n_heads, B] -> [head_dim, 1, n_heads, B] for flash.
     ggml_tensor * Q_att = ggml_cont(ctx, ggml_permute(ctx, Q, 0, 2, 3, 1));
-    ggml_tensor * o = ggml_flash_attn_ext(ctx, Q_att, K, V, mask, scale, 0.0f, 0.0f);
-    o = ggml_reshape_2d(ctx, o, hidden, B);
+    ggml_tensor * o     = ggml_flash_attn_ext(ctx, Q_att, K, V, mask, scale, 0.0f, 0.0f);
+    o                   = ggml_reshape_2d(ctx, o, hidden, B);
 
     o = ggml_mul_mat(ctx, out_w, o);
-    if (out_b != nullptr) o = ggml_add(ctx, o, out_b);
+    if (out_b != nullptr) {
+        o = ggml_add(ctx, o, out_b);
+    }
     return o;
 }
 
 // Batched cross-attention step. x: [hidden, B]; reads cross slab
 // [hidden, T_enc_max, B] per layer with a per-utterance cross-pad mask.
-ggml_tensor * mha_cross_step_batched(
-    ggml_context * ctx, ggml_tensor * x, CohereKvCache & kv_cache,
-    ggml_tensor * cross_mask,
-    ggml_tensor * q_w, ggml_tensor * q_b,
-    ggml_tensor * out_w, ggml_tensor * out_b,
-    int n_heads, int hidden, int il, int T_enc_max, int B)
-{
-    const int head_dim = hidden / n_heads;
-    const float scale  = 1.0f / std::sqrt(static_cast<float>(head_dim));
-    const size_t k_elem = ggml_element_size(kv_cache.cross_k);
-    const size_t v_elem = ggml_element_size(kv_cache.cross_v);
+ggml_tensor * mha_cross_step_batched(ggml_context *  ctx,
+                                     ggml_tensor *   x,
+                                     CohereKvCache & kv_cache,
+                                     ggml_tensor *   cross_mask,
+                                     ggml_tensor *   q_w,
+                                     ggml_tensor *   q_b,
+                                     ggml_tensor *   out_w,
+                                     ggml_tensor *   out_b,
+                                     int             n_heads,
+                                     int             hidden,
+                                     int             il,
+                                     int             T_enc_max,
+                                     int             B) {
+    const int    head_dim = hidden / n_heads;
+    const float  scale    = 1.0f / std::sqrt(static_cast<float>(head_dim));
+    const size_t k_elem   = ggml_element_size(kv_cache.cross_k);
+    const size_t v_elem   = ggml_element_size(kv_cache.cross_v);
 
     ggml_tensor * Qcur = ggml_mul_mat(ctx, q_w, x);
-    if (q_b != nullptr) Qcur = ggml_add(ctx, Qcur, q_b);
-    ggml_tensor * Q = ggml_reshape_3d(ctx, Qcur, head_dim, n_heads, B);
+    if (q_b != nullptr) {
+        Qcur = ggml_add(ctx, Qcur, q_b);
+    }
+    ggml_tensor * Q     = ggml_reshape_3d(ctx, Qcur, head_dim, n_heads, B);
     ggml_tensor * Q_att = ggml_cont(ctx, ggml_permute(ctx, Q, 0, 2, 3, 1));
 
-    const size_t layer_off_k =
-        k_elem * static_cast<size_t>(il) * T_enc_max * hidden * B;
-    const size_t layer_off_v =
-        v_elem * static_cast<size_t>(il) * T_enc_max * hidden * B;
-    ggml_tensor * K = ggml_view_4d(ctx, kv_cache.cross_k,
-        head_dim, T_enc_max, n_heads, B,
-        k_elem * hidden, k_elem * head_dim, k_elem * hidden * T_enc_max, layer_off_k);
-    ggml_tensor * V = ggml_view_4d(ctx, kv_cache.cross_v,
-        head_dim, T_enc_max, n_heads, B,
-        v_elem * hidden, v_elem * head_dim, v_elem * hidden * T_enc_max, layer_off_v);
+    const size_t  layer_off_k = k_elem * static_cast<size_t>(il) * T_enc_max * hidden * B;
+    const size_t  layer_off_v = v_elem * static_cast<size_t>(il) * T_enc_max * hidden * B;
+    ggml_tensor * K           = ggml_view_4d(ctx, kv_cache.cross_k, head_dim, T_enc_max, n_heads, B, k_elem * hidden,
+                                             k_elem * head_dim, k_elem * hidden * T_enc_max, layer_off_k);
+    ggml_tensor * V           = ggml_view_4d(ctx, kv_cache.cross_v, head_dim, T_enc_max, n_heads, B, v_elem * hidden,
+                                             v_elem * head_dim, v_elem * hidden * T_enc_max, layer_off_v);
 
     ggml_tensor * o = ggml_flash_attn_ext(ctx, Q_att, K, V, cross_mask, scale, 0.0f, 0.0f);
-    o = ggml_reshape_2d(ctx, o, hidden, B);
+    o               = ggml_reshape_2d(ctx, o, hidden, B);
 
     o = ggml_mul_mat(ctx, out_w, o);
-    if (out_b != nullptr) o = ggml_add(ctx, o, out_b);
+    if (out_b != nullptr) {
+        o = ggml_add(ctx, o, out_b);
+    }
     return o;
 }
 
-} // namespace
+}  // namespace
 
-DecoderBuild build_cross_kv_graph_batched(ggml_context *         ctx,
-                                          const CohereWeights &  w,
-                                          const CohereHParams &  hp,
-                                          CohereKvCache &        kv_cache,
-                                          int                    T_enc_max,
-                                          int                    n_batch)
-{
-    DecoderBuild db {};
-    if (ctx == nullptr || T_enc_max <= 0 || n_batch <= 0) return db;
+DecoderBuild build_cross_kv_graph_batched(ggml_context *        ctx,
+                                          const CohereWeights & w,
+                                          const CohereHParams & hp,
+                                          CohereKvCache &       kv_cache,
+                                          int                   T_enc_max,
+                                          int                   n_batch) {
+    DecoderBuild db{};
+    if (ctx == nullptr || T_enc_max <= 0 || n_batch <= 0) {
+        return db;
+    }
 
     const int64_t hidden = hp.dec_hidden;
     const int     B      = n_batch;
@@ -1063,7 +1041,9 @@ DecoderBuild build_cross_kv_graph_batched(ggml_context *         ctx,
     ggml_set_input(db.encoder_out_in);
 
     db.graph = ggml_new_graph_custom(ctx, 8192, false);
-    if (db.graph == nullptr) return db;
+    if (db.graph == nullptr) {
+        return db;
+    }
 
     const size_t k_elem = ggml_element_size(kv_cache.cross_k);
     const size_t v_elem = ggml_element_size(kv_cache.cross_v);
@@ -1072,19 +1052,21 @@ DecoderBuild build_cross_kv_graph_batched(ggml_context *         ctx,
         const auto & blk = w.dec_blocks[il];
 
         ggml_tensor * Kc = ggml_mul_mat(ctx, blk.cross_k_w, db.encoder_out_in);
-        if (blk.cross_k_b != nullptr) Kc = ggml_add(ctx, Kc, blk.cross_k_b);
+        if (blk.cross_k_b != nullptr) {
+            Kc = ggml_add(ctx, Kc, blk.cross_k_b);
+        }
         ggml_tensor * Vc = ggml_mul_mat(ctx, blk.cross_v_w, db.encoder_out_in);
-        if (blk.cross_v_b != nullptr) Vc = ggml_add(ctx, Vc, blk.cross_v_b);
+        if (blk.cross_v_b != nullptr) {
+            Vc = ggml_add(ctx, Vc, blk.cross_v_b);
+        }
         // Kc/Vc: [hidden, T_enc_max, B].
 
-        const size_t off_k =
-            k_elem * static_cast<size_t>(il) * T_enc_max * hidden * B;
-        const size_t off_v =
-            v_elem * static_cast<size_t>(il) * T_enc_max * hidden * B;
-        ggml_tensor * k_dst = ggml_view_3d(ctx, kv_cache.cross_k,
-            hidden, T_enc_max, B, k_elem * hidden, k_elem * hidden * T_enc_max, off_k);
-        ggml_tensor * v_dst = ggml_view_3d(ctx, kv_cache.cross_v,
-            hidden, T_enc_max, B, v_elem * hidden, v_elem * hidden * T_enc_max, off_v);
+        const size_t  off_k = k_elem * static_cast<size_t>(il) * T_enc_max * hidden * B;
+        const size_t  off_v = v_elem * static_cast<size_t>(il) * T_enc_max * hidden * B;
+        ggml_tensor * k_dst = ggml_view_3d(ctx, kv_cache.cross_k, hidden, T_enc_max, B, k_elem * hidden,
+                                           k_elem * hidden * T_enc_max, off_k);
+        ggml_tensor * v_dst = ggml_view_3d(ctx, kv_cache.cross_v, hidden, T_enc_max, B, v_elem * hidden,
+                                           v_elem * hidden * T_enc_max, off_v);
         ggml_build_forward_expand(db.graph, ggml_cpy(ctx, Kc, k_dst));
         ggml_build_forward_expand(db.graph, ggml_cpy(ctx, Vc, v_dst));
     }
@@ -1098,12 +1080,13 @@ StepBuildBatched build_step_graph_batched(ggml_context *        ctx,
                                           int                   max_n_kv,
                                           int                   T_enc_max,
                                           int                   n_batch,
-                                          bool                  use_flash)
-{
-    StepBuildBatched sb {};
+                                          bool                  use_flash) {
+    StepBuildBatched sb{};
     sb.max_n_kv = max_n_kv;
     sb.n_batch  = n_batch;
-    if (ctx == nullptr || max_n_kv <= 0 || T_enc_max <= 0 || n_batch <= 0) return sb;
+    if (ctx == nullptr || max_n_kv <= 0 || T_enc_max <= 0 || n_batch <= 0) {
+        return sb;
+    }
     if (!use_flash) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "cohere step(batched): requires flash path");
         return sb;
@@ -1114,58 +1097,69 @@ StepBuildBatched build_step_graph_batched(ggml_context *        ctx,
     const int     B       = n_batch;
 
     sb.token_ids_in = ggml_new_tensor_1d(ctx, GGML_TYPE_I32, B);
-    ggml_set_name(sb.token_ids_in, "step.token_ids"); ggml_set_input(sb.token_ids_in);
+    ggml_set_name(sb.token_ids_in, "step.token_ids");
+    ggml_set_input(sb.token_ids_in);
     sb.pos_ids_in = ggml_new_tensor_1d(ctx, GGML_TYPE_I32, B);
-    ggml_set_name(sb.pos_ids_in, "step.pos_ids"); ggml_set_input(sb.pos_ids_in);
+    ggml_set_name(sb.pos_ids_in, "step.pos_ids");
+    ggml_set_input(sb.pos_ids_in);
     sb.kv_idx_in = ggml_new_tensor_2d(ctx, GGML_TYPE_I64, 1, B);
-    ggml_set_name(sb.kv_idx_in, "step.kv_idx"); ggml_set_input(sb.kv_idx_in);
+    ggml_set_name(sb.kv_idx_in, "step.kv_idx");
+    ggml_set_input(sb.kv_idx_in);
     sb.self_mask_in = ggml_new_tensor_4d(ctx, GGML_TYPE_F16, max_n_kv, 1, 1, B);
-    ggml_set_name(sb.self_mask_in, "step.self_mask"); ggml_set_input(sb.self_mask_in);
+    ggml_set_name(sb.self_mask_in, "step.self_mask");
+    ggml_set_input(sb.self_mask_in);
     sb.cross_mask_in = ggml_new_tensor_4d(ctx, GGML_TYPE_F16, T_enc_max, 1, 1, B);
-    ggml_set_name(sb.cross_mask_in, "step.cross_mask"); ggml_set_input(sb.cross_mask_in);
+    ggml_set_name(sb.cross_mask_in, "step.cross_mask");
+    ggml_set_input(sb.cross_mask_in);
 
     sb.graph = ggml_new_graph_custom(ctx, 16384, false);
-    if (sb.graph == nullptr) return sb;
+    if (sb.graph == nullptr) {
+        return sb;
+    }
 
     // Embedding: get_rows over B token ids -> [hidden, B].
     ggml_tensor * tok_emb = ggml_get_rows(ctx, w.dec_embed.token_w, sb.token_ids_in);
     ggml_tensor * pos_emb = ggml_get_rows(ctx, w.dec_embed.pos_enc, sb.pos_ids_in);
-    ggml_tensor * x = ggml_add(ctx, tok_emb, pos_emb);
-    x = layer_norm(ctx, x, w.dec_embed.norm_w, w.dec_embed.norm_b);
+    ggml_tensor * x       = ggml_add(ctx, tok_emb, pos_emb);
+    x                     = layer_norm(ctx, x, w.dec_embed.norm_w, w.dec_embed.norm_b);
 
     for (int i = 0; i < hp.dec_n_layers; ++i) {
         const auto & blk = w.dec_blocks[i];
         {
             ggml_tensor * xn = layer_norm(ctx, x, blk.norm_self_w, blk.norm_self_b);
-            ggml_tensor * so = mha_self_step_batched(
-                ctx, sb.graph, xn, kv_cache, sb.self_mask_in, sb.kv_idx_in,
-                blk.self_q_w, blk.self_q_b, blk.self_k_w, blk.self_k_b,
-                blk.self_v_w, blk.self_v_b, blk.self_out_w, blk.self_out_b,
-                n_heads, static_cast<int>(hidden), i, max_n_kv, B);
-            x = ggml_add(ctx, x, so);
+            ggml_tensor * so = mha_self_step_batched(ctx, sb.graph, xn, kv_cache, sb.self_mask_in, sb.kv_idx_in,
+                                                     blk.self_q_w, blk.self_q_b, blk.self_k_w, blk.self_k_b,
+                                                     blk.self_v_w, blk.self_v_b, blk.self_out_w, blk.self_out_b,
+                                                     n_heads, static_cast<int>(hidden), i, max_n_kv, B);
+            x                = ggml_add(ctx, x, so);
         }
         {
             ggml_tensor * xn = layer_norm(ctx, x, blk.norm_cross_w, blk.norm_cross_b);
-            ggml_tensor * co = mha_cross_step_batched(
-                ctx, xn, kv_cache, sb.cross_mask_in,
-                blk.cross_q_w, blk.cross_q_b, blk.cross_out_w, blk.cross_out_b,
-                n_heads, static_cast<int>(hidden), i, T_enc_max, B);
-            x = ggml_add(ctx, x, co);
+            ggml_tensor * co = mha_cross_step_batched(ctx, xn, kv_cache, sb.cross_mask_in, blk.cross_q_w, blk.cross_q_b,
+                                                      blk.cross_out_w, blk.cross_out_b, n_heads,
+                                                      static_cast<int>(hidden), i, T_enc_max, B);
+            x                = ggml_add(ctx, x, co);
         }
         {
             ggml_tensor * xn = layer_norm(ctx, x, blk.norm_ff_w, blk.norm_ff_b);
             ggml_tensor * ff = ggml_mul_mat(ctx, blk.ff_in_w, xn);
-            if (blk.ff_in_b != nullptr) ff = ggml_add(ctx, ff, blk.ff_in_b);
+            if (blk.ff_in_b != nullptr) {
+                ff = ggml_add(ctx, ff, blk.ff_in_b);
+            }
             ff = (hp.dec_activation == "relu") ? ggml_relu(ctx, ff) : ggml_silu(ctx, ff);
             ff = ggml_mul_mat(ctx, blk.ff_out_w, ff);
-            if (blk.ff_out_b != nullptr) ff = ggml_add(ctx, ff, blk.ff_out_b);
+            if (blk.ff_out_b != nullptr) {
+                ff = ggml_add(ctx, ff, blk.ff_out_b);
+            }
             x = ggml_add(ctx, x, ff);
         }
     }
 
-    x = layer_norm(ctx, x, w.dec_final.norm_w, w.dec_final.norm_b);
+    x                    = layer_norm(ctx, x, w.dec_final.norm_w, w.dec_final.norm_b);
     ggml_tensor * logits = ggml_mul_mat(ctx, w.dec_embed.token_w, x);  // [vocab, B]
-    if (w.head.bias != nullptr) logits = ggml_add(ctx, logits, w.head.bias);
+    if (w.head.bias != nullptr) {
+        logits = ggml_add(ctx, logits, w.head.bias);
+    }
 
     sb.argmax_out = ggml_argmax(ctx, logits);  // [B]
     ggml_set_name(sb.argmax_out, "step.argmax");
@@ -1174,4 +1168,4 @@ StepBuildBatched build_step_graph_batched(ggml_context *        ctx,
     return sb;
 }
 
-} // namespace transcribe::cohere
+}  // namespace transcribe::cohere
diff --git a/src/arch/cohere/decoder.h b/src/arch/cohere/decoder.h
index 2908d038..05b75898 100644
--- a/src/arch/cohere/decoder.h
+++ b/src/arch/cohere/decoder.h
@@ -45,10 +45,10 @@ struct DecoderBuild {
     ggml_tensor * encoder_out_in = nullptr;  // [dec_hidden, T_enc] f32
 
     // Output.
-    ggml_tensor * out = nullptr;  // logits [vocab_size, seq_len]
+    ggml_tensor * out        = nullptr;  // logits [vocab_size, seq_len]
     ggml_tensor * argmax_out = nullptr;  // [seq_len] i32, set when skip_log_softmax
 
-    DecoderDumps dumps {};
+    DecoderDumps  dumps{};
     ggml_cgraph * graph = nullptr;
 };
 
@@ -57,21 +57,21 @@ struct DecoderBuild {
 //   seq_len:   number of prompt tokens.
 //   T_enc:     number of encoder frames (after enc-dec projection).
 //   use_flash: fused ggml_flash_attn_ext vs manual mul_mat path.
-DecoderBuild build_decoder_graph(ggml_context *         compute_ctx,
-                                 const CohereWeights &  weights,
-                                 const CohereHParams &  hp,
-                                 int                    seq_len,
-                                 int                    T_enc,
-                                 bool                   use_flash = true);
+DecoderBuild build_decoder_graph(ggml_context *        compute_ctx,
+                                 const CohereWeights & weights,
+                                 const CohereHParams & hp,
+                                 int                   seq_len,
+                                 int                   T_enc,
+                                 bool                  use_flash = true);
 
 // Compute cross-attention K/V for all decoder layers from encoder_out
 // (an input) into kv_cache.cross_k / cross_v via ggml_cpy. Run once per
 // utterance. Returns a DecoderBuild with only .encoder_out_in and .graph set.
-DecoderBuild build_cross_kv_graph(ggml_context *         compute_ctx,
-                                  const CohereWeights &  weights,
-                                  const CohereHParams &  hp,
-                                  CohereKvCache &        kv_cache,
-                                  int                    T_enc);
+DecoderBuild build_cross_kv_graph(ggml_context *        compute_ctx,
+                                  const CohereWeights & weights,
+                                  const CohereHParams & hp,
+                                  CohereKvCache &       kv_cache,
+                                  int                   T_enc);
 
 // KV-cached decoder graph for both prompt pass (n_tokens > 1) and step
 // pass (n_tokens = 1). Writes new self-K/V at position n_past via ggml_cpy,
@@ -79,15 +79,15 @@ DecoderBuild build_cross_kv_graph(ggml_context *         compute_ctx,
 // K/V, outputs logits for the new tokens only.
 //   n_past: tokens already in the self-attention KV cache (0 for prompt).
 //   T_enc:  number of encoder frames (cross-attention cache shape).
-DecoderBuild build_decoder_graph_kv(ggml_context *         compute_ctx,
-                                    const CohereWeights &  weights,
-                                    const CohereHParams &  hp,
-                                    CohereKvCache &        kv_cache,
-                                    int                    n_tokens,
-                                    int                    n_past,
-                                    int                    T_enc,
-                                    bool                   skip_log_softmax = false,
-                                    bool                   use_flash        = true);
+DecoderBuild build_decoder_graph_kv(ggml_context *        compute_ctx,
+                                    const CohereWeights & weights,
+                                    const CohereHParams & hp,
+                                    CohereKvCache &       kv_cache,
+                                    int                   n_tokens,
+                                    int                   n_past,
+                                    int                   T_enc,
+                                    bool                  skip_log_softmax = false,
+                                    bool                  use_flash        = true);
 
 // Static-topology single-token decoder graph, built once per utterance and
 // reused for every step. Independent of n_past: KV writes go via
@@ -104,13 +104,13 @@ struct StepBuild {
     ggml_cgraph * graph       = nullptr;
 };
 
-StepBuild build_step_graph(ggml_context *         compute_ctx,
-                           const CohereWeights &  weights,
-                           const CohereHParams &  hp,
-                           CohereKvCache &        kv_cache,
-                           int                    max_n_kv,
-                           int                    T_enc,
-                           bool                   use_flash = true);
+StepBuild build_step_graph(ggml_context *        compute_ctx,
+                           const CohereWeights & weights,
+                           const CohereHParams & hp,
+                           CohereKvCache &       kv_cache,
+                           int                   max_n_kv,
+                           int                   T_enc,
+                           bool                  use_flash = true);
 
 // ---------------------------------------------------------------------------
 // Offline batched decode (B utterances at once).
@@ -120,27 +120,27 @@ StepBuild build_step_graph(ggml_context *         compute_ctx,
 // (each utterance right-padded to T_enc_max); per-layer K/V written into
 // the batched cross cache slab (layer, b). Padded frames produce bias-only
 // K/V that the cross-pad mask discards at attention time.
-DecoderBuild build_cross_kv_graph_batched(ggml_context *         compute_ctx,
-                                          const CohereWeights &  weights,
-                                          const CohereHParams &  hp,
-                                          CohereKvCache &        kv_cache,
-                                          int                    T_enc_max,
-                                          int                    n_batch);
+DecoderBuild build_cross_kv_graph_batched(ggml_context *        compute_ctx,
+                                          const CohereWeights & weights,
+                                          const CohereHParams & hp,
+                                          CohereKvCache &       kv_cache,
+                                          int                   T_enc_max,
+                                          int                   n_batch);
 
 // Static-topology batched single-step graph for B utterances, reused for
 // both the prompt feed and generation: each call consumes one token per
 // utterance, writes self-KV at kv_idx[b], reads self-KV [0,max_n_kv)
 // (self_mask) + cross-KV [0,T_enc_max) (cross_mask).
 struct StepBuildBatched {
-    ggml_tensor * token_ids_in = nullptr;  // i32 [B]
-    ggml_tensor * pos_ids_in   = nullptr;  // i32 [B]
-    ggml_tensor * kv_idx_in    = nullptr;  // i64 [1, B]
-    ggml_tensor * self_mask_in = nullptr;  // f16 [max_n_kv, 1, 1, B]
-    ggml_tensor * cross_mask_in = nullptr; // f16 [T_enc_max, 1, 1, B]
-    ggml_tensor * argmax_out   = nullptr;  // i32 [B]
-    int           max_n_kv     = 0;
-    int           n_batch      = 0;
-    ggml_cgraph * graph        = nullptr;
+    ggml_tensor * token_ids_in  = nullptr;  // i32 [B]
+    ggml_tensor * pos_ids_in    = nullptr;  // i32 [B]
+    ggml_tensor * kv_idx_in     = nullptr;  // i64 [1, B]
+    ggml_tensor * self_mask_in  = nullptr;  // f16 [max_n_kv, 1, 1, B]
+    ggml_tensor * cross_mask_in = nullptr;  // f16 [T_enc_max, 1, 1, B]
+    ggml_tensor * argmax_out    = nullptr;  // i32 [B]
+    int           max_n_kv      = 0;
+    int           n_batch       = 0;
+    ggml_cgraph * graph         = nullptr;
 };
 
 StepBuildBatched build_step_graph_batched(ggml_context *        compute_ctx,
@@ -152,4 +152,4 @@ StepBuildBatched build_step_graph_batched(ggml_context *        compute_ctx,
                                           int                   n_batch,
                                           bool                  use_flash = true);
 
-} // namespace transcribe::cohere
+}  // namespace transcribe::cohere
diff --git a/src/arch/cohere/encoder.cpp b/src/arch/cohere/encoder.cpp
index a3911892..0b0819cc 100644
--- a/src/arch/cohere/encoder.cpp
+++ b/src/arch/cohere/encoder.cpp
@@ -7,13 +7,11 @@
 
 #include "encoder.h"
 
-#include "weights.h"
-
 #include "conformer/conformer.h"
+#include "ggml.h"
 #include "transcribe-debug.h"
 #include "transcribe-log.h"
-
-#include "ggml.h"
+#include "weights.h"
 
 #include <cstdio>
 #include <cstdlib>
@@ -29,24 +27,27 @@ namespace conf = transcribe::conformer;
 // (native kernels), im2col + mul_mat on Metal/CPU. See the ConvPolicy
 // comment in conformer.h for why the two dw sites share one detect result.
 bool detect_direct_dw(const char * backend) {
-    const bool backend_default = backend != nullptr &&
-        (std::strstr(backend, "Vulkan") != nullptr ||
-         std::strstr(backend, "CUDA")   != nullptr);
-    return conf::resolve_conv_direct("TRANSCRIBE_CONV_DIRECT_DW",
-                                     "TRANSCRIBE_CONV_NO_DIRECT_DW",
-                                     backend_default);
+    const bool backend_default =
+        backend != nullptr && (std::strstr(backend, "Vulkan") != nullptr || std::strstr(backend, "CUDA") != nullptr);
+    return conf::resolve_conv_direct("TRANSCRIBE_CONV_DIRECT_DW", "TRANSCRIBE_CONV_NO_DIRECT_DW", backend_default);
 }
 
 // ----- Views ------------------------------------------------------
 
 conf::PreEncodeView to_view(const CoherePreEncode & pe) {
     conf::PreEncodeView v;
-    v.conv0_w = pe.conv0_w; v.conv0_b = pe.conv0_b;
-    v.conv2_w = pe.conv2_w; v.conv2_b = pe.conv2_b;
-    v.conv3_w = pe.conv3_w; v.conv3_b = pe.conv3_b;
-    v.conv5_w = pe.conv5_w; v.conv5_b = pe.conv5_b;
-    v.conv6_w = pe.conv6_w; v.conv6_b = pe.conv6_b;
-    v.out_w   = pe.out_w;   v.out_b   = pe.out_b;
+    v.conv0_w = pe.conv0_w;
+    v.conv0_b = pe.conv0_b;
+    v.conv2_w = pe.conv2_w;
+    v.conv2_b = pe.conv2_b;
+    v.conv3_w = pe.conv3_w;
+    v.conv3_b = pe.conv3_b;
+    v.conv5_w = pe.conv5_w;
+    v.conv5_b = pe.conv5_b;
+    v.conv6_w = pe.conv6_w;
+    v.conv6_b = pe.conv6_b;
+    v.out_w   = pe.out_w;
+    v.out_b   = pe.out_b;
     return v;
 }
 
@@ -56,16 +57,22 @@ conf::BlockView to_view(const CohereBlock & b) {
     // FF1 (biases present).
     v.norm_ff1_w = b.norm_ff1_w;
     v.norm_ff1_b = b.norm_ff1_b;
-    v.ff1_lin1_w = b.ff1_lin1_w; v.ff1_lin1_b = b.ff1_lin1_b;
-    v.ff1_lin2_w = b.ff1_lin2_w; v.ff1_lin2_b = b.ff1_lin2_b;
+    v.ff1_lin1_w = b.ff1_lin1_w;
+    v.ff1_lin1_b = b.ff1_lin1_b;
+    v.ff1_lin2_w = b.ff1_lin2_w;
+    v.ff1_lin2_b = b.ff1_lin2_b;
 
     // Self-attention (biases on Q/K/V/out; pos projection is bias-free).
     v.norm_attn_w = b.norm_attn_w;
     v.norm_attn_b = b.norm_attn_b;
-    v.attn_q_w    = b.attn_q_w;   v.attn_q_b   = b.attn_q_b;
-    v.attn_k_w    = b.attn_k_w;   v.attn_k_b   = b.attn_k_b;
-    v.attn_v_w    = b.attn_v_w;   v.attn_v_b   = b.attn_v_b;
-    v.attn_out_w  = b.attn_out_w; v.attn_out_b = b.attn_out_b;
+    v.attn_q_w    = b.attn_q_w;
+    v.attn_q_b    = b.attn_q_b;
+    v.attn_k_w    = b.attn_k_w;
+    v.attn_k_b    = b.attn_k_b;
+    v.attn_v_w    = b.attn_v_w;
+    v.attn_v_b    = b.attn_v_b;
+    v.attn_out_w  = b.attn_out_w;
+    v.attn_out_b  = b.attn_out_b;
     v.attn_pos_w  = b.attn_pos_w;
     v.attn_pos_u  = b.attn_pos_u;
     v.attn_pos_v  = b.attn_pos_v;
@@ -73,72 +80,78 @@ conf::BlockView to_view(const CohereBlock & b) {
     // Conv module (biases on pw1/dw/pw2).
     v.norm_conv_w         = b.norm_conv_w;
     v.norm_conv_b         = b.norm_conv_b;
-    v.conv_pw1_w          = b.conv_pw1_w; v.conv_pw1_b = b.conv_pw1_b;
-    v.conv_dw_w           = b.conv_dw_w;  v.conv_dw_b  = b.conv_dw_b;
-    v.conv_pw2_w          = b.conv_pw2_w; v.conv_pw2_b = b.conv_pw2_b;
+    v.conv_pw1_w          = b.conv_pw1_w;
+    v.conv_pw1_b          = b.conv_pw1_b;
+    v.conv_dw_w           = b.conv_dw_w;
+    v.conv_dw_b           = b.conv_dw_b;
+    v.conv_pw2_w          = b.conv_pw2_w;
+    v.conv_pw2_b          = b.conv_pw2_b;
     v.conv_bn_fused_scale = b.conv_bn_fused_scale;
     v.conv_bn_fused_bias  = b.conv_bn_fused_bias;
 
     // FF2 (biases present).
     v.norm_ff2_w = b.norm_ff2_w;
     v.norm_ff2_b = b.norm_ff2_b;
-    v.ff2_lin1_w = b.ff2_lin1_w; v.ff2_lin1_b = b.ff2_lin1_b;
-    v.ff2_lin2_w = b.ff2_lin2_w; v.ff2_lin2_b = b.ff2_lin2_b;
+    v.ff2_lin1_w = b.ff2_lin1_w;
+    v.ff2_lin1_b = b.ff2_lin1_b;
+    v.ff2_lin2_w = b.ff2_lin2_w;
+    v.ff2_lin2_b = b.ff2_lin2_b;
 
     v.norm_out_w = b.norm_out_w;
     v.norm_out_b = b.norm_out_b;
     return v;
 }
 
-} // namespace
-
-EncoderBuild build_encoder_graph(ggml_context *         ctx,
-                                 const CohereWeights &  w,
-                                 const CohereHParams &  hp,
-                                 int                    n_mel_frames,
-                                 ggml_type              kv_type,
-                                 bool                   use_flash,
-                                 const char *           backend_name)
-{
-    conf::ConvPolicy policy {};
+}  // namespace
+
+EncoderBuild build_encoder_graph(ggml_context *        ctx,
+                                 const CohereWeights & w,
+                                 const CohereHParams & hp,
+                                 int                   n_mel_frames,
+                                 ggml_type             kv_type,
+                                 bool                  use_flash,
+                                 const char *          backend_name) {
+    conf::ConvPolicy policy{};
     policy.direct_pw               = conf::detect_direct_pw(backend_name);
     const bool direct_dw           = detect_direct_dw(backend_name);
     policy.direct_dw_in_block      = direct_dw;
     policy.direct_dw_in_pre_encode = direct_dw;
 
-    EncoderBuild eb {};
+    EncoderBuild eb{};
 
     if (ctx == nullptr || n_mel_frames <= 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "cohere encoder: invalid arg "
-                     "(ctx=%p, n_mel_frames=%d)",
-                     static_cast<void *>(ctx), n_mel_frames);
+                "cohere encoder: invalid arg "
+                "(ctx=%p, n_mel_frames=%d)",
+                static_cast<void *>(ctx), n_mel_frames);
         return eb;
     }
 
     if (hp.enc_subsampling_factor != 8 || hp.fe_num_mels != 128) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "cohere encoder: unsupported geometry "
-                     "subsampling_factor=%d num_mels=%d "
-                     "(only 8/128 implemented)",
-                     hp.enc_subsampling_factor, hp.fe_num_mels);
+                "cohere encoder: unsupported geometry "
+                "subsampling_factor=%d num_mels=%d "
+                "(only 8/128 implemented)",
+                hp.enc_subsampling_factor, hp.fe_num_mels);
         return eb;
     }
 
     // Mel input handle.
-    eb.mel_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32,
-                                   n_mel_frames, hp.fe_num_mels);
-    if (eb.mel_in == nullptr) return eb;
+    eb.mel_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, n_mel_frames, hp.fe_num_mels);
+    if (eb.mel_in == nullptr) {
+        return eb;
+    }
     ggml_set_name(eb.mel_in, "mel.in");
     ggml_set_input(eb.mel_in);
     eb.dumps.mel_in = eb.mel_in;
 
     // Pre-encode.
-    ggml_tensor * x = conf::build_pre_encode(ctx, to_view(w.pre_encode),
-                                             eb.mel_in, policy,
+    ggml_tensor * x = conf::build_pre_encode(ctx, to_view(w.pre_encode), eb.mel_in, policy,
                                              /*name_prefix=*/"enc.pre_encode",
                                              /*error_tag=*/"cohere");
-    if (x == nullptr) return eb;
+    if (x == nullptr) {
+        return eb;
+    }
     eb.dumps.pre_encode_out = x;
     transcribe::debug::mark_tensor_for_dump(x);
 
@@ -148,13 +161,12 @@ EncoderBuild build_encoder_graph(ggml_context *         ctx,
 
         // Positional embedding input.
         const int64_t pos_len = 2 * T_enc - 1;
-        eb.pos_emb_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32,
-                                           hp.enc_d_model, pos_len);
+        eb.pos_emb_in         = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, hp.enc_d_model, pos_len);
         ggml_set_name(eb.pos_emb_in, "pos_emb.in");
         ggml_set_input(eb.pos_emb_in);
         eb.dumps.pos_emb = eb.pos_emb_in;
 
-        conf::BlockParams bparams {};
+        conf::BlockParams bparams{};
         bparams.d_model     = hp.enc_d_model;
         bparams.n_head      = hp.enc_n_heads;
         bparams.conv_kernel = hp.enc_conv_kernel;
@@ -164,22 +176,20 @@ EncoderBuild build_encoder_graph(ggml_context *         ctx,
 
         // Block 0 (named for the dump stream).
         {
-            x = conf::build_conformer_block(ctx, x, eb.pos_emb_in,
-                                            to_view(w.blocks[0]), bparams);
-            x = conf::named(x, "enc.block.0.out");
+            x                   = conf::build_conformer_block(ctx, x, eb.pos_emb_in, to_view(w.blocks[0]), bparams);
+            x                   = conf::named(x, "enc.block.0.out");
             eb.dumps.block0_out = x;
             transcribe::debug::mark_tensor_for_dump(x);
         }
 
         // Blocks 1..N-1.
         for (size_t i = 1; i < w.blocks.size(); ++i) {
-            x = conf::build_conformer_block(ctx, x, eb.pos_emb_in,
-                                            to_view(w.blocks[i]), bparams);
+            x = conf::build_conformer_block(ctx, x, eb.pos_emb_in, to_view(w.blocks[i]), bparams);
             // Spot-check at the middle block (n_layers/2 - 1).
             if (i == static_cast<size_t>(hp.enc_n_layers / 2 - 1)) {
                 char bname[64];
                 std::snprintf(bname, sizeof(bname), "enc.block.%zu.out", i);
-                x = conf::named(x, bname);
+                x                      = conf::named(x, bname);
                 eb.dumps.block_mid_out = x;
                 transcribe::debug::mark_tensor_for_dump(x);
             }
@@ -187,7 +197,7 @@ EncoderBuild build_encoder_graph(ggml_context *         ctx,
             if (i == w.blocks.size() - 1) {
                 char bname[64];
                 std::snprintf(bname, sizeof(bname), "enc.block.%zu.out", i);
-                x = conf::named(x, bname);
+                x                       = conf::named(x, bname);
                 eb.dumps.block_last_out = x;
                 transcribe::debug::mark_tensor_for_dump(x);
             }
@@ -195,14 +205,14 @@ EncoderBuild build_encoder_graph(ggml_context *         ctx,
     }
 
     eb.dumps.final_out = x;
-    x = conf::named(x, "enc.final");
+    x                  = conf::named(x, "enc.final");
     transcribe::debug::mark_tensor_for_dump(x);
 
     // Encoder-decoder projection (Cohere-specific, not in the shared block).
     {
-        ggml_tensor * proj = ggml_mul_mat(ctx, w.enc_dec_proj.weight, x);
-        proj = ggml_add(ctx, proj, w.enc_dec_proj.bias);
-        proj = conf::named(proj, "enc_dec_proj.out");
+        ggml_tensor * proj        = ggml_mul_mat(ctx, w.enc_dec_proj.weight, x);
+        proj                      = ggml_add(ctx, proj, w.enc_dec_proj.bias);
+        proj                      = conf::named(proj, "enc_dec_proj.out");
         eb.dumps.enc_dec_proj_out = proj;
         transcribe::debug::mark_tensor_for_dump(proj);
         x = proj;
@@ -215,8 +225,7 @@ EncoderBuild build_encoder_graph(ggml_context *         ctx,
     // large graph; 16384 leaves headroom.
     eb.graph = ggml_new_graph_custom(ctx, 16384, false);
     if (eb.graph == nullptr) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "cohere encoder: ggml_new_graph_custom failed");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "cohere encoder: ggml_new_graph_custom failed");
         return eb;
     }
     ggml_build_forward_expand(eb.graph, eb.out);
@@ -224,4 +233,4 @@ EncoderBuild build_encoder_graph(ggml_context *         ctx,
     return eb;
 }
 
-} // namespace transcribe::cohere
+}  // namespace transcribe::cohere
diff --git a/src/arch/cohere/encoder.h b/src/arch/cohere/encoder.h
index 2bf0bf0c..817c436b 100644
--- a/src/arch/cohere/encoder.h
+++ b/src/arch/cohere/encoder.h
@@ -18,30 +18,30 @@ struct CohereHParams;
 struct CohereWeights;
 
 struct EncoderDumps {
-    ggml_tensor * mel_in            = nullptr;
-    ggml_tensor * pre_encode_out    = nullptr;
-    ggml_tensor * pos_emb           = nullptr;
-    ggml_tensor * block0_out        = nullptr;
-    ggml_tensor * block_mid_out     = nullptr; // block 23 (middle of 48)
-    ggml_tensor * block_last_out    = nullptr; // block 47 (last)
-    ggml_tensor * final_out         = nullptr;
-    ggml_tensor * enc_dec_proj_out  = nullptr;
+    ggml_tensor * mel_in           = nullptr;
+    ggml_tensor * pre_encode_out   = nullptr;
+    ggml_tensor * pos_emb          = nullptr;
+    ggml_tensor * block0_out       = nullptr;
+    ggml_tensor * block_mid_out    = nullptr;  // block 23 (middle of 48)
+    ggml_tensor * block_last_out   = nullptr;  // block 47 (last)
+    ggml_tensor * final_out        = nullptr;
+    ggml_tensor * enc_dec_proj_out = nullptr;
 };
 
 struct EncoderBuild {
     ggml_tensor * mel_in     = nullptr;
     ggml_tensor * pos_emb_in = nullptr;
     ggml_tensor * out        = nullptr;  // after enc-dec projection
-    EncoderDumps  dumps {};
-    ggml_cgraph * graph      = nullptr;
+    EncoderDumps  dumps{};
+    ggml_cgraph * graph = nullptr;
 };
 
-EncoderBuild build_encoder_graph(ggml_context *         compute_ctx,
-                                 const CohereWeights &  weights,
-                                 const CohereHParams &  hp,
-                                 int                    n_mel_frames,
-                                 ggml_type              kv_type = GGML_TYPE_COUNT,
-                                 bool                   use_flash = true,
-                                 const char *           backend_name = "");
+EncoderBuild build_encoder_graph(ggml_context *        compute_ctx,
+                                 const CohereWeights & weights,
+                                 const CohereHParams & hp,
+                                 int                   n_mel_frames,
+                                 ggml_type             kv_type      = GGML_TYPE_COUNT,
+                                 bool                  use_flash    = true,
+                                 const char *          backend_name = "");
 
-} // namespace transcribe::cohere
+}  // namespace transcribe::cohere
diff --git a/src/arch/cohere/model.cpp b/src/arch/cohere/model.cpp
index bf8cb262..b631a579 100644
--- a/src/arch/cohere/model.cpp
+++ b/src/arch/cohere/model.cpp
@@ -6,11 +6,12 @@
 // on the ggml graph (not host-side like Parakeet's LSTM).
 
 #include "cohere.h"
-
 #include "decoder.h"
 #include "encoder.h"
-#include "weights.h"
-
+#include "ggml-alloc.h"
+#include "ggml-backend.h"
+#include "ggml.h"
+#include "gguf.h"
 #include "transcribe-arch.h"
 #include "transcribe-batch-util.h"
 #include "transcribe-debug.h"
@@ -21,11 +22,7 @@
 #include "transcribe-log.h"
 #include "transcribe-mel.h"
 #include "transcribe-meta.h"
-
-#include "ggml.h"
-#include "ggml-alloc.h"
-#include "ggml-backend.h"
-#include "gguf.h"
+#include "weights.h"
 
 #include <algorithm>
 #include <cmath>
@@ -46,7 +43,7 @@ namespace transcribe::cohere {
 
 extern const Arch arch;
 
-static_assert(std::is_base_of_v<transcribe_model,   CohereModel>);
+static_assert(std::is_base_of_v<transcribe_model, CohereModel>);
 static_assert(std::is_base_of_v<transcribe_session, CohereSession>);
 
 CohereSession::~CohereSession() {
@@ -68,19 +65,19 @@ bool kv_cache_init(CohereKvCache & cache,
                    int             T_enc,
                    int             n_state,
                    int             n_layer,
-                   ggml_type       kv_type)
-{
+                   ggml_type       kv_type) {
     if (kv_type != GGML_TYPE_F16 && kv_type != GGML_TYPE_F32) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "cohere kv_cache: unsupported kv_type=%d "
-                     "(only F16/F32)", static_cast<int>(kv_type));
+                "cohere kv_cache: unsupported kv_type=%d "
+                "(only F16/F32)",
+                static_cast<int>(kv_type));
         return false;
     }
 
     // Allocate 4 tensors: self K, self V, cross K, cross V.
     const size_t ctx_size = 4 * ggml_tensor_overhead() + 256;
 
-    ggml_init_params params {};
+    ggml_init_params params{};
     params.mem_size   = ctx_size;
     params.mem_buffer = nullptr;
     params.no_alloc   = true;
@@ -99,8 +96,8 @@ bool kv_cache_init(CohereKvCache & cache,
     cache.cross_k = ggml_new_tensor_1d(cache.ctx, kv_type, cross_elements);
     cache.cross_v = ggml_new_tensor_1d(cache.ctx, kv_type, cross_elements);
 
-    ggml_set_name(cache.self_k,  "kv_self_k");
-    ggml_set_name(cache.self_v,  "kv_self_v");
+    ggml_set_name(cache.self_k, "kv_self_k");
+    ggml_set_name(cache.self_v, "kv_self_v");
     ggml_set_name(cache.cross_k, "kv_cross_k");
     ggml_set_name(cache.cross_v, "kv_cross_v");
 
@@ -114,21 +111,19 @@ bool kv_cache_init(CohereKvCache & cache,
 
     ggml_backend_buffer_clear(cache.buffer, 0);
 
-    cache.n_ctx  = n_ctx;
-    cache.T_enc  = T_enc;
-    cache.n      = 0;
-    cache.head   = 0;
+    cache.n_ctx           = n_ctx;
+    cache.T_enc           = T_enc;
+    cache.n               = 0;
+    cache.head            = 0;
     cache.cross_populated = false;
 
     const size_t total_bytes =
-        ggml_nbytes(cache.self_k) + ggml_nbytes(cache.self_v) +
-        ggml_nbytes(cache.cross_k) + ggml_nbytes(cache.cross_v);
+        ggml_nbytes(cache.self_k) + ggml_nbytes(cache.self_v) + ggml_nbytes(cache.cross_k) + ggml_nbytes(cache.cross_v);
     log_msg(TRANSCRIBE_LOG_LEVEL_INFO,
-                 "cohere kv_cache: allocated %.1f MB (%s) "
-                 "(self: %d session x %d layers, cross: %d T_enc x %d layers)",
-                 static_cast<double>(total_bytes) / (1024.0 * 1024.0),
-                 ggml_type_name(kv_type),
-                 n_ctx, n_layer, T_enc, n_layer);
+            "cohere kv_cache: allocated %.1f MB (%s) "
+            "(self: %d session x %d layers, cross: %d T_enc x %d layers)",
+            static_cast<double>(total_bytes) / (1024.0 * 1024.0), ggml_type_name(kv_type), n_ctx, n_layer, T_enc,
+            n_layer);
 
     return true;
 }
@@ -140,11 +135,11 @@ bool kv_cache_init_batched(CohereKvCache & cache,
                            int             n_state,
                            int             n_layer,
                            int             n_batch,
-                           ggml_type       kv_type)
-{
+                           ggml_type       kv_type) {
     if (n_batch <= 1) {
-        if (!kv_cache_init(cache, backend, n_ctx, T_enc, n_state, n_layer, kv_type))
+        if (!kv_cache_init(cache, backend, n_ctx, T_enc, n_state, n_layer, kv_type)) {
             return false;
+        }
         cache.n_batch = 1;
         return true;
     }
@@ -153,39 +148,41 @@ bool kv_cache_init_batched(CohereKvCache & cache,
         return false;
     }
 
-    const size_t ctx_size = 4 * ggml_tensor_overhead() + 256;
-    ggml_init_params params {};
+    const size_t     ctx_size = 4 * ggml_tensor_overhead() + 256;
+    ggml_init_params params{};
     params.mem_size   = ctx_size;
     params.mem_buffer = nullptr;
     params.no_alloc   = true;
-    cache.ctx = ggml_init(params);
-    if (cache.ctx == nullptr) return false;
+    cache.ctx         = ggml_init(params);
+    if (cache.ctx == nullptr) {
+        return false;
+    }
 
-    const int64_t self_elements =
-        static_cast<int64_t>(n_state) * n_layer * n_ctx * n_batch;
-    const int64_t cross_elements =
-        static_cast<int64_t>(n_state) * n_layer * T_enc * n_batch;
+    const int64_t self_elements  = static_cast<int64_t>(n_state) * n_layer * n_ctx * n_batch;
+    const int64_t cross_elements = static_cast<int64_t>(n_state) * n_layer * T_enc * n_batch;
 
     cache.self_k  = ggml_new_tensor_1d(cache.ctx, kv_type, self_elements);
     cache.self_v  = ggml_new_tensor_1d(cache.ctx, kv_type, self_elements);
     cache.cross_k = ggml_new_tensor_1d(cache.ctx, kv_type, cross_elements);
     cache.cross_v = ggml_new_tensor_1d(cache.ctx, kv_type, cross_elements);
-    ggml_set_name(cache.self_k,  "kv_self_k");
-    ggml_set_name(cache.self_v,  "kv_self_v");
+    ggml_set_name(cache.self_k, "kv_self_k");
+    ggml_set_name(cache.self_v, "kv_self_v");
     ggml_set_name(cache.cross_k, "kv_cross_k");
     ggml_set_name(cache.cross_v, "kv_cross_v");
 
     cache.buffer = ggml_backend_alloc_ctx_tensors(cache.ctx, backend);
     if (cache.buffer == nullptr) {
-        ggml_free(cache.ctx); cache.ctx = nullptr; return false;
+        ggml_free(cache.ctx);
+        cache.ctx = nullptr;
+        return false;
     }
     ggml_backend_buffer_clear(cache.buffer, 0);
 
-    cache.n_ctx   = n_ctx;
-    cache.T_enc   = T_enc;
-    cache.n       = 0;
-    cache.head    = 0;
-    cache.n_batch = n_batch;
+    cache.n_ctx           = n_ctx;
+    cache.T_enc           = T_enc;
+    cache.n               = 0;
+    cache.head            = 0;
+    cache.n_batch         = n_batch;
     cache.cross_populated = false;
     return true;
 }
@@ -215,9 +212,7 @@ CohereModel::~CohereModel() {
         ggml_backend_buffer_free(backend_buffer);
         backend_buffer = nullptr;
     }
-    for (auto it = plan.scheduler_list.rbegin();
-         it != plan.scheduler_list.rend(); ++it)
-    {
+    for (auto it = plan.scheduler_list.rbegin(); it != plan.scheduler_list.rend(); ++it) {
         ggml_backend_free(*it);
     }
     plan.scheduler_list.clear();
@@ -273,12 +268,11 @@ int cohere_predict_t_enc(int mel_n_frames, int subsampling_factor) {
 // at T_enc == enc_pos_emb_max_len. Returns 0 (unknown) if any rate hparam
 // is missing, so a misconfigured model is never advertised with a wrong value.
 int64_t cohere_max_audio_ms(const CohereHParams & hp) {
-    if (hp.enc_pos_emb_max_len <= 0 || hp.enc_subsampling_factor <= 0 ||
-        hp.fe_hop_length <= 0 || hp.fe_sample_rate <= 0) {
+    if (hp.enc_pos_emb_max_len <= 0 || hp.enc_subsampling_factor <= 0 || hp.fe_hop_length <= 0 ||
+        hp.fe_sample_rate <= 0) {
         return 0;
     }
-    const int64_t mel_frames =
-        static_cast<int64_t>(hp.enc_pos_emb_max_len) * hp.enc_subsampling_factor;
+    const int64_t mel_frames = static_cast<int64_t>(hp.enc_pos_emb_max_len) * hp.enc_subsampling_factor;
     return mel_frames * hp.fe_hop_length * 1000 / hp.fe_sample_rate;
 }
 
@@ -295,44 +289,49 @@ int cohere_dec_ctx_ceiling(int32_t n_ctx_knob, const CohereHParams & hp) {
 
 transcribe_status fuse_batch_norm(CohereModel & m) {
     const size_t n_blocks = m.weights.blocks.size();
-    if (n_blocks == 0) return TRANSCRIBE_OK;
+    if (n_blocks == 0) {
+        return TRANSCRIBE_OK;
+    }
 
-    const int64_t d = m.hparams.enc_d_model;
-    const size_t tensor_bytes = static_cast<size_t>(d) * sizeof(float);
+    const int64_t d            = m.hparams.enc_d_model;
+    const size_t  tensor_bytes = static_cast<size_t>(d) * sizeof(float);
 
-    const size_t ctx_size = n_blocks * 2 * ggml_tensor_overhead() + 256;
-    ggml_init_params params = {ctx_size, nullptr, true};
-    m.bn_fused_ctx = ggml_init(params);
-    if (m.bn_fused_ctx == nullptr) return TRANSCRIBE_ERR_BACKEND;
+    const size_t     ctx_size = n_blocks * 2 * ggml_tensor_overhead() + 256;
+    ggml_init_params params   = { ctx_size, nullptr, true };
+    m.bn_fused_ctx            = ggml_init(params);
+    if (m.bn_fused_ctx == nullptr) {
+        return TRANSCRIBE_ERR_BACKEND;
+    }
 
     for (size_t i = 0; i < n_blocks; ++i) {
-        auto & b = m.weights.blocks[i];
+        auto & b              = m.weights.blocks[i];
         b.conv_bn_fused_scale = ggml_new_tensor_1d(m.bn_fused_ctx, GGML_TYPE_F32, d);
         b.conv_bn_fused_bias  = ggml_new_tensor_1d(m.bn_fused_ctx, GGML_TYPE_F32, d);
     }
 
-    m.bn_fused_buffer = ggml_backend_alloc_ctx_tensors(
-        m.bn_fused_ctx, m.plan.scheduler_list.back());
-    if (m.bn_fused_buffer == nullptr) return TRANSCRIBE_ERR_BACKEND;
+    m.bn_fused_buffer = ggml_backend_alloc_ctx_tensors(m.bn_fused_ctx, m.plan.scheduler_list.back());
+    if (m.bn_fused_buffer == nullptr) {
+        return TRANSCRIBE_ERR_BACKEND;
+    }
 
     std::vector<float> bn_w(d), bn_b(d), rm(d), rv(d);
     std::vector<float> fused_s(d), fused_b(d);
 
     for (size_t i = 0; i < n_blocks; ++i) {
         auto & b = m.weights.blocks[i];
-        ggml_backend_tensor_get(b.conv_bn_w,  bn_w.data(), 0, tensor_bytes);
-        ggml_backend_tensor_get(b.conv_bn_b,  bn_b.data(), 0, tensor_bytes);
-        ggml_backend_tensor_get(b.conv_bn_rm, rm.data(),   0, tensor_bytes);
-        ggml_backend_tensor_get(b.conv_bn_rv, rv.data(),   0, tensor_bytes);
+        ggml_backend_tensor_get(b.conv_bn_w, bn_w.data(), 0, tensor_bytes);
+        ggml_backend_tensor_get(b.conv_bn_b, bn_b.data(), 0, tensor_bytes);
+        ggml_backend_tensor_get(b.conv_bn_rm, rm.data(), 0, tensor_bytes);
+        ggml_backend_tensor_get(b.conv_bn_rv, rv.data(), 0, tensor_bytes);
 
         for (int64_t c = 0; c < d; ++c) {
             const float s = bn_w[c] / std::sqrt(rv[c] + kBnEps);
-            fused_s[c] = s;
-            fused_b[c] = bn_b[c] - rm[c] * s;
+            fused_s[c]    = s;
+            fused_b[c]    = bn_b[c] - rm[c] * s;
         }
 
         ggml_backend_tensor_set(b.conv_bn_fused_scale, fused_s.data(), 0, tensor_bytes);
-        ggml_backend_tensor_set(b.conv_bn_fused_bias,  fused_b.data(), 0, tensor_bytes);
+        ggml_backend_tensor_set(b.conv_bn_fused_bias, fused_b.data(), 0, tensor_bytes);
     }
 
     return TRANSCRIBE_OK;
@@ -346,7 +345,9 @@ transcribe_status fuse_batch_norm(CohereModel & m) {
 // `q = q + q_b` graph op. We null attn_q_b after so the builder skips the add.
 transcribe_status fuse_encoder_q_bias(CohereModel & m) {
     const size_t n_blocks = m.weights.blocks.size();
-    if (n_blocks == 0) return TRANSCRIBE_OK;
+    if (n_blocks == 0) {
+        return TRANSCRIBE_OK;
+    }
 
     const int64_t d_model  = m.hparams.enc_d_model;
     const int64_t n_heads  = m.hparams.enc_n_heads;
@@ -354,28 +355,27 @@ transcribe_status fuse_encoder_q_bias(CohereModel & m) {
 
     if (head_dim * n_heads != d_model) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "cohere: d_model (%lld) != head_dim*n_heads; "
-            "skipping encoder Q-bias fusion", (long long)d_model);
+                "cohere: d_model (%lld) != head_dim*n_heads; "
+                "skipping encoder Q-bias fusion",
+                (long long) d_model);
         return TRANSCRIBE_OK;
     }
 
-    const size_t nbytes = static_cast<size_t>(d_model) * sizeof(float);
+    const size_t       nbytes = static_cast<size_t>(d_model) * sizeof(float);
     std::vector<float> q_bias(d_model);
-    std::vector<float> pos_u (d_model);
-    std::vector<float> pos_v (d_model);
+    std::vector<float> pos_u(d_model);
+    std::vector<float> pos_v(d_model);
 
     size_t fused = 0;
     for (size_t i = 0; i < n_blocks; ++i) {
         auto & b = m.weights.blocks[i];
-        if (b.attn_q_b   == nullptr ||
-            b.attn_pos_u == nullptr ||
-            b.attn_pos_v == nullptr) {
+        if (b.attn_q_b == nullptr || b.attn_pos_u == nullptr || b.attn_pos_v == nullptr) {
             continue;
         }
 
-        ggml_backend_tensor_get(b.attn_q_b,   q_bias.data(), 0, nbytes);
-        ggml_backend_tensor_get(b.attn_pos_u, pos_u.data(),  0, nbytes);
-        ggml_backend_tensor_get(b.attn_pos_v, pos_v.data(),  0, nbytes);
+        ggml_backend_tensor_get(b.attn_q_b, q_bias.data(), 0, nbytes);
+        ggml_backend_tensor_get(b.attn_pos_u, pos_u.data(), 0, nbytes);
+        ggml_backend_tensor_get(b.attn_pos_v, pos_v.data(), 0, nbytes);
 
         // pos_u/v [head_dim, n_heads] and q_b [d_model=head_dim*n_heads]
         // share the same linear element layout, so a flat add is correct.
@@ -394,9 +394,7 @@ transcribe_status fuse_encoder_q_bias(CohereModel & m) {
     }
 
     if (fused > 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_INFO,
-            "cohere: fused Q bias into pos_u/pos_v for %zu encoder blocks",
-            fused);
+        log_msg(TRANSCRIBE_LOG_LEVEL_INFO, "cohere: fused Q bias into pos_u/pos_v for %zu encoder blocks", fused);
     }
     return TRANSCRIBE_OK;
 }
@@ -410,37 +408,29 @@ transcribe_status promote_conv_pw_to_f32_on_cpu(CohereModel & m) {
     slots.reserve(m.weights.blocks.size() * 2);
     for (auto & b : m.weights.blocks) {
         if (b.conv_pw1_w != nullptr && b.conv_pw1_w->type == GGML_TYPE_F16) {
-            slots.push_back({&b.conv_pw1_w, b.conv_pw1_w});
+            slots.push_back({ &b.conv_pw1_w, b.conv_pw1_w });
         }
         if (b.conv_pw2_w != nullptr && b.conv_pw2_w->type == GGML_TYPE_F16) {
-            slots.push_back({&b.conv_pw2_w, b.conv_pw2_w});
+            slots.push_back({ &b.conv_pw2_w, b.conv_pw2_w });
         }
     }
-    return load_common::promote_conv_pw_f16_to_f32_on_cpu(
-        m.plan, slots, "cohere",
-        &m.conv_pw_f32_ctx, &m.conv_pw_f32_buffer);
+    return load_common::promote_conv_pw_f16_to_f32_on_cpu(m.plan, slots, "cohere", &m.conv_pw_f32_ctx,
+                                                          &m.conv_pw_f32_buffer);
 }
 
 constexpr const char k_default_variant[] = "cohere-asr";
 
 // Forward declarations for the Arch trait below.
-extern transcribe_status load        (Loader &, const transcribe_model_load_params *,
-                                      transcribe_model **);
-extern transcribe_status init_context(transcribe_model *, const transcribe_session_params *,
-                                      transcribe_session **);
-extern transcribe_status run         (transcribe_session *, const float *, int,
-                                      const transcribe_run_params *);
-
-transcribe_status load(
-    Loader &                          loader,
-    const transcribe_model_load_params *   params,
-    transcribe_model **               out_model)
-{
+extern transcribe_status load(Loader &, const transcribe_model_load_params *, transcribe_model **);
+extern transcribe_status init_context(transcribe_model *, const transcribe_session_params *, transcribe_session **);
+extern transcribe_status run(transcribe_session *, const float *, int, const transcribe_run_params *);
+
+transcribe_status load(Loader & loader, const transcribe_model_load_params * params, transcribe_model ** out_model) {
     // Backend and device selection are resolved below via load_common.
 
     const int64_t t_load_start = ggml_time_us();
 
-    auto m = std::make_unique<CohereModel>();
+    auto m       = std::make_unique<CohereModel>();
     m->arch      = &arch;
     m->t_load_us = 0;
 
@@ -455,15 +445,11 @@ transcribe_status load(
     m->caps.n_languages = 0;
     m->caps.languages   = nullptr;
 
-    if (const transcribe_status st = read_capability_kv(loader.gguf(), m->caps);
-        st != TRANSCRIBE_OK)
-    {
+    if (const transcribe_status st = read_capability_kv(loader.gguf(), m->caps); st != TRANSCRIBE_OK) {
         return st;
     }
 
-    if (const transcribe_status st = read_languages_kv(loader.gguf(), *m);
-        st != TRANSCRIBE_OK)
-    {
+    if (const transcribe_status st = read_languages_kv(loader.gguf(), *m); st != TRANSCRIBE_OK) {
         return st;
     }
 
@@ -471,9 +457,7 @@ transcribe_status load(
         return st;
     }
 
-    if (const transcribe_status st = read_cohere_hparams(loader.gguf(), m->hparams);
-        st != TRANSCRIBE_OK)
-    {
+    if (const transcribe_status st = read_cohere_hparams(loader.gguf(), m->hparams); st != TRANSCRIBE_OK) {
         return st;
     }
 
@@ -487,28 +471,25 @@ transcribe_status load(
     // effective_max_audio_ms therefore keys off the decoder ceiling and will
     // NOT match caps.max_audio_ms (the encoder input bound) — for cohere the
     // decoder context bounds the OUTPUT transcript, so that figure is advisory.
-    if (m->hparams.dec_max_seq > 0 &&
-        m->hparams.enc_subsampling_factor > 0 &&
-        m->hparams.fe_hop_length > 0 && m->hparams.fe_sample_rate > 0) {
-        m->limits.has_context_cap = true;
+    if (m->hparams.dec_max_seq > 0 && m->hparams.enc_subsampling_factor > 0 && m->hparams.fe_hop_length > 0 &&
+        m->hparams.fe_sample_rate > 0) {
+        m->limits.has_context_cap        = true;
         // Audio bound is the encoder table (caps.max_audio_ms), not the
         // decoder context, so effective_max_audio_ms must not shrink with n_ctx.
-        m->limits.audio_from_caps = true;
-        m->limits.model_max_ctx   = m->hparams.dec_max_seq;
+        m->limits.audio_from_caps        = true;
+        m->limits.model_max_ctx          = m->hparams.dec_max_seq;
         // Fixed control-token preamble (see run()'s prompt_pieces). Audio is
         // in cross-KV, so there is no audio-token overhead here.
-        m->limits.prompt_overhead = 10;
-        m->limits.gen_reserve     = 512;  // max-new-tokens cap in run()
+        m->limits.prompt_overhead        = 10;
+        m->limits.gen_reserve            = 512;  // max-new-tokens cap in run()
         // ms-per-audio-token = subsampling_factor * hop_length * 1000 / sr.
-        m->limits.ms_per_audio_token =
-            static_cast<double>(m->hparams.enc_subsampling_factor) *
-            m->hparams.fe_hop_length * 1000.0 / m->hparams.fe_sample_rate;
+        m->limits.ms_per_audio_token     = static_cast<double>(m->hparams.enc_subsampling_factor) *
+                                           m->hparams.fe_hop_length * 1000.0 / m->hparams.fe_sample_rate;
         // Self-KV stores dec_hidden per layer, two tensors (K, V); no GQA.
-        m->limits.kv_elems_per_ctx_token =
-            (int64_t) m->hparams.dec_hidden * m->hparams.dec_n_layers * 2;
+        m->limits.kv_elems_per_ctx_token = (int64_t) m->hparams.dec_hidden * m->hparams.dec_n_layers * 2;
     }
 
-    m->hparams.vocab_size = m->tok.n_tokens();
+    m->hparams.vocab_size   = m->tok.n_tokens();
     m->hparams.bos_token_id = m->tok.bos_id();
     m->hparams.eos_token_id = m->tok.eos_id();
 
@@ -516,14 +497,14 @@ transcribe_status load(
     // a missing EOS is a GGUF-builder bug that should surface at conversion.
     if (m->hparams.eos_token_id < 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "cohere: GGUF tokenizer has no eos_token_id -- "
-                     "regenerate with an up-to-date converter");
+                "cohere: GGUF tokenizer has no eos_token_id -- "
+                "regenerate with an up-to-date converter");
         return TRANSCRIBE_ERR_GGUF;
     }
 
     // Mel frontend.
     {
-        transcribe::MelConfig cfg {};
+        transcribe::MelConfig cfg{};
         cfg.sample_rate  = m->hparams.fe_sample_rate;
         cfg.num_mels     = m->hparams.fe_num_mels;
         cfg.n_fft        = m->hparams.fe_n_fft;
@@ -540,21 +521,16 @@ transcribe_status load(
         {
             using R = load_common::ReadF32Result;
 
-            const size_t fb_elems = static_cast<size_t>(cfg.num_mels)
-                                  * static_cast<size_t>(cfg.n_fft / 2 + 1);
-            const auto fb_rc = load_common::read_f32_tensor_checked(
-                loader.gguf(), loader.path(),
-                "frontend.mel_filterbank", fb_elems,
-                "cohere", cfg.filterbank);
+            const size_t fb_elems = static_cast<size_t>(cfg.num_mels) * static_cast<size_t>(cfg.n_fft / 2 + 1);
+            const auto   fb_rc    = load_common::read_f32_tensor_checked(
+                loader.gguf(), loader.path(), "frontend.mel_filterbank", fb_elems, "cohere", cfg.filterbank);
             if (fb_rc != R::Ok && fb_rc != R::Absent) {
                 return TRANSCRIBE_ERR_GGUF;
             }
 
             const size_t win_elems = static_cast<size_t>(cfg.win_length);
-            const auto win_rc = load_common::read_f32_tensor_checked(
-                loader.gguf(), loader.path(),
-                "frontend.window", win_elems,
-                "cohere", cfg.window);
+            const auto   win_rc = load_common::read_f32_tensor_checked(loader.gguf(), loader.path(), "frontend.window",
+                                                                       win_elems, "cohere", cfg.window);
             if (win_rc != R::Ok && win_rc != R::Absent) {
                 return TRANSCRIBE_ERR_GGUF;
             }
@@ -564,20 +540,16 @@ transcribe_status load(
     }
 
     // Reopen with no_alloc.
-    gguf_init_params init_params {};
+    gguf_init_params init_params{};
     init_params.no_alloc = true;
     init_params.ctx      = &m->ctx_meta;
 
-    gguf_context * gguf_data = gguf_init_from_file(loader.path().c_str(),
-                                                   init_params);
+    gguf_context * gguf_data = gguf_init_from_file(loader.path().c_str(), init_params);
     if (gguf_data == nullptr) {
         return TRANSCRIBE_ERR_GGUF;
     }
 
-    if (const transcribe_status st =
-            build_cohere_weights(m->ctx_meta, m->hparams, m->weights);
-        st != TRANSCRIBE_OK)
-    {
+    if (const transcribe_status st = build_cohere_weights(m->ctx_meta, m->hparams, m->weights); st != TRANSCRIBE_OK) {
         gguf_free(gguf_data);
         return st;
     }
@@ -586,79 +558,65 @@ transcribe_status load(
     // pointwise F16->F32 promotion below depends on a strict-CPU plan
     // (primary_kind == BackendKind::Cpu), which only TRANSCRIBE_BACKEND_CPU
     // reliably produces.
-    const transcribe_backend_request backend_req =
-        (params != nullptr) ? params->backend : TRANSCRIBE_BACKEND_AUTO;
+    const transcribe_backend_request backend_req = (params != nullptr) ? params->backend : TRANSCRIBE_BACKEND_AUTO;
 
     if (const transcribe_status st = transcribe::load_common::init_backends(
             backend_req, (params != nullptr) ? params->gpu_device : 0, "cohere", m->plan);
-        st != TRANSCRIBE_OK)
-    {
+        st != TRANSCRIBE_OK) {
         gguf_free(gguf_data);
         return st;
     }
 
-    m->backend = ggml_backend_name(m->plan.primary);
+    m->backend         = ggml_backend_name(m->plan.primary);
     m->primary_backend = m->plan.primary;
 
-    ggml_backend_buffer_t weights_buffer =
-        ggml_backend_alloc_ctx_tensors(m->ctx_meta, m->plan.primary);
+    ggml_backend_buffer_t weights_buffer = ggml_backend_alloc_ctx_tensors(m->ctx_meta, m->plan.primary);
     if (weights_buffer == nullptr) {
         gguf_free(gguf_data);
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "cohere: ggml_backend_alloc_ctx_tensors failed");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "cohere: ggml_backend_alloc_ctx_tensors failed");
         return TRANSCRIBE_ERR_GGUF;
     }
     m->backend_buffer = weights_buffer;
-    ggml_backend_buffer_set_usage(weights_buffer,
-                                  GGML_BACKEND_BUFFER_USAGE_WEIGHTS);
+    ggml_backend_buffer_set_usage(weights_buffer, GGML_BACKEND_BUFFER_USAGE_WEIGHTS);
 
     // Stream tensor data from the GGUF file into the backend buffer
     // slots. See transcribe-load-common.h for the shared loop.
-    if (const transcribe_status st = transcribe::load_common::stream_tensor_data(
-            loader.path(), gguf_data, m->ctx_meta, "cohere");
-        st != TRANSCRIBE_OK)
-    {
+    if (const transcribe_status st =
+            transcribe::load_common::stream_tensor_data(loader.path(), gguf_data, m->ctx_meta, "cohere");
+        st != TRANSCRIBE_OK) {
         gguf_free(gguf_data);
         return st;
     }
 
     gguf_free(gguf_data);
 
-    if (const transcribe_status st = fuse_batch_norm(*m);
-        st != TRANSCRIBE_OK)
-    {
+    if (const transcribe_status st = fuse_batch_norm(*m); st != TRANSCRIBE_OK) {
         return st;
     }
 
     // Fuse encoder Q bias into pos_bias_u/v (drops one add per layer).
-    if (const transcribe_status st = fuse_encoder_q_bias(*m);
-        st != TRANSCRIBE_OK)
-    {
+    if (const transcribe_status st = fuse_encoder_q_bias(*m); st != TRANSCRIBE_OK) {
         return st;
     }
 
     // CPU only: dequantize conv pointwise weights to F32 (see function doc).
-    if (const transcribe_status st = promote_conv_pw_to_f32_on_cpu(*m);
-        st != TRANSCRIBE_OK)
-    {
+    if (const transcribe_status st = promote_conv_pw_to_f32_on_cpu(*m); st != TRANSCRIBE_OK) {
         return st;
     }
 
     m->t_load_us = ggml_time_us() - t_load_start;
-    *out_model = m.release();
+    *out_model   = m.release();
     return TRANSCRIBE_OK;
 }
 
-transcribe_status init_context(
-    transcribe_model *                model,
-    const transcribe_session_params * params,
-    transcribe_session **             out_ctx)
-{
+transcribe_status init_context(transcribe_model *                model,
+                               const transcribe_session_params * params,
+                               transcribe_session **             out_ctx) {
     if (model->arch != &arch) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
 
-    auto cc = std::make_unique<CohereSession>();
+    auto cc       = std::make_unique<CohereSession>();
     cc->model     = model;
     cc->n_threads = params->n_threads;
     cc->kv_type   = params->kv_type;
@@ -668,26 +626,22 @@ transcribe_status init_context(
 
     // Flash-attention policy — see CohereSession (cohere.h). Encoder
     // auto-disables on Metal; decoder defaults on; env overrides apply globally.
-    auto * cm = static_cast<CohereModel *>(model);
-    const bool is_metal =
-        (cm->plan.primary_kind == transcribe::BackendKind::Metal);
+    auto *     cm       = static_cast<CohereModel *>(model);
+    const bool is_metal = (cm->plan.primary_kind == transcribe::BackendKind::Metal);
 
     cc->encoder_use_flash = !is_metal;
     cc->decoder_use_flash = true;
 
-    transcribe::flash::apply_env_overrides(
-        cc->encoder_use_flash, cc->decoder_use_flash);
+    transcribe::flash::apply_env_overrides(cc->encoder_use_flash, cc->decoder_use_flash);
 
     *out_ctx = cc.release();
     return TRANSCRIBE_OK;
 }
 
-transcribe_status run(
-    transcribe_session *      session,
-    const float *             pcm,
-    int                       n_samples,
-    const transcribe_run_params * params)
-{
+transcribe_status run(transcribe_session *          session,
+                      const float *                 pcm,
+                      int                           n_samples,
+                      const transcribe_run_params * params) {
     if (session == nullptr || pcm == nullptr || n_samples <= 0) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
@@ -707,21 +661,17 @@ transcribe_status run(
 
     // ----- Mel front-end -------------------------------------------
     if (!cm->mel.has_value()) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "cohere run: model has no MelFrontend (load skipped?)");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "cohere run: model has no MelFrontend (load skipped?)");
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
-    const int64_t t_mel_start = ggml_time_us();
-    int mel_n_mels   = 0;
-    int mel_n_frames = 0;
-    if (const transcribe_status mst = cm->mel->compute(
-            pcm, static_cast<size_t>(n_samples),
-            cc->mel_buf, mel_n_mels, mel_n_frames);
-        mst != TRANSCRIBE_OK)
-    {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "cohere run: MelFrontend::compute failed (%s)",
-                     transcribe_status_string(mst));
+    const int64_t t_mel_start  = ggml_time_us();
+    int           mel_n_mels   = 0;
+    int           mel_n_frames = 0;
+    if (const transcribe_status mst =
+            cm->mel->compute(pcm, static_cast<size_t>(n_samples), cc->mel_buf, mel_n_mels, mel_n_frames);
+        mst != TRANSCRIBE_OK) {
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "cohere run: MelFrontend::compute failed (%s)",
+                transcribe_status_string(mst));
         return mst;
     }
     cc->t_mel_us = ggml_time_us() - t_mel_start;
@@ -732,17 +682,14 @@ transcribe_status run(
     // deterministic function of mel_n_frames, so reject an over-length clip
     // here, before building the encoder graph.
     if (cm->hparams.enc_pos_emb_max_len > 0) {
-        const int t_enc_pred = cohere_predict_t_enc(
-            mel_n_frames, cm->hparams.enc_subsampling_factor);
+        const int t_enc_pred = cohere_predict_t_enc(mel_n_frames, cm->hparams.enc_subsampling_factor);
         if (t_enc_pred > cm->hparams.enc_pos_emb_max_len) {
-            const double max_s =
-                static_cast<double>(cm->caps.max_audio_ms) / 1000.0;
-            transcribe::log_msg(
-                TRANSCRIBE_LOG_LEVEL_ERROR,
-                "cohere run: input too long — %d encoder frames exceed the %d "
-                "the model supports (~%.0f s max). See "
-                "transcribe_capabilities.max_audio_ms.",
-                t_enc_pred, cm->hparams.enc_pos_emb_max_len, max_s);
+            const double max_s = static_cast<double>(cm->caps.max_audio_ms) / 1000.0;
+            transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
+                                "cohere run: input too long — %d encoder frames exceed the %d "
+                                "the model supports (~%.0f s max). See "
+                                "transcribe_capabilities.max_audio_ms.",
+                                t_enc_pred, cm->hparams.enc_pos_emb_max_len, max_s);
             return TRANSCRIBE_ERR_INPUT_TOO_LONG;
         }
     }
@@ -757,54 +704,51 @@ transcribe_status run(
     // ----- Build encoder graph -------------------------------------
     {
         // 48 encoder blocks + decoder = large graph. 8 MB metadata arena.
-        ggml_init_params init_params {};
+        ggml_init_params init_params{};
         init_params.mem_size   = 8 * 1024 * 1024;
         init_params.mem_buffer = nullptr;
         init_params.no_alloc   = true;
-        cc->compute_ctx = ggml_init(init_params);
+        cc->compute_ctx        = ggml_init(init_params);
         if (cc->compute_ctx == nullptr) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "cohere run: ggml_init for compute_ctx failed — out of memory.");
+                                "cohere run: ggml_init for compute_ctx failed — out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
     }
 
     ggml_type resolved_kv = GGML_TYPE_COUNT;
-    if (cc->kv_type == TRANSCRIBE_KV_TYPE_F32) resolved_kv = GGML_TYPE_F32;
-    if (cc->kv_type == TRANSCRIBE_KV_TYPE_F16) resolved_kv = GGML_TYPE_F16;
+    if (cc->kv_type == TRANSCRIBE_KV_TYPE_F32) {
+        resolved_kv = GGML_TYPE_F32;
+    }
+    if (cc->kv_type == TRANSCRIBE_KV_TYPE_F16) {
+        resolved_kv = GGML_TYPE_F16;
+    }
 
-    EncoderBuild eb = build_encoder_graph(
-        cc->compute_ctx, cm->weights, cm->hparams, mel_n_frames,
-        resolved_kv, cc->encoder_use_flash, cm->backend.c_str());
+    EncoderBuild eb = build_encoder_graph(cc->compute_ctx, cm->weights, cm->hparams, mel_n_frames, resolved_kv,
+                                          cc->encoder_use_flash, cm->backend.c_str());
     if (eb.mel_in == nullptr || eb.out == nullptr || eb.graph == nullptr) {
         return TRANSCRIBE_ERR_GGUF;
     }
 
     // ----- Allocate + compute encoder graph -------------------------
     if (cc->sched == nullptr) {
-        cc->sched = ggml_backend_sched_new(
-            cm->plan.scheduler_list.data(), nullptr,
-            static_cast<int>(cm->plan.scheduler_list.size()),
-            16384, false, true);
+        cc->sched = ggml_backend_sched_new(cm->plan.scheduler_list.data(), nullptr,
+                                           static_cast<int>(cm->plan.scheduler_list.size()), 16384, false, true);
         if (cc->sched == nullptr) {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "cohere run: ggml_backend_sched_new failed");
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "cohere run: ggml_backend_sched_new failed");
             return TRANSCRIBE_ERR_GGUF;
         }
     }
     ggml_backend_sched_reset(cc->sched);
     if (!ggml_backend_sched_alloc_graph(cc->sched, eb.graph)) {
-        transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "cohere run: encoder graph allocation failed — out of memory.");
+        transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "cohere run: encoder graph allocation failed — out of memory.");
         return TRANSCRIBE_ERR_OOM;
     }
 
     // Upload mel.
-    ggml_backend_tensor_set(eb.mel_in, cc->mel_buf.data(),
-                            0, cc->mel_buf.size() * sizeof(float));
+    ggml_backend_tensor_set(eb.mel_in, cc->mel_buf.data(), 0, cc->mel_buf.size() * sizeof(float));
 
-    transcribe::debug::dump_tensor(
-        "enc.mel.in", eb.mel_in, "encoder.mel");
+    transcribe::debug::dump_tensor("enc.mel.in", eb.mel_in, "encoder.mel");
 
     // Sinusoidal positional embedding (same as Parakeet).
     if (eb.pos_emb_in != nullptr) {
@@ -818,25 +762,22 @@ transcribe_status run(
         const float ln_10000 = std::log(10000.0f);
         for (int k = 0; k < d_model / 2; ++k) {
             cc->pos_div_term[static_cast<size_t>(k)] =
-                std::exp(static_cast<float>(2 * k) *
-                         (-ln_10000 / static_cast<float>(d_model)));
+                std::exp(static_cast<float>(2 * k) * (-ln_10000 / static_cast<float>(d_model)));
         }
 
         for (int i = 0; i < pos_len; ++i) {
             const float pos = static_cast<float>((T_enc - 1) - i);
-            float * row = cc->pos_buf.data() + static_cast<size_t>(i) * d_model;
+            float *     row = cc->pos_buf.data() + static_cast<size_t>(i) * d_model;
             for (int k = 0; k < d_model / 2; ++k) {
                 const float div = cc->pos_div_term[static_cast<size_t>(k)];
-                row[2 * k]     = std::sin(pos * div);
-                row[2 * k + 1] = std::cos(pos * div);
+                row[2 * k]      = std::sin(pos * div);
+                row[2 * k + 1]  = std::cos(pos * div);
             }
         }
 
-        ggml_backend_tensor_set(eb.pos_emb_in, cc->pos_buf.data(),
-                                0, cc->pos_buf.size() * sizeof(float));
+        ggml_backend_tensor_set(eb.pos_emb_in, cc->pos_buf.data(), 0, cc->pos_buf.size() * sizeof(float));
 
-        transcribe::debug::dump_tensor(
-            "enc.pos_emb", eb.pos_emb_in, "encoder.pos_emb");
+        transcribe::debug::dump_tensor("enc.pos_emb", eb.pos_emb_in, "encoder.pos_emb");
     }
 
     // Set thread count.
@@ -844,41 +785,34 @@ transcribe_status run(
 
     // Compute encoder graph.
     const int64_t t_enc_start = ggml_time_us();
-    if (const ggml_status gs =
-            ggml_backend_sched_graph_compute(cc->sched, eb.graph);
-        gs != GGML_STATUS_SUCCESS)
-    {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "cohere run: encoder graph compute failed (%d)",
-                     static_cast<int>(gs));
+    if (const ggml_status gs = ggml_backend_sched_graph_compute(cc->sched, eb.graph); gs != GGML_STATUS_SUCCESS) {
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "cohere run: encoder graph compute failed (%d)", static_cast<int>(gs));
         return TRANSCRIBE_ERR_GGUF;
     }
     cc->t_encode_us = ggml_time_us() - t_enc_start;
 
     // Dump encoder intermediates.
-    auto try_dump = [](const char * name, ggml_tensor * t,
-                       const char * stage)
-    {
+    auto try_dump = [](const char * name, ggml_tensor * t, const char * stage) {
         if (t != nullptr) {
             transcribe::debug::dump_tensor(name, t, stage);
         }
     };
 
     // Pre-encode sub-stage dumps for debugging.
-    try_dump("enc.pre_encode.out",   eb.dumps.pre_encode_out,   "encoder.pre_encode");
-    try_dump("enc.block.0.out",      eb.dumps.block0_out,       "encoder.block0.out");
+    try_dump("enc.pre_encode.out", eb.dumps.pre_encode_out, "encoder.pre_encode");
+    try_dump("enc.block.0.out", eb.dumps.block0_out, "encoder.block0.out");
     {
         char bname[64];
         std::snprintf(bname, sizeof(bname), "enc.block.%d.out", cm->hparams.enc_n_layers / 2 - 1);
-        try_dump(bname,  eb.dumps.block_mid_out,  "encoder.block_mid.out");
+        try_dump(bname, eb.dumps.block_mid_out, "encoder.block_mid.out");
     }
     {
         char bname[64];
         std::snprintf(bname, sizeof(bname), "enc.block.%d.out", cm->hparams.enc_n_layers - 1);
-        try_dump(bname,  eb.dumps.block_last_out, "encoder.block_last.out");
+        try_dump(bname, eb.dumps.block_last_out, "encoder.block_last.out");
     }
-    try_dump("enc.final",            eb.dumps.final_out,        "encoder.final");
-    try_dump("enc_dec_proj.out",     eb.dumps.enc_dec_proj_out, "encoder.enc_dec_proj");
+    try_dump("enc.final", eb.dumps.final_out, "encoder.final");
+    try_dump("enc_dec_proj.out", eb.dumps.enc_dec_proj_out, "encoder.enc_dec_proj");
 
     cc->encoder_out = eb.out;
 
@@ -887,14 +821,13 @@ transcribe_status run(
     const int T_enc = static_cast<int>(eb.out->ne[1]);
     if (d_enc <= 0 || T_enc <= 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "cohere run: encoder output has degenerate shape "
-                     "[%d, %d]", d_enc, T_enc);
+                "cohere run: encoder output has degenerate shape "
+                "[%d, %d]",
+                d_enc, T_enc);
         return TRANSCRIBE_ERR_GGUF;
     }
-    cc->enc_host.resize(static_cast<size_t>(d_enc) *
-                        static_cast<size_t>(T_enc));
-    ggml_backend_tensor_get(eb.out, cc->enc_host.data(), 0,
-                            cc->enc_host.size() * sizeof(float));
+    cc->enc_host.resize(static_cast<size_t>(d_enc) * static_cast<size_t>(T_enc));
+    ggml_backend_tensor_get(eb.out, cc->enc_host.data(), 0, cc->enc_host.size() * sizeof(float));
 
     // ----- Decoder with KV cache ------------------------------------
     //
@@ -918,18 +851,11 @@ transcribe_status run(
     // before this handler; the NULL -> "en" default applies only when the
     // caller specified none.
 
-    const std::string lang_token = std::string("<|") + lang + "|>";
+    const std::string              lang_token    = std::string("<|") + lang + "|>";
     const std::vector<std::string> prompt_pieces = {
         "\xe2\x96\x81",  // ▁ (U+2581, sentencepiece space prefix)
-        "<|startofcontext|>",
-        "<|startoftranscript|>",
-        "<|emo:undefined|>",
-        lang_token,
-        lang_token,
-        "<|pnc|>",
-        "<|noitn|>",
-        "<|notimestamp|>",
-        "<|nodiarize|>",
+        "<|startofcontext|>", "<|startoftranscript|>", "<|emo:undefined|>", lang_token, lang_token, "<|pnc|>",
+        "<|noitn|>",          "<|notimestamp|>",       "<|nodiarize|>",
     };
 
     std::vector<int32_t> prompt_ids;
@@ -937,9 +863,7 @@ transcribe_status run(
     for (const auto & piece : prompt_pieces) {
         const int id = cm->tok.find(piece);
         if (id < 0) {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "cohere run: unknown prompt token '%s'",
-                         piece.c_str());
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "cohere run: unknown prompt token '%s'", piece.c_str());
             return TRANSCRIBE_ERR_INVALID_ARG;
         }
         prompt_ids.push_back(id);
@@ -949,36 +873,32 @@ transcribe_status run(
     // ----- Initialize KV cache -----
     {
         // Free any existing cache if T_enc changed.
-        if (cc->kv_cache.buffer != nullptr &&
-            cc->kv_cache.T_enc != T_enc) {
+        if (cc->kv_cache.buffer != nullptr && cc->kv_cache.T_enc != T_enc) {
             cc->kv_cache.free();
         }
 
         if (cc->kv_cache.buffer == nullptr) {
             // Decoder self-KV ceiling: the model's trained dec_max_seq,
             // optionally lowered (never raised) by the caller's n_ctx knob.
-            const int n_ctx = cohere_dec_ctx_ceiling(cc->n_ctx, cm->hparams);
+            const int n_ctx      = cohere_dec_ctx_ceiling(cc->n_ctx, cm->hparams);
             // Decoder cache dtype: honor user override, else default to
             // F16 (weights are bf16, so F16 KV is lossless-enough and
             // halves autoregressive memory bandwidth).
             ggml_type cache_type = resolved_kv;
-            if (cache_type == GGML_TYPE_COUNT) cache_type = GGML_TYPE_F16;
-            if (!kv_cache_init(cc->kv_cache,
-                               cm->plan.primary,
-                               n_ctx, T_enc,
-                               static_cast<int>(cm->hparams.dec_hidden),
-                               cm->hparams.dec_n_layers,
-                               cache_type))
-            {
+            if (cache_type == GGML_TYPE_COUNT) {
+                cache_type = GGML_TYPE_F16;
+            }
+            if (!kv_cache_init(cc->kv_cache, cm->plan.primary, n_ctx, T_enc, static_cast<int>(cm->hparams.dec_hidden),
+                               cm->hparams.dec_n_layers, cache_type)) {
                 transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                    "cohere run: KV cache allocation failed — out of memory. "
-                    "Lower transcribe_session_params.n_ctx or shorten the audio.");
+                                    "cohere run: KV cache allocation failed — out of memory. "
+                                    "Lower transcribe_session_params.n_ctx or shorten the audio.");
                 return TRANSCRIBE_ERR_OOM;
             }
         } else {
             // Cache exists with same T_enc; just reset self-attn state.
-            cc->kv_cache.n    = 0;
-            cc->kv_cache.head = 0;
+            cc->kv_cache.n               = 0;
+            cc->kv_cache.head            = 0;
             cc->kv_cache.cross_populated = false;
         }
     }
@@ -992,23 +912,19 @@ transcribe_status run(
             cc->compute_ctx = nullptr;
         }
         cc->encoder_out = nullptr;
-        ggml_init_params init_params {};
+        ggml_init_params init_params{};
         init_params.mem_size   = mem_size;
         init_params.mem_buffer = nullptr;
         init_params.no_alloc   = true;
-        cc->compute_ctx = ggml_init(init_params);
+        cc->compute_ctx        = ggml_init(init_params);
         return cc->compute_ctx != nullptr;
     };
 
     // Helper to find the causal mask input tensor by name.
     auto find_mask_input = [&]() -> ggml_tensor * {
-        for (ggml_tensor * t = ggml_get_first_tensor(cc->compute_ctx);
-             t != nullptr;
-             t = ggml_get_next_tensor(cc->compute_ctx, t))
-        {
-            if (std::strcmp(t->name, "dec.causal_mask") == 0 &&
-                t->type == GGML_TYPE_F32)
-            {
+        for (ggml_tensor * t = ggml_get_first_tensor(cc->compute_ctx); t != nullptr;
+             t               = ggml_get_next_tensor(cc->compute_ctx, t)) {
+            if (std::strcmp(t->name, "dec.causal_mask") == 0 && t->type == GGML_TYPE_F32) {
                 return t;
             }
         }
@@ -1020,38 +936,29 @@ transcribe_status run(
     {
         if (!new_compute_ctx(4 * 1024 * 1024)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "cohere run: ggml_init for cross_kv failed — out of memory.");
+                                "cohere run: ggml_init for cross_kv failed — out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
 
-        DecoderBuild cross_db = build_cross_kv_graph(
-            cc->compute_ctx, cm->weights, cm->hparams,
-            cc->kv_cache, T_enc);
+        DecoderBuild cross_db = build_cross_kv_graph(cc->compute_ctx, cm->weights, cm->hparams, cc->kv_cache, T_enc);
         if (cross_db.graph == nullptr) {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "cohere run: build_cross_kv_graph failed");
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "cohere run: build_cross_kv_graph failed");
             return TRANSCRIBE_ERR_GGUF;
         }
 
         ggml_backend_sched_reset(cc->sched);
         if (!ggml_backend_sched_alloc_graph(cc->sched, cross_db.graph)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "cohere run: cross_kv graph allocation failed — out of memory.");
+                                "cohere run: cross_kv graph allocation failed — out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
 
         // Upload encoder output.
-        ggml_backend_tensor_set(cross_db.encoder_out_in,
-                                cc->enc_host.data(), 0,
-                                cc->enc_host.size() * sizeof(float));
+        ggml_backend_tensor_set(cross_db.encoder_out_in, cc->enc_host.data(), 0, cc->enc_host.size() * sizeof(float));
 
-        if (const ggml_status gs =
-                ggml_backend_sched_graph_compute(cc->sched, cross_db.graph);
-            gs != GGML_STATUS_SUCCESS)
-        {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "cohere run: cross_kv compute failed (%d)",
-                         static_cast<int>(gs));
+        if (const ggml_status gs = ggml_backend_sched_graph_compute(cc->sched, cross_db.graph);
+            gs != GGML_STATUS_SUCCESS) {
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "cohere run: cross_kv compute failed (%d)", static_cast<int>(gs));
             return TRANSCRIBE_ERR_GGUF;
         }
         cc->kv_cache.cross_populated = true;
@@ -1061,72 +968,60 @@ transcribe_status run(
     {
         if (!new_compute_ctx(4 * 1024 * 1024)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "cohere run: ggml_init for decoder prompt failed — out of memory.");
+                                "cohere run: ggml_init for decoder prompt failed — out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
 
         // Skip log_softmax and emit a GPU argmax over the last position.
         // Debug dumps need the pre-head state, so they take the slower path.
-        const bool prompt_skip_softmax = !transcribe::debug::enabled();
-        DecoderBuild db = build_decoder_graph_kv(
-            cc->compute_ctx, cm->weights, cm->hparams,
-            cc->kv_cache,
-            prompt_len, /*n_past=*/0, T_enc,
-            /*skip_log_softmax=*/prompt_skip_softmax,
-            cc->decoder_use_flash);
+        const bool   prompt_skip_softmax = !transcribe::debug::enabled();
+        DecoderBuild db = build_decoder_graph_kv(cc->compute_ctx, cm->weights, cm->hparams, cc->kv_cache, prompt_len,
+                                                 /*n_past=*/0, T_enc,
+                                                 /*skip_log_softmax=*/prompt_skip_softmax, cc->decoder_use_flash);
         if (db.out == nullptr || db.graph == nullptr) {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "cohere run: build_decoder_graph_kv (prompt) failed");
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "cohere run: build_decoder_graph_kv (prompt) failed");
             return TRANSCRIBE_ERR_GGUF;
         }
 
         ggml_backend_sched_reset(cc->sched);
         if (!ggml_backend_sched_alloc_graph(cc->sched, db.graph)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "cohere run: decoder prompt graph allocation failed — out of memory.");
+                                "cohere run: decoder prompt graph allocation failed — out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
 
         // Upload token IDs and position IDs.
-        ggml_backend_tensor_set(db.token_ids_in, prompt_ids.data(),
-                                0, prompt_ids.size() * sizeof(int32_t));
+        ggml_backend_tensor_set(db.token_ids_in, prompt_ids.data(), 0, prompt_ids.size() * sizeof(int32_t));
         std::vector<int32_t> pos_ids(prompt_len);
-        for (int i = 0; i < prompt_len; ++i) pos_ids[i] = i;
-        ggml_backend_tensor_set(db.pos_ids_in, pos_ids.data(),
-                                0, pos_ids.size() * sizeof(int32_t));
+        for (int i = 0; i < prompt_len; ++i) {
+            pos_ids[i] = i;
+        }
+        ggml_backend_tensor_set(db.pos_ids_in, pos_ids.data(), 0, pos_ids.size() * sizeof(int32_t));
 
         // Causal mask for prompt pass: [n_kv=prompt_len, prompt_len].
         if (prompt_len > 1) {
             ggml_tensor * mask_input = find_mask_input();
             if (mask_input != nullptr) {
-                const int n_kv = prompt_len;
-                std::vector<float> mask_data(
-                    static_cast<size_t>(n_kv) * prompt_len);
+                const int          n_kv = prompt_len;
+                std::vector<float> mask_data(static_cast<size_t>(n_kv) * prompt_len);
                 for (int q = 0; q < prompt_len; ++q) {
                     for (int k = 0; k < n_kv; ++k) {
-                        mask_data[static_cast<size_t>(q) * n_kv + k] =
-                            (k <= q) ? 0.0f : -1e9f;
+                        mask_data[static_cast<size_t>(q) * n_kv + k] = (k <= q) ? 0.0f : -1e9f;
                     }
                 }
-                ggml_backend_tensor_set(mask_input, mask_data.data(),
-                                        0, mask_data.size() * sizeof(float));
+                ggml_backend_tensor_set(mask_input, mask_data.data(), 0, mask_data.size() * sizeof(float));
             }
         }
 
-        if (const ggml_status gs =
-                ggml_backend_sched_graph_compute(cc->sched, db.graph);
-            gs != GGML_STATUS_SUCCESS)
-        {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "cohere run: decoder prompt compute failed (%d)",
-                         static_cast<int>(gs));
+        if (const ggml_status gs = ggml_backend_sched_graph_compute(cc->sched, db.graph); gs != GGML_STATUS_SUCCESS) {
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "cohere run: decoder prompt compute failed (%d)", static_cast<int>(gs));
             return TRANSCRIBE_ERR_GGUF;
         }
 
         // Dump decoder intermediates (prompt pass only).
-        try_dump("dec.token_emb",       db.dumps.token_emb,       "decoder.embedding");
-        try_dump("dec.pos_emb",         db.dumps.pos_emb,         "decoder.position_embedding");
-        try_dump("dec.embed_norm",      db.dumps.embed_norm,      "decoder.embed_norm");
+        try_dump("dec.token_emb", db.dumps.token_emb, "decoder.embedding");
+        try_dump("dec.pos_emb", db.dumps.pos_emb, "decoder.position_embedding");
+        try_dump("dec.embed_norm", db.dumps.embed_norm, "decoder.embed_norm");
         for (int i = 0; i < cm->hparams.dec_n_layers; ++i) {
             char bname[32], stage[48];
             std::snprintf(bname, sizeof(bname), "dec.block.%d.out", i);
@@ -1134,8 +1029,8 @@ transcribe_status run(
             try_dump(bname, db.dumps.block_out[i], stage);
         }
         try_dump("dec.out_before_head", db.dumps.out_before_head, "decoder.out_before_head");
-        try_dump("dec.logits_raw",      db.dumps.logits_raw,      "decoder.logits_raw");
-        try_dump("dec.logits",          db.dumps.logits,          "decoder.logits");
+        try_dump("dec.logits_raw", db.dumps.logits_raw, "decoder.logits_raw");
+        try_dump("dec.logits", db.dumps.logits, "decoder.logits");
 
         // Update KV cache state: prompt_len tokens are now cached.
         cc->kv_cache.n    = prompt_len;
@@ -1147,9 +1042,8 @@ transcribe_status run(
         // Load-time validation guarantees eos_token_id >= 0; no
         // fallback is needed here. See the tokenizer.eos_id() check
         // in cohere::load() at the top of this file.
-        const int eos_id = cm->hparams.eos_token_id;
-        const int max_tokens = std::min(512,
-                                        cc->kv_cache.n_ctx - prompt_len);
+        const int eos_id     = cm->hparams.eos_token_id;
+        const int max_tokens = std::min(512, cc->kv_cache.n_ctx - prompt_len);
 
         // Pick the first generated token. Fast path reads a single
         // int32 argmax that the GPU computed; debug path reads the
@@ -1157,22 +1051,17 @@ transcribe_status run(
         int next_token = 0;
         if (prompt_skip_softmax && db.argmax_out != nullptr) {
             int32_t argmax_id = 0;
-            ggml_backend_tensor_get(db.argmax_out, &argmax_id,
-                                    0, sizeof(int32_t));
+            ggml_backend_tensor_get(db.argmax_out, &argmax_id, 0, sizeof(int32_t));
             next_token = argmax_id;
         } else {
-            const int64_t vocab_size = db.out->ne[0];
-            std::vector<float> logits_host(
-                static_cast<size_t>(vocab_size) * prompt_len);
-            ggml_backend_tensor_get(db.out, logits_host.data(), 0,
-                                    logits_host.size() * sizeof(float));
-            const float * last_logits = logits_host.data() +
-                                        static_cast<size_t>(prompt_len - 1) *
-                                        vocab_size;
-            float best = last_logits[0];
+            const int64_t      vocab_size = db.out->ne[0];
+            std::vector<float> logits_host(static_cast<size_t>(vocab_size) * prompt_len);
+            ggml_backend_tensor_get(db.out, logits_host.data(), 0, logits_host.size() * sizeof(float));
+            const float * last_logits = logits_host.data() + static_cast<size_t>(prompt_len - 1) * vocab_size;
+            float         best        = last_logits[0];
             for (int j = 1; j < static_cast<int>(vocab_size); ++j) {
                 if (last_logits[j] > best) {
-                    best = last_logits[j];
+                    best       = last_logits[j];
                     next_token = j;
                 }
             }
@@ -1193,12 +1082,13 @@ transcribe_status run(
         auto commit_result = [&]() {
             cc->t_decode_us = ggml_time_us() - t_dec_start;
 
-            if (generated_ids.empty()) return;
+            if (generated_ids.empty()) {
+                return;
+            }
 
             const transcribe::Tokenizer & tok = cm->tok;
 
-            std::string full = tok.decode(generated_ids.data(),
-                                          static_cast<int>(generated_ids.size()));
+            std::string full = tok.decode(generated_ids.data(), static_cast<int>(generated_ids.size()));
             if (!full.empty() && full.front() == ' ') {
                 full.erase(full.begin());
             }
@@ -1229,10 +1119,9 @@ transcribe_status run(
         //     to amortize, so the static-graph bandwidth tax is a net loss.
         int n_past = prompt_len;
 
-        const bool primary_is_gpu =
-            cm->plan.primary_kind != transcribe::BackendKind::Cpu &&
-            cm->plan.primary_kind != transcribe::BackendKind::Accel &&
-            cm->plan.primary_kind != transcribe::BackendKind::Unknown;
+        const bool primary_is_gpu = cm->plan.primary_kind != transcribe::BackendKind::Cpu &&
+                                    cm->plan.primary_kind != transcribe::BackendKind::Accel &&
+                                    cm->plan.primary_kind != transcribe::BackendKind::Unknown;
 
         if (primary_is_gpu) {
             // ---------- Static-graph step path (GPU) ----------
@@ -1240,28 +1129,30 @@ transcribe_status run(
             // dispatches faster on pow2 ne[1], and the static graph amortizes
             // the slight bandwidth cost.
             int max_n_kv = 1024;
-            while (max_n_kv < prompt_len + max_tokens) max_n_kv *= 2;
-            if (max_n_kv > cc->kv_cache.n_ctx) max_n_kv = cc->kv_cache.n_ctx;
+            while (max_n_kv < prompt_len + max_tokens) {
+                max_n_kv *= 2;
+            }
+            if (max_n_kv > cc->kv_cache.n_ctx) {
+                max_n_kv = cc->kv_cache.n_ctx;
+            }
 
             if (!new_compute_ctx(8 * 1024 * 1024)) {
                 transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                    "cohere run: new_compute_ctx failed (step) — out of memory.");
+                                    "cohere run: new_compute_ctx failed (step) — out of memory.");
                 commit_result();
                 return TRANSCRIBE_ERR_OOM;
             }
-            StepBuild sb = build_step_graph(
-                cc->compute_ctx, cm->weights, cm->hparams, cc->kv_cache,
-                max_n_kv, T_enc, cc->decoder_use_flash);
+            StepBuild sb = build_step_graph(cc->compute_ctx, cm->weights, cm->hparams, cc->kv_cache, max_n_kv, T_enc,
+                                            cc->decoder_use_flash);
             if (sb.graph == nullptr || sb.argmax_out == nullptr) {
-                log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                             "cohere run: build_step_graph failed");
+                log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "cohere run: build_step_graph failed");
                 commit_result();
                 return TRANSCRIBE_ERR_GGUF;
             }
             ggml_backend_sched_reset(cc->sched);
             if (!ggml_backend_sched_alloc_graph(cc->sched, sb.graph)) {
                 transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                    "cohere run: step graph allocation failed — out of memory.");
+                                    "cohere run: step graph allocation failed — out of memory.");
                 commit_result();
                 return TRANSCRIBE_ERR_OOM;
             }
@@ -1270,14 +1161,14 @@ transcribe_status run(
             // already populated by the prompt pass [0, prompt_len) start
             // attendable; remaining slots are -inf until each step flips
             // its newly-written position to attendable.
-            const ggml_fp16_t mask_zero    = ggml_fp32_to_fp16(0.0f);
-            const ggml_fp16_t mask_neg_inf = ggml_fp32_to_fp16(-INFINITY);
+            const ggml_fp16_t        mask_zero    = ggml_fp32_to_fp16(0.0f);
+            const ggml_fp16_t        mask_neg_inf = ggml_fp32_to_fp16(-INFINITY);
             std::vector<ggml_fp16_t> step_mask(max_n_kv, mask_neg_inf);
-            for (int p = 0; p < prompt_len; ++p) step_mask[p] = mask_zero;
+            for (int p = 0; p < prompt_len; ++p) {
+                step_mask[p] = mask_zero;
+            }
 
-            for (int step = 1; step < max_tokens && next_token != eos_id;
-                 ++step)
-            {
+            for (int step = 1; step < max_tokens && next_token != eos_id; ++step) {
                 if (cc->poll_abort()) {
                     commit_result();
                     return TRANSCRIBE_ERR_ABORTED;
@@ -1286,12 +1177,11 @@ transcribe_status run(
                     // Hit the self-KV window before EOS: keep the partial
                     // transcript, flag truncation, warn — never discard it.
                     cc->was_truncated = true;
-                    transcribe::log_msg(
-                        TRANSCRIBE_LOG_LEVEL_WARN,
-                        "cohere run: output truncated at %d tokens — decode "
-                        "reached the context/budget before end-of-stream; "
-                        "transcript may be incomplete.",
-                        static_cast<int>(generated_ids.size()));
+                    transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_WARN,
+                                        "cohere run: output truncated at %d tokens — decode "
+                                        "reached the context/budget before end-of-stream; "
+                                        "transcript may be incomplete.",
+                                        static_cast<int>(generated_ids.size()));
                     break;
                 }
 
@@ -1299,21 +1189,17 @@ transcribe_status run(
                 int32_t pos_val   = n_past;
                 int64_t kv_val    = n_past;
                 ggml_backend_tensor_set(sb.token_id_in, &token_val, 0, sizeof(int32_t));
-                ggml_backend_tensor_set(sb.pos_id_in,   &pos_val,   0, sizeof(int32_t));
-                ggml_backend_tensor_set(sb.kv_idx_in,   &kv_val,    0, sizeof(int64_t));
+                ggml_backend_tensor_set(sb.pos_id_in, &pos_val, 0, sizeof(int32_t));
+                ggml_backend_tensor_set(sb.kv_idx_in, &kv_val, 0, sizeof(int64_t));
 
                 step_mask[n_past] = mask_zero;
                 ggml_backend_tensor_set(sb.mask_in, step_mask.data(), 0,
-                                        static_cast<size_t>(max_n_kv) *
-                                        sizeof(ggml_fp16_t));
-
-                if (const ggml_status gs =
-                        ggml_backend_sched_graph_compute(cc->sched, sb.graph);
-                    gs != GGML_STATUS_SUCCESS)
-                {
-                    log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                                 "cohere run: step compute failed (%d, n_past=%d)",
-                                 static_cast<int>(gs), n_past);
+                                        static_cast<size_t>(max_n_kv) * sizeof(ggml_fp16_t));
+
+                if (const ggml_status gs = ggml_backend_sched_graph_compute(cc->sched, sb.graph);
+                    gs != GGML_STATUS_SUCCESS) {
+                    log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "cohere run: step compute failed (%d, n_past=%d)",
+                            static_cast<int>(gs), n_past);
                     commit_result();
                     return TRANSCRIBE_ERR_GGUF;
                 }
@@ -1326,28 +1212,26 @@ transcribe_status run(
                 ggml_backend_tensor_get(sb.argmax_out, &argmax_id, 0, sizeof(int32_t));
                 next_token = argmax_id;
 
-                if (next_token != eos_id) generated_ids.push_back(next_token);
+                if (next_token != eos_id) {
+                    generated_ids.push_back(next_token);
+                }
             }
         } else {
             // ---------- Dynamic-graph step path (CPU) ----------
             // Reserve scheduler buffers with a worst-case single-token graph
             // (n_past = n_ctx - 1) so alloc_graph never reallocates in-loop.
             if (new_compute_ctx(4 * 1024 * 1024)) {
-                const int worst_n_past = cc->kv_cache.n_ctx - 1;
-                DecoderBuild db_reserve = build_decoder_graph_kv(
-                    cc->compute_ctx, cm->weights, cm->hparams,
-                    cc->kv_cache,
-                    /*n_tokens=*/1, worst_n_past, T_enc,
-                    /*skip_log_softmax=*/true,
-                    cc->decoder_use_flash);
+                const int    worst_n_past = cc->kv_cache.n_ctx - 1;
+                DecoderBuild db_reserve =
+                    build_decoder_graph_kv(cc->compute_ctx, cm->weights, cm->hparams, cc->kv_cache,
+                                           /*n_tokens=*/1, worst_n_past, T_enc,
+                                           /*skip_log_softmax=*/true, cc->decoder_use_flash);
                 if (db_reserve.graph != nullptr) {
                     ggml_backend_sched_reserve(cc->sched, db_reserve.graph);
                 }
             }
 
-            for (int step = 1; step < max_tokens && next_token != eos_id;
-                 ++step)
-            {
+            for (int step = 1; step < max_tokens && next_token != eos_id; ++step) {
                 if (cc->poll_abort()) {
                     commit_result();
                     return TRANSCRIBE_ERR_ABORTED;
@@ -1357,41 +1241,37 @@ transcribe_status run(
                     // Filled the self-KV cache before EOS: keep the partial
                     // transcript, flag truncation, warn — never discard it.
                     cc->was_truncated = true;
-                    transcribe::log_msg(
-                        TRANSCRIBE_LOG_LEVEL_WARN,
-                        "cohere run: output truncated at %d tokens — decode "
-                        "reached the context/budget before end-of-stream; "
-                        "transcript may be incomplete.",
-                        static_cast<int>(generated_ids.size()));
+                    transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_WARN,
+                                        "cohere run: output truncated at %d tokens — decode "
+                                        "reached the context/budget before end-of-stream; "
+                                        "transcript may be incomplete.",
+                                        static_cast<int>(generated_ids.size()));
                     break;
                 }
 
-                if (!new_compute_ctx(4 * 1024 * 1024)) break;
+                if (!new_compute_ctx(4 * 1024 * 1024)) {
+                    break;
+                }
 
-                DecoderBuild db_step = build_decoder_graph_kv(
-                    cc->compute_ctx, cm->weights, cm->hparams,
-                    cc->kv_cache,
-                    /*n_tokens=*/1, n_past, T_enc,
-                    /*skip_log_softmax=*/true,
-                    cc->decoder_use_flash);
-                if (db_step.out == nullptr || db_step.graph == nullptr) break;
+                DecoderBuild db_step = build_decoder_graph_kv(cc->compute_ctx, cm->weights, cm->hparams, cc->kv_cache,
+                                                              /*n_tokens=*/1, n_past, T_enc,
+                                                              /*skip_log_softmax=*/true, cc->decoder_use_flash);
+                if (db_step.out == nullptr || db_step.graph == nullptr) {
+                    break;
+                }
 
                 ggml_backend_sched_reset(cc->sched);
-                if (!ggml_backend_sched_alloc_graph(cc->sched, db_step.graph))
+                if (!ggml_backend_sched_alloc_graph(cc->sched, db_step.graph)) {
                     break;
+                }
 
                 int32_t token_id = next_token;
                 int32_t pos_id   = n_past;
-                ggml_backend_tensor_set(db_step.token_ids_in,
-                                        &token_id, 0, sizeof(int32_t));
-                ggml_backend_tensor_set(db_step.pos_ids_in,
-                                        &pos_id, 0, sizeof(int32_t));
-
-                if (const ggml_status gs =
-                        ggml_backend_sched_graph_compute(cc->sched,
-                                                         db_step.graph);
-                    gs != GGML_STATUS_SUCCESS)
-                {
+                ggml_backend_tensor_set(db_step.token_ids_in, &token_id, 0, sizeof(int32_t));
+                ggml_backend_tensor_set(db_step.pos_ids_in, &pos_id, 0, sizeof(int32_t));
+
+                if (const ggml_status gs = ggml_backend_sched_graph_compute(cc->sched, db_step.graph);
+                    gs != GGML_STATUS_SUCCESS) {
                     break;
                 }
 
@@ -1400,8 +1280,7 @@ transcribe_status run(
                 cc->kv_cache.head = n_past;
 
                 int32_t argmax_id = 0;
-                ggml_backend_tensor_get(db_step.argmax_out, &argmax_id,
-                                        0, sizeof(int32_t));
+                ggml_backend_tensor_get(db_step.argmax_out, &argmax_id, 0, sizeof(int32_t));
                 next_token = argmax_id;
 
                 if (next_token != eos_id) {
@@ -1416,12 +1295,11 @@ transcribe_status run(
         // the normal-exit-at-budget case.
         if (!cc->was_truncated && next_token != eos_id) {
             cc->was_truncated = true;
-            transcribe::log_msg(
-                TRANSCRIBE_LOG_LEVEL_WARN,
-                "cohere run: output truncated at %d tokens — decode reached "
-                "the context/budget before end-of-stream; transcript may be "
-                "incomplete.",
-                static_cast<int>(generated_ids.size()));
+            transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_WARN,
+                                "cohere run: output truncated at %d tokens — decode reached "
+                                "the context/budget before end-of-stream; transcript may be "
+                                "incomplete.",
+                                static_cast<int>(generated_ids.size()));
         }
 
         // Build the result. max_timestamp_kind == NONE means text but no
@@ -1451,166 +1329,192 @@ transcribe_status run(
 // prompt feeds through the same batched step graph (prompt_len steps).
 
 // Encoder for one utterance from a precomputed mel buffer → host [hidden, T_enc].
-transcribe_status encode_one_to_host(
-    CohereSession * cc, CohereModel * cm,
-    const std::vector<float> & mel_buf, int mel_n_frames,
-    std::vector<float> & enc_host_out, int & T_enc_out, int64_t & enc_us)
-{
-    if (mel_n_frames <= 0) return TRANSCRIBE_ERR_INVALID_ARG;
-
-    if (cc->compute_ctx != nullptr) { ggml_free(cc->compute_ctx); cc->compute_ctx = nullptr; }
+transcribe_status encode_one_to_host(CohereSession *            cc,
+                                     CohereModel *              cm,
+                                     const std::vector<float> & mel_buf,
+                                     int                        mel_n_frames,
+                                     std::vector<float> &       enc_host_out,
+                                     int &                      T_enc_out,
+                                     int64_t &                  enc_us) {
+    if (mel_n_frames <= 0) {
+        return TRANSCRIBE_ERR_INVALID_ARG;
+    }
+
+    if (cc->compute_ctx != nullptr) {
+        ggml_free(cc->compute_ctx);
+        cc->compute_ctx = nullptr;
+    }
     cc->encoder_out = nullptr;
-    { ggml_init_params ip {}; ip.mem_size = 8 * 1024 * 1024; ip.mem_buffer = nullptr;
-      ip.no_alloc = true; cc->compute_ctx = ggml_init(ip);
-      if (cc->compute_ctx == nullptr) {
-          transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-              "cohere encode_one_to_host: ggml_init failed — out of memory.");
-          return TRANSCRIBE_ERR_OOM;
-      } }
+    {
+        ggml_init_params ip{};
+        ip.mem_size     = 8 * 1024 * 1024;
+        ip.mem_buffer   = nullptr;
+        ip.no_alloc     = true;
+        cc->compute_ctx = ggml_init(ip);
+        if (cc->compute_ctx == nullptr) {
+            transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
+                                "cohere encode_one_to_host: ggml_init failed — out of memory.");
+            return TRANSCRIBE_ERR_OOM;
+        }
+    }
 
     ggml_type resolved_kv = GGML_TYPE_COUNT;
-    if (cc->kv_type == TRANSCRIBE_KV_TYPE_F32) resolved_kv = GGML_TYPE_F32;
-    if (cc->kv_type == TRANSCRIBE_KV_TYPE_F16) resolved_kv = GGML_TYPE_F16;
+    if (cc->kv_type == TRANSCRIBE_KV_TYPE_F32) {
+        resolved_kv = GGML_TYPE_F32;
+    }
+    if (cc->kv_type == TRANSCRIBE_KV_TYPE_F16) {
+        resolved_kv = GGML_TYPE_F16;
+    }
 
-    EncoderBuild eb = build_encoder_graph(
-        cc->compute_ctx, cm->weights, cm->hparams, mel_n_frames,
-        resolved_kv, cc->encoder_use_flash, cm->backend.c_str());
-    if (eb.out == nullptr || eb.graph == nullptr) return TRANSCRIBE_ERR_GGUF;
+    EncoderBuild eb = build_encoder_graph(cc->compute_ctx, cm->weights, cm->hparams, mel_n_frames, resolved_kv,
+                                          cc->encoder_use_flash, cm->backend.c_str());
+    if (eb.out == nullptr || eb.graph == nullptr) {
+        return TRANSCRIBE_ERR_GGUF;
+    }
 
     if (cc->sched == nullptr) {
-        cc->sched = ggml_backend_sched_new(
-            cm->plan.scheduler_list.data(), nullptr,
-            static_cast<int>(cm->plan.scheduler_list.size()), 16384, false, true);
-        if (cc->sched == nullptr) return TRANSCRIBE_ERR_GGUF;
+        cc->sched = ggml_backend_sched_new(cm->plan.scheduler_list.data(), nullptr,
+                                           static_cast<int>(cm->plan.scheduler_list.size()), 16384, false, true);
+        if (cc->sched == nullptr) {
+            return TRANSCRIBE_ERR_GGUF;
+        }
     }
     ggml_backend_sched_reset(cc->sched);
     if (!ggml_backend_sched_alloc_graph(cc->sched, eb.graph)) {
         transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "cohere encode_one_to_host: encoder graph allocation failed — out of memory.");
+                            "cohere encode_one_to_host: encoder graph allocation failed — out of memory.");
         return TRANSCRIBE_ERR_OOM;
     }
 
     ggml_backend_tensor_set(eb.mel_in, mel_buf.data(), 0, mel_buf.size() * sizeof(float));
 
     if (eb.pos_emb_in != nullptr) {
-        const int d_model = cm->hparams.enc_d_model;
-        const int pos_len = static_cast<int>(eb.pos_emb_in->ne[1]);
-        const int T_enc   = (pos_len + 1) / 2;
+        const int          d_model = cm->hparams.enc_d_model;
+        const int          pos_len = static_cast<int>(eb.pos_emb_in->ne[1]);
+        const int          T_enc   = (pos_len + 1) / 2;
         std::vector<float> pos_buf(static_cast<size_t>(pos_len) * d_model, 0.0f);
-        const float ln_10000 = std::log(10000.0f);
+        const float        ln_10000 = std::log(10000.0f);
         std::vector<float> div_term(static_cast<size_t>(d_model / 2));
-        for (int k = 0; k < d_model / 2; ++k)
-            div_term[k] = std::exp(static_cast<float>(2 * k) *
-                                   (-ln_10000 / static_cast<float>(d_model)));
+        for (int k = 0; k < d_model / 2; ++k) {
+            div_term[k] = std::exp(static_cast<float>(2 * k) * (-ln_10000 / static_cast<float>(d_model)));
+        }
         for (int i = 0; i < pos_len; ++i) {
-            const float p = static_cast<float>((T_enc - 1) - i);
-            float * row = pos_buf.data() + static_cast<size_t>(i) * d_model;
+            const float p   = static_cast<float>((T_enc - 1) - i);
+            float *     row = pos_buf.data() + static_cast<size_t>(i) * d_model;
             for (int k = 0; k < d_model / 2; ++k) {
                 row[2 * k]     = std::sin(p * div_term[k]);
                 row[2 * k + 1] = std::cos(p * div_term[k]);
             }
         }
-        ggml_backend_tensor_set(eb.pos_emb_in, pos_buf.data(), 0,
-                                pos_buf.size() * sizeof(float));
+        ggml_backend_tensor_set(eb.pos_emb_in, pos_buf.data(), 0, pos_buf.size() * sizeof(float));
     }
 
     transcribe::configure_sched_n_threads(cc->sched, cc->n_threads);
 
     const int64_t t0 = ggml_time_us();
-    if (ggml_backend_sched_graph_compute(cc->sched, eb.graph) != GGML_STATUS_SUCCESS)
+    if (ggml_backend_sched_graph_compute(cc->sched, eb.graph) != GGML_STATUS_SUCCESS) {
         return TRANSCRIBE_ERR_GGUF;
+    }
     enc_us += ggml_time_us() - t0;
 
     const int d_enc = static_cast<int>(eb.out->ne[0]);
     const int T_enc = static_cast<int>(eb.out->ne[1]);
-    if (d_enc <= 0 || T_enc <= 0) return TRANSCRIBE_ERR_GGUF;
+    if (d_enc <= 0 || T_enc <= 0) {
+        return TRANSCRIBE_ERR_GGUF;
+    }
     enc_host_out.resize(static_cast<size_t>(d_enc) * T_enc);
-    ggml_backend_tensor_get(eb.out, enc_host_out.data(), 0,
-                            enc_host_out.size() * sizeof(float));
+    ggml_backend_tensor_get(eb.out, enc_host_out.data(), 0, enc_host_out.size() * sizeof(float));
     T_enc_out = T_enc;
     return TRANSCRIBE_OK;
 }
 
-transcribe_status run_batch_serial(CohereSession * cc,
-                                   const float * const * pcm,
-                                   const int * n_samples, int n,
+transcribe_status run_batch_serial(CohereSession *               cc,
+                                   const float * const *         pcm,
+                                   const int *                   n_samples,
+                                   int                           n,
                                    const transcribe_run_params * params) {
     for (int i = 0; i < n; ++i) {
-        if (cc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
-        const transcribe_status st =
-            (pcm[i] == nullptr || n_samples[i] <= 0)
-                ? TRANSCRIBE_ERR_INVALID_ARG
-                : run(cc, pcm[i], n_samples[i], params);
+        if (cc->poll_abort()) {
+            return TRANSCRIBE_ERR_ABORTED;
+        }
+        const transcribe_status st = (pcm[i] == nullptr || n_samples[i] <= 0) ? TRANSCRIBE_ERR_INVALID_ARG :
+                                                                                run(cc, pcm[i], n_samples[i], params);
         if (st == TRANSCRIBE_OK) {
             cc->batch_results.push_back(cc->capture_result(st));
         } else {
-            transcribe_session::ResultSet rs; rs.status = st;
+            transcribe_session::ResultSet rs;
+            rs.status = st;
             cc->batch_results.push_back(std::move(rs));
         }
     }
     return TRANSCRIBE_OK;
 }
 
-transcribe_status run_batch(
-    transcribe_session *          session,
-    const float * const *         pcm,
-    const int *                   n_samples,
-    int                           n,
-    const transcribe_run_params * params)
-{
-    if (session == nullptr || pcm == nullptr || n_samples == nullptr || n <= 0)
+transcribe_status run_batch(transcribe_session *          session,
+                            const float * const *         pcm,
+                            const int *                   n_samples,
+                            int                           n,
+                            const transcribe_run_params * params) {
+    if (session == nullptr || pcm == nullptr || n_samples == nullptr || n <= 0) {
         return TRANSCRIBE_ERR_INVALID_ARG;
+    }
     auto * cc = static_cast<CohereSession *>(session);
     auto * cm = static_cast<CohereModel *>(cc->model);
-    if (cm == nullptr || cm->plan.scheduler_list.empty() || !cm->mel.has_value())
+    if (cm == nullptr || cm->plan.scheduler_list.empty() || !cm->mel.has_value()) {
         return TRANSCRIBE_ERR_INVALID_ARG;
+    }
 
     // Batched decode requires the flash step path; fall back to serial for
     // n==1, the CPU/manual path, or when debug dumping is active.
-    const bool primary_is_gpu =
-        cm->plan.primary_kind != transcribe::BackendKind::Cpu &&
-        cm->plan.primary_kind != transcribe::BackendKind::Accel &&
-        cm->plan.primary_kind != transcribe::BackendKind::Unknown;
-    if (n == 1 || !cc->decoder_use_flash || !primary_is_gpu ||
-        transcribe::debug::enabled())
+    const bool primary_is_gpu = cm->plan.primary_kind != transcribe::BackendKind::Cpu &&
+                                cm->plan.primary_kind != transcribe::BackendKind::Accel &&
+                                cm->plan.primary_kind != transcribe::BackendKind::Unknown;
+    if (n == 1 || !cc->decoder_use_flash || !primary_is_gpu || transcribe::debug::enabled()) {
         return run_batch_serial(cc, pcm, n_samples, n, params);
+    }
 
     transcribe::debug::init();
-    const auto & hp = cm->hparams;
-    const int hidden  = hp.dec_hidden;
-    const int n_layer = hp.dec_n_layers;
+    const auto & hp      = cm->hparams;
+    const int    hidden  = hp.dec_hidden;
+    const int    n_layer = hp.dec_n_layers;
 
     // ----- Shared prompt (identical across the batch) -----
-    const char * lang = (params && params->language) ? params->language : "en";
-    const std::string lang_token = std::string("<|") + lang + "|>";
+    const char *                   lang          = (params && params->language) ? params->language : "en";
+    const std::string              lang_token    = std::string("<|") + lang + "|>";
     const std::vector<std::string> prompt_pieces = {
-        "\xe2\x96\x81", "<|startofcontext|>", "<|startoftranscript|>",
-        "<|emo:undefined|>", lang_token, lang_token,
-        "<|pnc|>", "<|noitn|>", "<|notimestamp|>", "<|nodiarize|>",
+        "\xe2\x96\x81", "<|startofcontext|>", "<|startoftranscript|>", "<|emo:undefined|>", lang_token, lang_token,
+        "<|pnc|>",      "<|noitn|>",          "<|notimestamp|>",       "<|nodiarize|>",
     };
     std::vector<int32_t> prompt_ids;
     for (const auto & piece : prompt_pieces) {
         const int id = cm->tok.find(piece);
-        if (id < 0) return TRANSCRIBE_ERR_INVALID_ARG;
+        if (id < 0) {
+            return TRANSCRIBE_ERR_INVALID_ARG;
+        }
         prompt_ids.push_back(id);
     }
     const int prompt_len = static_cast<int>(prompt_ids.size());
 
     // ----- Pass 0: parallel mel -----
-    std::vector<char> valid(n, 0);
+    std::vector<char>               valid(n, 0);
     std::vector<std::vector<float>> mel_bufs(n);
-    std::vector<int> mel_nf(n, 0);
-    int n_threads = cc->n_threads;
-    if (n_threads <= 0) n_threads = transcribe::default_n_threads();
-    int64_t mel_us = 0, enc_us = 0;
+    std::vector<int>                mel_nf(n, 0);
+    int                             n_threads = cc->n_threads;
+    if (n_threads <= 0) {
+        n_threads = transcribe::default_n_threads();
+    }
+    int64_t       mel_us = 0, enc_us = 0;
     const int64_t t_mel0 = ggml_time_us();
     transcribe::parallel_for_all(n, n_threads, [&](int b) {
-        if (pcm[b] == nullptr || n_samples[b] <= 0) return true;
+        if (pcm[b] == nullptr || n_samples[b] <= 0) {
+            return true;
+        }
         int nm = 0, nf = 0;
-        if (cm->mel->compute(pcm[b], static_cast<size_t>(n_samples[b]),
-                             mel_bufs[b], nm, nf, /*n_threads=*/1) == TRANSCRIBE_OK
-            && nf > 0) {
-            mel_nf[b] = nf; valid[b] = 1;
+        if (cm->mel->compute(pcm[b], static_cast<size_t>(n_samples[b]), mel_bufs[b], nm, nf, /*n_threads=*/1) ==
+                TRANSCRIBE_OK &&
+            nf > 0) {
+            mel_nf[b] = nf;
+            valid[b]  = 1;
         }
         return true;
     });
@@ -1620,76 +1524,88 @@ transcribe_status run_batch(
     // Per-utterance input-length gate (same enc_pos_emb_max_len limit as
     // run()). An over-length utterance is marked invalid with INPUT_TOO_LONG
     // so the rest of the batch still decodes.
-    std::vector<transcribe_status> reject_status(n, TRANSCRIBE_ERR_INVALID_ARG);
+    std::vector<transcribe_status>  reject_status(n, TRANSCRIBE_ERR_INVALID_ARG);
     std::vector<std::vector<float>> enc_hosts(n);
-    std::vector<int> T_enc(n, 0);
-    int T_enc_max = 0;
+    std::vector<int>                T_enc(n, 0);
+    int                             T_enc_max = 0;
     for (int b = 0; b < n; ++b) {
-        if (cc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
-        if (!valid[b]) continue;
+        if (cc->poll_abort()) {
+            return TRANSCRIBE_ERR_ABORTED;
+        }
+        if (!valid[b]) {
+            continue;
+        }
         if (cm->hparams.enc_pos_emb_max_len > 0) {
-            const int t_enc_pred = cohere_predict_t_enc(
-                mel_nf[b], cm->hparams.enc_subsampling_factor);
+            const int t_enc_pred = cohere_predict_t_enc(mel_nf[b], cm->hparams.enc_subsampling_factor);
             if (t_enc_pred > cm->hparams.enc_pos_emb_max_len) {
-                const double max_s =
-                    static_cast<double>(cm->caps.max_audio_ms) / 1000.0;
-                transcribe::log_msg(
-                    TRANSCRIBE_LOG_LEVEL_ERROR,
-                    "cohere run_batch: utterance %d too long — %d encoder frames "
-                    "exceed the %d the model supports (~%.0f s max). See "
-                    "transcribe_capabilities.max_audio_ms.",
-                    b, t_enc_pred, cm->hparams.enc_pos_emb_max_len, max_s);
+                const double max_s = static_cast<double>(cm->caps.max_audio_ms) / 1000.0;
+                transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
+                                    "cohere run_batch: utterance %d too long — %d encoder frames "
+                                    "exceed the %d the model supports (~%.0f s max). See "
+                                    "transcribe_capabilities.max_audio_ms.",
+                                    b, t_enc_pred, cm->hparams.enc_pos_emb_max_len, max_s);
                 reject_status[b] = TRANSCRIBE_ERR_INPUT_TOO_LONG;
-                valid[b] = 0;
+                valid[b]         = 0;
                 continue;
             }
         }
-        if (encode_one_to_host(cc, cm, mel_bufs[b], mel_nf[b],
-                               enc_hosts[b], T_enc[b], enc_us) != TRANSCRIBE_OK
-            || T_enc[b] <= 0) {
-            valid[b] = 0; continue;
+        if (encode_one_to_host(cc, cm, mel_bufs[b], mel_nf[b], enc_hosts[b], T_enc[b], enc_us) != TRANSCRIBE_OK ||
+            T_enc[b] <= 0) {
+            valid[b] = 0;
+            continue;
         }
         T_enc_max = std::max(T_enc_max, T_enc[b]);
     }
     if (T_enc_max <= 0) {
         for (int b = 0; b < n; ++b) {
-            transcribe_session::ResultSet rs; rs.status = reject_status[b];
+            transcribe_session::ResultSet rs;
+            rs.status = reject_status[b];
             cc->batch_results.push_back(std::move(rs));
         }
         return TRANSCRIBE_OK;
     }
 
     // ----- Allocate batched KV cache -----
-    const int max_new = std::min(512, /*budget*/ 4096);
-    int max_n_kv = 1024;
-    while (max_n_kv < prompt_len + max_new) max_n_kv *= 2;
+    const int max_new  = std::min(512, /*budget*/ 4096);
+    int       max_n_kv = 1024;
+    while (max_n_kv < prompt_len + max_new) {
+        max_n_kv *= 2;
+    }
     // Honor the session context cap (same ceiling the single-shot path uses),
     // not the raw model max — so a lowered n_ctx bounds batch decoder KV too.
     const int n_ctx_cap = cohere_dec_ctx_ceiling(cc->n_ctx, hp);
-    if (max_n_kv > n_ctx_cap) max_n_kv = n_ctx_cap;
+    if (max_n_kv > n_ctx_cap) {
+        max_n_kv = n_ctx_cap;
+    }
 
-    ggml_type kv_type = (cc->kv_type == TRANSCRIBE_KV_TYPE_F32)
-                      ? GGML_TYPE_F32 : GGML_TYPE_F16;
+    ggml_type kv_type = (cc->kv_type == TRANSCRIBE_KV_TYPE_F32) ? GGML_TYPE_F32 : GGML_TYPE_F16;
     if (cc->kv_cache.buffer != nullptr &&
-        (cc->kv_cache.n_batch != n || cc->kv_cache.T_enc != T_enc_max ||
-         cc->kv_cache.n_ctx != max_n_kv))
+        (cc->kv_cache.n_batch != n || cc->kv_cache.T_enc != T_enc_max || cc->kv_cache.n_ctx != max_n_kv)) {
         cc->kv_cache.free();
+    }
     if (cc->kv_cache.buffer == nullptr) {
-        if (!kv_cache_init_batched(cc->kv_cache, cm->plan.primary,
-                                   max_n_kv, T_enc_max, hidden, n_layer, n, kv_type)) {
+        if (!kv_cache_init_batched(cc->kv_cache, cm->plan.primary, max_n_kv, T_enc_max, hidden, n_layer, n, kv_type)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "cohere run_batch: batched KV cache allocation failed — out of memory.");
+                                "cohere run_batch: batched KV cache allocation failed — out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
     } else {
         ggml_backend_buffer_clear(cc->kv_cache.buffer, 0);
-        cc->kv_cache.n = 0; cc->kv_cache.head = 0; cc->kv_cache.cross_populated = false;
+        cc->kv_cache.n               = 0;
+        cc->kv_cache.head            = 0;
+        cc->kv_cache.cross_populated = false;
     }
 
     auto new_compute_ctx = [&](size_t mem) -> bool {
-        if (cc->compute_ctx != nullptr) { ggml_free(cc->compute_ctx); cc->compute_ctx = nullptr; }
+        if (cc->compute_ctx != nullptr) {
+            ggml_free(cc->compute_ctx);
+            cc->compute_ctx = nullptr;
+        }
         cc->encoder_out = nullptr;
-        ggml_init_params ip {}; ip.mem_size = mem; ip.mem_buffer = nullptr; ip.no_alloc = true;
+        ggml_init_params ip{};
+        ip.mem_size     = mem;
+        ip.mem_buffer   = nullptr;
+        ip.no_alloc     = true;
         cc->compute_ctx = ggml_init(ip);
         return cc->compute_ctx != nullptr;
     };
@@ -1700,30 +1616,32 @@ transcribe_status run_batch(
     {
         if (!new_compute_ctx(8 * 1024 * 1024)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "cohere run_batch: ggml_init for cross_kv failed — out of memory.");
+                                "cohere run_batch: ggml_init for cross_kv failed — out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
-        DecoderBuild cross = build_cross_kv_graph_batched(
-            cc->compute_ctx, cm->weights, hp, cc->kv_cache, T_enc_max, n);
-        if (cross.graph == nullptr) return TRANSCRIBE_ERR_GGUF;
+        DecoderBuild cross = build_cross_kv_graph_batched(cc->compute_ctx, cm->weights, hp, cc->kv_cache, T_enc_max, n);
+        if (cross.graph == nullptr) {
+            return TRANSCRIBE_ERR_GGUF;
+        }
         ggml_backend_sched_reset(cc->sched);
         if (!ggml_backend_sched_alloc_graph(cc->sched, cross.graph)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "cohere run_batch: cross_kv graph allocation failed — out of memory.");
+                                "cohere run_batch: cross_kv graph allocation failed — out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
         // Pack encoder outputs [hidden, T_enc_max, B], zero-padded.
         std::vector<float> packed(static_cast<size_t>(hidden) * T_enc_max * n, 0.0f);
         for (int b = 0; b < n; ++b) {
-            if (!valid[b]) continue;
-            std::memcpy(packed.data() + static_cast<size_t>(b) * T_enc_max * hidden,
-                        enc_hosts[b].data(),
+            if (!valid[b]) {
+                continue;
+            }
+            std::memcpy(packed.data() + static_cast<size_t>(b) * T_enc_max * hidden, enc_hosts[b].data(),
                         static_cast<size_t>(hidden) * T_enc[b] * sizeof(float));
         }
-        ggml_backend_tensor_set(cross.encoder_out_in, packed.data(), 0,
-                                packed.size() * sizeof(float));
-        if (ggml_backend_sched_graph_compute(cc->sched, cross.graph) != GGML_STATUS_SUCCESS)
+        ggml_backend_tensor_set(cross.encoder_out_in, packed.data(), 0, packed.size() * sizeof(float));
+        if (ggml_backend_sched_graph_compute(cc->sched, cross.graph) != GGML_STATUS_SUCCESS) {
             return TRANSCRIBE_ERR_GGUF;
+        }
         cc->kv_cache.cross_populated = true;
     }
 
@@ -1734,30 +1652,39 @@ transcribe_status run_batch(
     // KV cache persists), keeping per-step self-KV bandwidth within 2x of real.
     const ggml_fp16_t f16_zero = ggml_fp32_to_fp16(0.0f);
     const ggml_fp16_t f16_ninf = ggml_fp32_to_fp16(-INFINITY);
-    const int32_t eos_id = hp.eos_token_id;
+    const int32_t     eos_id   = hp.eos_token_id;
 
     // Fixed cross-pad mask [T_enc_max, 1, 1, B] (re-uploaded after rebuilds).
     std::vector<ggml_fp16_t> cmask(static_cast<size_t>(T_enc_max) * n, f16_ninf);
     for (int b = 0; b < n; ++b) {
-        const int real = valid[b] ? T_enc[b] : 1;  // >=1 valid col avoids NaN
+        const int     real = valid[b] ? T_enc[b] : 1;  // >=1 valid col avoids NaN
         ggml_fp16_t * base = cmask.data() + static_cast<size_t>(b) * T_enc_max;
         std::fill(base, base + std::min(real, T_enc_max), f16_zero);
     }
 
     int init_window = 64;
-    while (init_window > max_n_kv) init_window /= 2;
-    if (init_window < 1) init_window = max_n_kv;
-
-    StepBuildBatched sb {};
-    auto rebuild = [&](int win, transcribe::EncDecStepIO & io) -> bool {
-        if (!new_compute_ctx(16 * 1024 * 1024)) return false;
-        sb = build_step_graph_batched(cc->compute_ctx, cm->weights, hp,
-                                      cc->kv_cache, win, T_enc_max, n, cc->decoder_use_flash);
-        if (sb.graph == nullptr || sb.argmax_out == nullptr) return false;
+    while (init_window > max_n_kv) {
+        init_window /= 2;
+    }
+    if (init_window < 1) {
+        init_window = max_n_kv;
+    }
+
+    StepBuildBatched sb{};
+    auto             rebuild = [&](int win, transcribe::EncDecStepIO & io) -> bool {
+        if (!new_compute_ctx(16 * 1024 * 1024)) {
+            return false;
+        }
+        sb = build_step_graph_batched(cc->compute_ctx, cm->weights, hp, cc->kv_cache, win, T_enc_max, n,
+                                      cc->decoder_use_flash);
+        if (sb.graph == nullptr || sb.argmax_out == nullptr) {
+            return false;
+        }
         ggml_backend_sched_reset(cc->sched);
-        if (!ggml_backend_sched_alloc_graph(cc->sched, sb.graph)) return false;
-        ggml_backend_tensor_set(sb.cross_mask_in, cmask.data(), 0,
-                                cmask.size() * sizeof(ggml_fp16_t));
+        if (!ggml_backend_sched_alloc_graph(cc->sched, sb.graph)) {
+            return false;
+        }
+        ggml_backend_tensor_set(sb.cross_mask_in, cmask.data(), 0, cmask.size() * sizeof(ggml_fp16_t));
         io.token_ids = sb.token_ids_in;
         io.pos_ids   = sb.pos_ids_in;
         io.kv_idx    = sb.kv_idx_in;
@@ -1768,10 +1695,9 @@ transcribe_status run_batch(
     };
 
     std::vector<std::vector<int32_t>> generated(n);
-    std::vector<char> truncated;
+    std::vector<char>                 truncated;
     if (const transcribe_status st = transcribe::run_batched_encdec_step_loop(
-            cc, cc->sched, rebuild, prompt_ids, prompt_len, init_window,
-            max_new, max_n_kv, eos_id, n, valid, generated,
+            cc, cc->sched, rebuild, prompt_ids, prompt_len, init_window, max_new, max_n_kv, eos_id, n, valid, generated,
             /*n_steps_out=*/nullptr, &truncated);
         st != TRANSCRIBE_OK) {
         return st;
@@ -1779,29 +1705,34 @@ transcribe_status run_batch(
     const int64_t dec_us = ggml_time_us() - t_dec0;
 
     // ----- Capture -----
-    const int valid_count = std::max(1, static_cast<int>(
-        std::count(valid.begin(), valid.end(), char(1))));
+    const int valid_count = std::max(1, static_cast<int>(std::count(valid.begin(), valid.end(), char(1))));
     for (int b = 0; b < n; ++b) {
         transcribe_session::ResultSet rs;
-        if (!valid[b]) { rs.status = reject_status[b];
-                         cc->batch_results.push_back(std::move(rs)); continue; }
-        std::string full = cm->tok.decode(generated[b].data(),
-                                          static_cast<int>(generated[b].size()));
-        if (!full.empty() && full.front() == ' ') full.erase(full.begin());
-        transcribe_session::SegmentEntry seg {};
-        seg.t0_ms = 0; seg.t1_ms = 0; seg.text = full;
+        if (!valid[b]) {
+            rs.status = reject_status[b];
+            cc->batch_results.push_back(std::move(rs));
+            continue;
+        }
+        std::string full = cm->tok.decode(generated[b].data(), static_cast<int>(generated[b].size()));
+        if (!full.empty() && full.front() == ' ') {
+            full.erase(full.begin());
+        }
+        transcribe_session::SegmentEntry seg{};
+        seg.t0_ms = 0;
+        seg.t1_ms = 0;
+        seg.text  = full;
         rs.segments.push_back(std::move(seg));
-        rs.full_text = full;
+        rs.full_text   = full;
         rs.result_kind = TRANSCRIBE_TIMESTAMPS_NONE;
-        rs.has_result = true; rs.status = TRANSCRIBE_OK;
+        rs.has_result  = true;
+        rs.status      = TRANSCRIBE_OK;
         // Truncation parity with the single-shot path; only override an
         // otherwise-OK status, never a worse one.
-        if (rs.status == TRANSCRIBE_OK &&
-            b < static_cast<int>(truncated.size()) && truncated[b]) {
+        if (rs.status == TRANSCRIBE_OK && b < static_cast<int>(truncated.size()) && truncated[b]) {
             cc->was_truncated = true;
-            rs.status = TRANSCRIBE_ERR_OUTPUT_TRUNCATED;
+            rs.status         = TRANSCRIBE_ERR_OUTPUT_TRUNCATED;
         }
-        rs.t_mel_us = mel_us / valid_count;
+        rs.t_mel_us    = mel_us / valid_count;
         rs.t_encode_us = enc_us / valid_count;
         rs.t_decode_us = dec_us / valid_count;
         cc->batch_results.push_back(std::move(rs));
@@ -1809,15 +1740,14 @@ transcribe_status run_batch(
 
     if (transcribe::env::flag("TRANSCRIBE_PERF_DEBUG")) {
         log_msg(TRANSCRIBE_LOG_LEVEL_DEBUG,
-            "cohere run_batch: n=%d T_enc_max=%d kv_cap=%d prompt=%d\n"
-            "  mel=%.1fms (parallel)  enc=%.1fms (serial x%d)  decode=%.1fms (batched)",
-            n, T_enc_max, max_n_kv, prompt_len,
-            mel_us / 1000.0, enc_us / 1000.0, n, dec_us / 1000.0);
+                "cohere run_batch: n=%d T_enc_max=%d kv_cap=%d prompt=%d\n"
+                "  mel=%.1fms (parallel)  enc=%.1fms (serial x%d)  decode=%.1fms (batched)",
+                n, T_enc_max, max_n_kv, prompt_len, mel_us / 1000.0, enc_us / 1000.0, n, dec_us / 1000.0);
     }
     return TRANSCRIBE_OK;
 }
 
-} // namespace
+}  // namespace
 
 extern const Arch arch = {
     /* .name             = */ "cohere_asr",
@@ -1833,4 +1763,4 @@ extern const Arch arch = {
     /* .accepts_ext_kind = */ nullptr,
 };
 
-} // namespace transcribe::cohere
+}  // namespace transcribe::cohere
diff --git a/src/arch/cohere/weights.cpp b/src/arch/cohere/weights.cpp
index 510c5fc5..ab486897 100644
--- a/src/arch/cohere/weights.cpp
+++ b/src/arch/cohere/weights.cpp
@@ -9,12 +9,11 @@
 
 #include "weights.h"
 
-#include "transcribe-meta.h"
-#include "transcribe-weights-util.h"
-#include "transcribe-log.h"
-
 #include "ggml.h"
 #include "gguf.h"
+#include "transcribe-log.h"
+#include "transcribe-meta.h"
+#include "transcribe-weights-util.h"
 
 #include <cstdio>
 #include <cstring>
@@ -26,140 +25,213 @@ namespace {
 
 constexpr const char * kFamilyTag = "cohere";
 
-} // namespace
+}  // namespace
 
-transcribe_status read_cohere_hparams(const gguf_context * gguf,
-                                      CohereHParams &      hp)
-{
+transcribe_status read_cohere_hparams(const gguf_context * gguf, CohereHParams & hp) {
     if (gguf == nullptr) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
 
     // Encoder.
-    if (auto st = read_required_u32_kv(gguf, "stt.cohere.encoder.n_layers", kFamilyTag, hp.enc_n_layers);           st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.cohere.encoder.d_model", kFamilyTag, hp.enc_d_model);            st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.cohere.encoder.n_heads", kFamilyTag, hp.enc_n_heads);            st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.cohere.encoder.d_ff", kFamilyTag, hp.enc_d_ff);               st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.cohere.encoder.conv_kernel", kFamilyTag, hp.enc_conv_kernel);        st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.cohere.encoder.subsampling_factor", kFamilyTag, hp.enc_subsampling_factor); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.cohere.encoder.subsampling_channels", kFamilyTag, hp.enc_subsampling_channels); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.cohere.encoder.pos_emb_max_len", kFamilyTag, hp.enc_pos_emb_max_len);    st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_bool_kv(gguf, "stt.cohere.encoder.use_bias", kFamilyTag, true, hp.enc_use_bias); st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_u32_kv(gguf, "stt.cohere.encoder.n_layers", kFamilyTag, hp.enc_n_layers);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.cohere.encoder.d_model", kFamilyTag, hp.enc_d_model);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.cohere.encoder.n_heads", kFamilyTag, hp.enc_n_heads);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.cohere.encoder.d_ff", kFamilyTag, hp.enc_d_ff); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.cohere.encoder.conv_kernel", kFamilyTag, hp.enc_conv_kernel);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st =
+            read_required_u32_kv(gguf, "stt.cohere.encoder.subsampling_factor", kFamilyTag, hp.enc_subsampling_factor);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.cohere.encoder.subsampling_channels", kFamilyTag,
+                                       hp.enc_subsampling_channels);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.cohere.encoder.pos_emb_max_len", kFamilyTag, hp.enc_pos_emb_max_len);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_bool_kv(gguf, "stt.cohere.encoder.use_bias", kFamilyTag, true, hp.enc_use_bias);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Decoder.
-    if (auto st = read_required_u32_kv(gguf, "stt.cohere.decoder.n_layers", kFamilyTag, hp.dec_n_layers); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.cohere.decoder.hidden_size", kFamilyTag, hp.dec_hidden);   st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.cohere.decoder.n_heads", kFamilyTag, hp.dec_n_heads);  st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.cohere.decoder.inner_size", kFamilyTag, hp.dec_inner);    st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.cohere.decoder.max_seq_len", kFamilyTag, hp.dec_max_seq);  st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.cohere.decoder.activation", kFamilyTag, hp.dec_activation); st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_u32_kv(gguf, "stt.cohere.decoder.n_layers", kFamilyTag, hp.dec_n_layers);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.cohere.decoder.hidden_size", kFamilyTag, hp.dec_hidden);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.cohere.decoder.n_heads", kFamilyTag, hp.dec_n_heads);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.cohere.decoder.inner_size", kFamilyTag, hp.dec_inner);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.cohere.decoder.max_seq_len", kFamilyTag, hp.dec_max_seq);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_string_kv(gguf, "stt.cohere.decoder.activation", kFamilyTag, hp.dec_activation);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Token IDs. vocab_size comes from the tokenizer; decoder_start_token_id is explicit.
-    if (auto st = read_required_u32_kv(gguf, "stt.cohere.decoder_start_token_id", kFamilyTag, hp.decoder_start_token_id); st != TRANSCRIBE_OK) return st;
+    if (auto st =
+            read_required_u32_kv(gguf, "stt.cohere.decoder_start_token_id", kFamilyTag, hp.decoder_start_token_id);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Head.
-    if (auto st = read_optional_bool_kv(gguf, "stt.cohere.head.log_softmax", kFamilyTag, true, hp.head_log_softmax); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_bool_kv(gguf, "stt.cohere.head.tied_weights", kFamilyTag, true, hp.head_tied_weights); st != TRANSCRIBE_OK) return st;
+    if (auto st = read_optional_bool_kv(gguf, "stt.cohere.head.log_softmax", kFamilyTag, true, hp.head_log_softmax);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_bool_kv(gguf, "stt.cohere.head.tied_weights", kFamilyTag, true, hp.head_tied_weights);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Frontend.
-    if (auto st = read_required_string_kv(gguf, "stt.frontend.type", kFamilyTag, hp.fe_type);         st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.frontend.num_mels", kFamilyTag, hp.fe_num_mels);     st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.frontend.sample_rate", kFamilyTag, hp.fe_sample_rate);  st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.frontend.n_fft", kFamilyTag, hp.fe_n_fft);        st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.frontend.win_length", kFamilyTag, hp.fe_win_length);   st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.frontend.hop_length", kFamilyTag, hp.fe_hop_length);   st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.frontend.window", kFamilyTag, hp.fe_window);       st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.frontend.normalize", kFamilyTag, hp.fe_normalize);    st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf, "stt.frontend.dither", kFamilyTag, hp.fe_dither);       st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf, "stt.frontend.pre_emphasis", kFamilyTag, hp.fe_pre_emphasis); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf, "stt.frontend.f_min", kFamilyTag, hp.fe_f_min);        st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf, "stt.frontend.f_max", kFamilyTag, hp.fe_f_max);        st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_string_kv(gguf, "stt.frontend.pad_mode", kFamilyTag, "reflect", hp.fe_pad_mode); st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_string_kv(gguf, "stt.frontend.type", kFamilyTag, hp.fe_type); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.num_mels", kFamilyTag, hp.fe_num_mels);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.sample_rate", kFamilyTag, hp.fe_sample_rate);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.n_fft", kFamilyTag, hp.fe_n_fft); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.win_length", kFamilyTag, hp.fe_win_length);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.hop_length", kFamilyTag, hp.fe_hop_length);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_string_kv(gguf, "stt.frontend.window", kFamilyTag, hp.fe_window); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_string_kv(gguf, "stt.frontend.normalize", kFamilyTag, hp.fe_normalize);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.frontend.dither", kFamilyTag, hp.fe_dither); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.frontend.pre_emphasis", kFamilyTag, hp.fe_pre_emphasis);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.frontend.f_min", kFamilyTag, hp.fe_f_min); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.frontend.f_max", kFamilyTag, hp.fe_f_max); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_string_kv(gguf, "stt.frontend.pad_mode", kFamilyTag, "reflect", hp.fe_pad_mode);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Cross-field invariants.
-    if (hp.enc_n_layers <= 0 || hp.enc_d_model <= 0 || hp.enc_n_heads <= 0 ||
-        hp.enc_d_ff <= 0 || hp.enc_conv_kernel <= 0 ||
-        hp.enc_subsampling_factor <= 0 || hp.enc_subsampling_channels <= 0)
-    {
+    if (hp.enc_n_layers <= 0 || hp.enc_d_model <= 0 || hp.enc_n_heads <= 0 || hp.enc_d_ff <= 0 ||
+        hp.enc_conv_kernel <= 0 || hp.enc_subsampling_factor <= 0 || hp.enc_subsampling_channels <= 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "cohere: encoder hparams must be positive");
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.enc_d_model % hp.enc_n_heads != 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "cohere: encoder d_model (%d) not divisible by n_heads (%d)",
-                     hp.enc_d_model, hp.enc_n_heads);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "cohere: encoder d_model (%d) not divisible by n_heads (%d)",
+                hp.enc_d_model, hp.enc_n_heads);
         return TRANSCRIBE_ERR_GGUF;
     }
-    if (hp.dec_n_layers <= 0 || hp.dec_hidden <= 0 || hp.dec_n_heads <= 0 ||
-        hp.dec_inner <= 0 || hp.dec_max_seq <= 0)
-    {
+    if (hp.dec_n_layers <= 0 || hp.dec_hidden <= 0 || hp.dec_n_heads <= 0 || hp.dec_inner <= 0 || hp.dec_max_seq <= 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "cohere: decoder hparams must be positive");
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.dec_hidden % hp.dec_n_heads != 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "cohere: decoder hidden (%d) not divisible by n_heads (%d)",
-                     hp.dec_hidden, hp.dec_n_heads);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "cohere: decoder hidden (%d) not divisible by n_heads (%d)", hp.dec_hidden,
+                hp.dec_n_heads);
         return TRANSCRIBE_ERR_GGUF;
     }
-    if (hp.dec_activation != "relu" && hp.dec_activation != "silu" &&
-        hp.dec_activation != "swish")
-    {
+    if (hp.dec_activation != "relu" && hp.dec_activation != "silu" && hp.dec_activation != "swish") {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "cohere: unsupported decoder activation \"%s\" "
-                     "(only relu, silu, swish are implemented)",
-                     hp.dec_activation.c_str());
+                "cohere: unsupported decoder activation \"%s\" "
+                "(only relu, silu, swish are implemented)",
+                hp.dec_activation.c_str());
         return TRANSCRIBE_ERR_GGUF;
     }
-    if (hp.fe_num_mels <= 0 || hp.fe_sample_rate <= 0 ||
-        hp.fe_n_fft <= 0 || hp.fe_win_length <= 0 || hp.fe_hop_length <= 0)
-    {
+    if (hp.fe_num_mels <= 0 || hp.fe_sample_rate <= 0 || hp.fe_n_fft <= 0 || hp.fe_win_length <= 0 ||
+        hp.fe_hop_length <= 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "cohere: frontend dimensions must be positive");
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.fe_win_length > hp.fe_n_fft) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "cohere: frontend win_length (%d) > n_fft (%d)",
-                     hp.fe_win_length, hp.fe_n_fft);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "cohere: frontend win_length (%d) > n_fft (%d)", hp.fe_win_length,
+                hp.fe_n_fft);
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.fe_f_min < 0.0f || hp.fe_f_max <= hp.fe_f_min) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "cohere: frontend mel band invalid: f_min=%f f_max=%f",
-                     hp.fe_f_min, hp.fe_f_max);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "cohere: frontend mel band invalid: f_min=%f f_max=%f", hp.fe_f_min,
+                hp.fe_f_max);
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.fe_type != "mel") {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "cohere: unsupported frontend type \"%s\" (only \"mel\")",
-                     hp.fe_type.c_str());
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "cohere: unsupported frontend type \"%s\" (only \"mel\")",
+                hp.fe_type.c_str());
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.fe_window != "hann") {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "cohere: unsupported frontend window \"%s\" "
-                     "(only \"hann\" is implemented)",
-                     hp.fe_window.c_str());
+                "cohere: unsupported frontend window \"%s\" "
+                "(only \"hann\" is implemented)",
+                hp.fe_window.c_str());
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.fe_normalize != "per_feature") {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "cohere: unsupported frontend normalize \"%s\" "
-                     "(only \"per_feature\" is implemented)",
-                     hp.fe_normalize.c_str());
+                "cohere: unsupported frontend normalize \"%s\" "
+                "(only \"per_feature\" is implemented)",
+                hp.fe_normalize.c_str());
         return TRANSCRIBE_ERR_GGUF;
     }
     if ((hp.fe_n_fft & (hp.fe_n_fft - 1)) != 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "cohere: frontend n_fft (%d) must be a power of 2",
-                     hp.fe_n_fft);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "cohere: frontend n_fft (%d) must be a power of 2", hp.fe_n_fft);
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.fe_pad_mode != "reflect" && hp.fe_pad_mode != "constant") {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "cohere: unsupported frontend pad_mode \"%s\" "
-                     "(only \"reflect\" and \"constant\" are implemented)",
-                     hp.fe_pad_mode.c_str());
+                "cohere: unsupported frontend pad_mode \"%s\" "
+                "(only \"reflect\" and \"constant\" are implemented)",
+                hp.fe_pad_mode.c_str());
         return TRANSCRIBE_ERR_GGUF;
     }
 
@@ -174,41 +246,36 @@ using transcribe::weights::lname;
 // the GET_* macros stay here so the family log tag lands in diagnostics.
 constexpr const char * kTag = kFamilyTag;
 
-#define GET_F32(slot, name, ...) \
-    do { \
-        ggml_tensor * _t = transcribe::weights::find_tensor( \
-            ctx_meta, (name), \
-            {GGML_TYPE_F32}, {__VA_ARGS__}, kTag); \
-        if (_t == nullptr) return TRANSCRIBE_ERR_GGUF; \
-        (slot) = _t; \
+#define GET_F32(slot, name, ...)                                                                          \
+    do {                                                                                                  \
+        ggml_tensor * _t =                                                                                \
+            transcribe::weights::find_tensor(ctx_meta, (name), { GGML_TYPE_F32 }, { __VA_ARGS__ }, kTag); \
+        if (_t == nullptr)                                                                                \
+            return TRANSCRIBE_ERR_GGUF;                                                                   \
+        (slot) = _t;                                                                                      \
     } while (0)
 
-#define GET_CONV(slot, name, ...) \
-    do { \
-        ggml_tensor * _t = transcribe::weights::find_tensor( \
-            ctx_meta, (name), \
-            {TRANSCRIBE_QUANT_CONV_TYPES}, \
-            {__VA_ARGS__}, kTag); \
-        if (_t == nullptr) return TRANSCRIBE_ERR_GGUF; \
-        (slot) = _t; \
+#define GET_CONV(slot, name, ...)                                                                              \
+    do {                                                                                                       \
+        ggml_tensor * _t = transcribe::weights::find_tensor(ctx_meta, (name), { TRANSCRIBE_QUANT_CONV_TYPES }, \
+                                                            { __VA_ARGS__ }, kTag);                            \
+        if (_t == nullptr)                                                                                     \
+            return TRANSCRIBE_ERR_GGUF;                                                                        \
+        (slot) = _t;                                                                                           \
     } while (0)
 
-#define GET_LIN(slot, name, ...) \
-    do { \
-        ggml_tensor * _t = transcribe::weights::find_tensor( \
-            ctx_meta, (name), \
-            {TRANSCRIBE_QUANT_LINEAR_TYPES}, \
-            {__VA_ARGS__}, kTag); \
-        if (_t == nullptr) return TRANSCRIBE_ERR_GGUF; \
-        (slot) = _t; \
+#define GET_LIN(slot, name, ...)                                                                                 \
+    do {                                                                                                         \
+        ggml_tensor * _t = transcribe::weights::find_tensor(ctx_meta, (name), { TRANSCRIBE_QUANT_LINEAR_TYPES }, \
+                                                            { __VA_ARGS__ }, kTag);                              \
+        if (_t == nullptr)                                                                                       \
+            return TRANSCRIBE_ERR_GGUF;                                                                          \
+        (slot) = _t;                                                                                             \
     } while (0)
 
-} // namespace
+}  // namespace
 
-transcribe_status build_cohere_weights(ggml_context *         ctx_meta,
-                                       const CohereHParams &  hp,
-                                       CohereWeights &        weights)
-{
+transcribe_status build_cohere_weights(ggml_context * ctx_meta, const CohereHParams & hp, CohereWeights & weights) {
     if (ctx_meta == nullptr) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
@@ -224,25 +291,25 @@ transcribe_status build_cohere_weights(ggml_context *         ctx_meta,
     const int64_t dec_hd   = hp.dec_head_dim();
     const int64_t dec_in   = hp.dec_inner;
 
-    (void)dec_nh;
-    (void)dec_hd;
+    (void) dec_nh;
+    (void) dec_hd;
 
     const int64_t pre_encode_freq = channels * (hp.fe_num_mels / hp.enc_subsampling_factor);
     const int64_t pre_encode_in   = pre_encode_freq;
 
     // ----- pre_encode -----
-    GET_CONV(weights.pre_encode.conv0_w, "enc.pre_encode.conv.0.weight", 3, 3, 1,        channels);
-    GET_F32 (weights.pre_encode.conv0_b, "enc.pre_encode.conv.0.bias", channels);
-    GET_CONV(weights.pre_encode.conv2_w, "enc.pre_encode.conv.2.weight", 3, 3, 1,        channels);
-    GET_F32 (weights.pre_encode.conv2_b, "enc.pre_encode.conv.2.bias", channels);
+    GET_CONV(weights.pre_encode.conv0_w, "enc.pre_encode.conv.0.weight", 3, 3, 1, channels);
+    GET_F32(weights.pre_encode.conv0_b, "enc.pre_encode.conv.0.bias", channels);
+    GET_CONV(weights.pre_encode.conv2_w, "enc.pre_encode.conv.2.weight", 3, 3, 1, channels);
+    GET_F32(weights.pre_encode.conv2_b, "enc.pre_encode.conv.2.bias", channels);
     GET_CONV(weights.pre_encode.conv3_w, "enc.pre_encode.conv.3.weight", 1, 1, channels, channels);
-    GET_F32 (weights.pre_encode.conv3_b, "enc.pre_encode.conv.3.bias", channels);
-    GET_CONV(weights.pre_encode.conv5_w, "enc.pre_encode.conv.5.weight", 3, 3, 1,        channels);
-    GET_F32 (weights.pre_encode.conv5_b, "enc.pre_encode.conv.5.bias", channels);
+    GET_F32(weights.pre_encode.conv3_b, "enc.pre_encode.conv.3.bias", channels);
+    GET_CONV(weights.pre_encode.conv5_w, "enc.pre_encode.conv.5.weight", 3, 3, 1, channels);
+    GET_F32(weights.pre_encode.conv5_b, "enc.pre_encode.conv.5.bias", channels);
     GET_CONV(weights.pre_encode.conv6_w, "enc.pre_encode.conv.6.weight", 1, 1, channels, channels);
-    GET_F32 (weights.pre_encode.conv6_b, "enc.pre_encode.conv.6.bias", channels);
-    GET_LIN (weights.pre_encode.out_w,   "enc.pre_encode.out.weight", pre_encode_in, d_model);
-    GET_F32 (weights.pre_encode.out_b,   "enc.pre_encode.out.bias", d_model);
+    GET_F32(weights.pre_encode.conv6_b, "enc.pre_encode.conv.6.bias", channels);
+    GET_LIN(weights.pre_encode.out_w, "enc.pre_encode.out.weight", pre_encode_in, d_model);
+    GET_F32(weights.pre_encode.out_b, "enc.pre_encode.out.bias", d_model);
 
     // ----- encoder blocks -----
     weights.blocks.assign(hp.enc_n_layers, CohereBlock{});
@@ -251,57 +318,57 @@ transcribe_status build_cohere_weights(ggml_context *         ctx_meta,
 
         // Macaron FF1 (with bias).
         GET_F32(b.norm_ff1_w, lname("enc.blocks.%d.norm_ff1.weight", i), d_model);
-        GET_F32(b.norm_ff1_b, lname("enc.blocks.%d.norm_ff1.bias",   i), d_model);
+        GET_F32(b.norm_ff1_b, lname("enc.blocks.%d.norm_ff1.bias", i), d_model);
         GET_LIN(b.ff1_lin1_w, lname("enc.blocks.%d.ff1.linear1.weight", i), d_model, d_ff);
-        GET_F32(b.ff1_lin1_b, lname("enc.blocks.%d.ff1.linear1.bias",   i), d_ff);
-        GET_LIN(b.ff1_lin2_w, lname("enc.blocks.%d.ff1.linear2.weight", i), d_ff,    d_model);
-        GET_F32(b.ff1_lin2_b, lname("enc.blocks.%d.ff1.linear2.bias",   i), d_model);
+        GET_F32(b.ff1_lin1_b, lname("enc.blocks.%d.ff1.linear1.bias", i), d_ff);
+        GET_LIN(b.ff1_lin2_w, lname("enc.blocks.%d.ff1.linear2.weight", i), d_ff, d_model);
+        GET_F32(b.ff1_lin2_b, lname("enc.blocks.%d.ff1.linear2.bias", i), d_model);
 
         // Self-attention with relative position (with bias on Q, K, V, out).
         GET_F32(b.norm_attn_w, lname("enc.blocks.%d.norm_attn.weight", i), d_model);
-        GET_F32(b.norm_attn_b, lname("enc.blocks.%d.norm_attn.bias",   i), d_model);
-        GET_LIN(b.attn_q_w,    lname("enc.blocks.%d.attn.linear_q.weight",   i), d_model, d_model);
-        GET_F32(b.attn_q_b,    lname("enc.blocks.%d.attn.linear_q.bias",     i), d_model);
-        GET_LIN(b.attn_k_w,    lname("enc.blocks.%d.attn.linear_k.weight",   i), d_model, d_model);
-        GET_F32(b.attn_k_b,    lname("enc.blocks.%d.attn.linear_k.bias",     i), d_model);
-        GET_LIN(b.attn_v_w,    lname("enc.blocks.%d.attn.linear_v.weight",   i), d_model, d_model);
-        GET_F32(b.attn_v_b,    lname("enc.blocks.%d.attn.linear_v.bias",     i), d_model);
-        GET_LIN(b.attn_out_w,  lname("enc.blocks.%d.attn.linear_out.weight", i), d_model, d_model);
-        GET_F32(b.attn_out_b,  lname("enc.blocks.%d.attn.linear_out.bias",   i), d_model);
-        GET_LIN(b.attn_pos_w,  lname("enc.blocks.%d.attn.linear_pos.weight", i), d_model, d_model);
-        GET_F32(b.attn_pos_u,  lname("enc.blocks.%d.attn.pos_bias_u",        i), head_dim, n_heads);
-        GET_F32(b.attn_pos_v,  lname("enc.blocks.%d.attn.pos_bias_v",        i), head_dim, n_heads);
+        GET_F32(b.norm_attn_b, lname("enc.blocks.%d.norm_attn.bias", i), d_model);
+        GET_LIN(b.attn_q_w, lname("enc.blocks.%d.attn.linear_q.weight", i), d_model, d_model);
+        GET_F32(b.attn_q_b, lname("enc.blocks.%d.attn.linear_q.bias", i), d_model);
+        GET_LIN(b.attn_k_w, lname("enc.blocks.%d.attn.linear_k.weight", i), d_model, d_model);
+        GET_F32(b.attn_k_b, lname("enc.blocks.%d.attn.linear_k.bias", i), d_model);
+        GET_LIN(b.attn_v_w, lname("enc.blocks.%d.attn.linear_v.weight", i), d_model, d_model);
+        GET_F32(b.attn_v_b, lname("enc.blocks.%d.attn.linear_v.bias", i), d_model);
+        GET_LIN(b.attn_out_w, lname("enc.blocks.%d.attn.linear_out.weight", i), d_model, d_model);
+        GET_F32(b.attn_out_b, lname("enc.blocks.%d.attn.linear_out.bias", i), d_model);
+        GET_LIN(b.attn_pos_w, lname("enc.blocks.%d.attn.linear_pos.weight", i), d_model, d_model);
+        GET_F32(b.attn_pos_u, lname("enc.blocks.%d.attn.pos_bias_u", i), head_dim, n_heads);
+        GET_F32(b.attn_pos_v, lname("enc.blocks.%d.attn.pos_bias_v", i), head_dim, n_heads);
 
         // Conv module (with bias on pointwise and depthwise).
-        GET_F32 (b.norm_conv_w, lname("enc.blocks.%d.norm_conv.weight", i), d_model);
-        GET_F32 (b.norm_conv_b, lname("enc.blocks.%d.norm_conv.bias",   i), d_model);
-        GET_CONV(b.conv_pw1_w,  lname("enc.blocks.%d.conv.pointwise1.weight", i), 1, d_model, 2 * d_model);
-        GET_F32 (b.conv_pw1_b,  lname("enc.blocks.%d.conv.pointwise1.bias",   i), 2 * d_model);
-        GET_CONV(b.conv_dw_w,   lname("enc.blocks.%d.conv.depthwise.weight",  i), k, 1,       d_model);
-        GET_F32 (b.conv_dw_b,   lname("enc.blocks.%d.conv.depthwise.bias",    i), d_model);
-        GET_CONV(b.conv_pw2_w,  lname("enc.blocks.%d.conv.pointwise2.weight", i), 1, d_model, d_model);
-        GET_F32 (b.conv_pw2_b,  lname("enc.blocks.%d.conv.pointwise2.bias",   i), d_model);
-        GET_F32 (b.conv_bn_w,   lname("enc.blocks.%d.conv.bn.weight",       i), d_model);
-        GET_F32 (b.conv_bn_b,   lname("enc.blocks.%d.conv.bn.bias",         i), d_model);
-        GET_F32 (b.conv_bn_rm,  lname("enc.blocks.%d.conv.bn.running_mean", i), d_model);
-        GET_F32 (b.conv_bn_rv,  lname("enc.blocks.%d.conv.bn.running_var",  i), d_model);
+        GET_F32(b.norm_conv_w, lname("enc.blocks.%d.norm_conv.weight", i), d_model);
+        GET_F32(b.norm_conv_b, lname("enc.blocks.%d.norm_conv.bias", i), d_model);
+        GET_CONV(b.conv_pw1_w, lname("enc.blocks.%d.conv.pointwise1.weight", i), 1, d_model, 2 * d_model);
+        GET_F32(b.conv_pw1_b, lname("enc.blocks.%d.conv.pointwise1.bias", i), 2 * d_model);
+        GET_CONV(b.conv_dw_w, lname("enc.blocks.%d.conv.depthwise.weight", i), k, 1, d_model);
+        GET_F32(b.conv_dw_b, lname("enc.blocks.%d.conv.depthwise.bias", i), d_model);
+        GET_CONV(b.conv_pw2_w, lname("enc.blocks.%d.conv.pointwise2.weight", i), 1, d_model, d_model);
+        GET_F32(b.conv_pw2_b, lname("enc.blocks.%d.conv.pointwise2.bias", i), d_model);
+        GET_F32(b.conv_bn_w, lname("enc.blocks.%d.conv.bn.weight", i), d_model);
+        GET_F32(b.conv_bn_b, lname("enc.blocks.%d.conv.bn.bias", i), d_model);
+        GET_F32(b.conv_bn_rm, lname("enc.blocks.%d.conv.bn.running_mean", i), d_model);
+        GET_F32(b.conv_bn_rv, lname("enc.blocks.%d.conv.bn.running_var", i), d_model);
 
         // Macaron FF2 (with bias).
         GET_F32(b.norm_ff2_w, lname("enc.blocks.%d.norm_ff2.weight", i), d_model);
-        GET_F32(b.norm_ff2_b, lname("enc.blocks.%d.norm_ff2.bias",   i), d_model);
+        GET_F32(b.norm_ff2_b, lname("enc.blocks.%d.norm_ff2.bias", i), d_model);
         GET_LIN(b.ff2_lin1_w, lname("enc.blocks.%d.ff2.linear1.weight", i), d_model, d_ff);
-        GET_F32(b.ff2_lin1_b, lname("enc.blocks.%d.ff2.linear1.bias",   i), d_ff);
-        GET_LIN(b.ff2_lin2_w, lname("enc.blocks.%d.ff2.linear2.weight", i), d_ff,    d_model);
-        GET_F32(b.ff2_lin2_b, lname("enc.blocks.%d.ff2.linear2.bias",   i), d_model);
+        GET_F32(b.ff2_lin1_b, lname("enc.blocks.%d.ff2.linear1.bias", i), d_ff);
+        GET_LIN(b.ff2_lin2_w, lname("enc.blocks.%d.ff2.linear2.weight", i), d_ff, d_model);
+        GET_F32(b.ff2_lin2_b, lname("enc.blocks.%d.ff2.linear2.bias", i), d_model);
 
         // Final per-block layer norm.
         GET_F32(b.norm_out_w, lname("enc.blocks.%d.norm_out.weight", i), d_model);
-        GET_F32(b.norm_out_b, lname("enc.blocks.%d.norm_out.bias",   i), d_model);
+        GET_F32(b.norm_out_b, lname("enc.blocks.%d.norm_out.bias", i), d_model);
     }
 
     // ----- encoder-decoder projection -----
     GET_LIN(weights.enc_dec_proj.weight, "enc_dec_proj.weight", d_model, dec_h);
-    GET_F32(weights.enc_dec_proj.bias,   "enc_dec_proj.bias",   dec_h);
+    GET_F32(weights.enc_dec_proj.bias, "enc_dec_proj.bias", dec_h);
 
     // ----- decoder embedding -----
     // Token embedding ne=[dec_hidden, vocab_size]; vocab_size is read from
@@ -313,10 +380,8 @@ transcribe_status build_cohere_weights(ggml_context *         ctx_meta,
             return TRANSCRIBE_ERR_GGUF;
         }
         if (tw->ne[0] != dec_h) {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "cohere: dec.embed.token.weight ne[0]=%lld, expected %lld",
-                         static_cast<long long>(tw->ne[0]),
-                         static_cast<long long>(dec_h));
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "cohere: dec.embed.token.weight ne[0]=%lld, expected %lld",
+                    static_cast<long long>(tw->ne[0]), static_cast<long long>(dec_h));
             return TRANSCRIBE_ERR_GGUF;
         }
         weights.dec_embed.token_w = tw;
@@ -325,8 +390,8 @@ transcribe_status build_cohere_weights(ggml_context *         ctx_meta,
     const int64_t vocab_size = weights.dec_embed.token_w->ne[1];
 
     GET_F32(weights.dec_embed.pos_enc, "dec.embed.pos_enc", dec_h, hp.dec_max_seq);
-    GET_F32(weights.dec_embed.norm_w,  "dec.embed.norm.weight", dec_h);
-    GET_F32(weights.dec_embed.norm_b,  "dec.embed.norm.bias",   dec_h);
+    GET_F32(weights.dec_embed.norm_w, "dec.embed.norm.weight", dec_h);
+    GET_F32(weights.dec_embed.norm_b, "dec.embed.norm.bias", dec_h);
 
     // ----- decoder blocks -----
     weights.dec_blocks.assign(hp.dec_n_layers, CohereDecBlock{});
@@ -335,40 +400,40 @@ transcribe_status build_cohere_weights(ggml_context *         ctx_meta,
 
         // Self-attention.
         GET_F32(db.norm_self_w, lname("dec.blocks.%d.norm_self.weight", i), dec_h);
-        GET_F32(db.norm_self_b, lname("dec.blocks.%d.norm_self.bias",   i), dec_h);
-        GET_LIN(db.self_q_w,   lname("dec.blocks.%d.self_attn.q.weight", i), dec_h, dec_h);
-        GET_F32(db.self_q_b,   lname("dec.blocks.%d.self_attn.q.bias",   i), dec_h);
-        GET_LIN(db.self_k_w,   lname("dec.blocks.%d.self_attn.k.weight", i), dec_h, dec_h);
-        GET_F32(db.self_k_b,   lname("dec.blocks.%d.self_attn.k.bias",   i), dec_h);
-        GET_LIN(db.self_v_w,   lname("dec.blocks.%d.self_attn.v.weight", i), dec_h, dec_h);
-        GET_F32(db.self_v_b,   lname("dec.blocks.%d.self_attn.v.bias",   i), dec_h);
+        GET_F32(db.norm_self_b, lname("dec.blocks.%d.norm_self.bias", i), dec_h);
+        GET_LIN(db.self_q_w, lname("dec.blocks.%d.self_attn.q.weight", i), dec_h, dec_h);
+        GET_F32(db.self_q_b, lname("dec.blocks.%d.self_attn.q.bias", i), dec_h);
+        GET_LIN(db.self_k_w, lname("dec.blocks.%d.self_attn.k.weight", i), dec_h, dec_h);
+        GET_F32(db.self_k_b, lname("dec.blocks.%d.self_attn.k.bias", i), dec_h);
+        GET_LIN(db.self_v_w, lname("dec.blocks.%d.self_attn.v.weight", i), dec_h, dec_h);
+        GET_F32(db.self_v_b, lname("dec.blocks.%d.self_attn.v.bias", i), dec_h);
         GET_LIN(db.self_out_w, lname("dec.blocks.%d.self_attn.out.weight", i), dec_h, dec_h);
-        GET_F32(db.self_out_b, lname("dec.blocks.%d.self_attn.out.bias",   i), dec_h);
+        GET_F32(db.self_out_b, lname("dec.blocks.%d.self_attn.out.bias", i), dec_h);
 
         // Cross-attention.
         GET_F32(db.norm_cross_w, lname("dec.blocks.%d.norm_cross.weight", i), dec_h);
-        GET_F32(db.norm_cross_b, lname("dec.blocks.%d.norm_cross.bias",   i), dec_h);
-        GET_LIN(db.cross_q_w,   lname("dec.blocks.%d.cross_attn.q.weight", i), dec_h, dec_h);
-        GET_F32(db.cross_q_b,   lname("dec.blocks.%d.cross_attn.q.bias",   i), dec_h);
-        GET_LIN(db.cross_k_w,   lname("dec.blocks.%d.cross_attn.k.weight", i), dec_h, dec_h);
-        GET_F32(db.cross_k_b,   lname("dec.blocks.%d.cross_attn.k.bias",   i), dec_h);
-        GET_LIN(db.cross_v_w,   lname("dec.blocks.%d.cross_attn.v.weight", i), dec_h, dec_h);
-        GET_F32(db.cross_v_b,   lname("dec.blocks.%d.cross_attn.v.bias",   i), dec_h);
+        GET_F32(db.norm_cross_b, lname("dec.blocks.%d.norm_cross.bias", i), dec_h);
+        GET_LIN(db.cross_q_w, lname("dec.blocks.%d.cross_attn.q.weight", i), dec_h, dec_h);
+        GET_F32(db.cross_q_b, lname("dec.blocks.%d.cross_attn.q.bias", i), dec_h);
+        GET_LIN(db.cross_k_w, lname("dec.blocks.%d.cross_attn.k.weight", i), dec_h, dec_h);
+        GET_F32(db.cross_k_b, lname("dec.blocks.%d.cross_attn.k.bias", i), dec_h);
+        GET_LIN(db.cross_v_w, lname("dec.blocks.%d.cross_attn.v.weight", i), dec_h, dec_h);
+        GET_F32(db.cross_v_b, lname("dec.blocks.%d.cross_attn.v.bias", i), dec_h);
         GET_LIN(db.cross_out_w, lname("dec.blocks.%d.cross_attn.out.weight", i), dec_h, dec_h);
-        GET_F32(db.cross_out_b, lname("dec.blocks.%d.cross_attn.out.bias",   i), dec_h);
+        GET_F32(db.cross_out_b, lname("dec.blocks.%d.cross_attn.out.bias", i), dec_h);
 
         // FFN.
         GET_F32(db.norm_ff_w, lname("dec.blocks.%d.norm_ff.weight", i), dec_h);
-        GET_F32(db.norm_ff_b, lname("dec.blocks.%d.norm_ff.bias",   i), dec_h);
-        GET_LIN(db.ff_in_w,  lname("dec.blocks.%d.ff.dense_in.weight",  i), dec_h, dec_in);
-        GET_F32(db.ff_in_b,  lname("dec.blocks.%d.ff.dense_in.bias",    i), dec_in);
+        GET_F32(db.norm_ff_b, lname("dec.blocks.%d.norm_ff.bias", i), dec_h);
+        GET_LIN(db.ff_in_w, lname("dec.blocks.%d.ff.dense_in.weight", i), dec_h, dec_in);
+        GET_F32(db.ff_in_b, lname("dec.blocks.%d.ff.dense_in.bias", i), dec_in);
         GET_LIN(db.ff_out_w, lname("dec.blocks.%d.ff.dense_out.weight", i), dec_in, dec_h);
-        GET_F32(db.ff_out_b, lname("dec.blocks.%d.ff.dense_out.bias",   i), dec_h);
+        GET_F32(db.ff_out_b, lname("dec.blocks.%d.ff.dense_out.bias", i), dec_h);
     }
 
     // ----- decoder final norm -----
     GET_F32(weights.dec_final.norm_w, "dec.final_norm.weight", dec_h);
-    GET_F32(weights.dec_final.norm_b, "dec.final_norm.bias",   dec_h);
+    GET_F32(weights.dec_final.norm_b, "dec.final_norm.bias", dec_h);
 
     // ----- head -----
     GET_F32(weights.head.bias, "head.bias", vocab_size);
@@ -380,4 +445,4 @@ transcribe_status build_cohere_weights(ggml_context *         ctx_meta,
 #undef GET_CONV
 #undef GET_LIN
 
-} // namespace transcribe::cohere
+}  // namespace transcribe::cohere
diff --git a/src/arch/cohere/weights.h b/src/arch/cohere/weights.h
index 0f352160..ad5bf56a 100644
--- a/src/arch/cohere/weights.h
+++ b/src/arch/cohere/weights.h
@@ -34,22 +34,22 @@ namespace transcribe::cohere {
 
 struct CohereHParams {
     // Encoder (Conformer).
-    int32_t enc_n_layers          = 0;
-    int32_t enc_d_model           = 0;
-    int32_t enc_n_heads           = 0;
-    int32_t enc_d_ff              = 0;
-    int32_t enc_conv_kernel       = 0;
+    int32_t enc_n_layers             = 0;
+    int32_t enc_d_model              = 0;
+    int32_t enc_n_heads              = 0;
+    int32_t enc_d_ff                 = 0;
+    int32_t enc_conv_kernel          = 0;
     int32_t enc_subsampling_factor   = 0;
     int32_t enc_subsampling_channels = 0;
-    int32_t enc_pos_emb_max_len   = 0;
-    bool    enc_use_bias          = false;
+    int32_t enc_pos_emb_max_len      = 0;
+    bool    enc_use_bias             = false;
 
     // Decoder (autoregressive Transformer).
-    int32_t dec_n_layers   = 0;
-    int32_t dec_hidden     = 0;
-    int32_t dec_n_heads    = 0;
-    int32_t dec_inner      = 0;
-    int32_t dec_max_seq    = 0;
+    int32_t     dec_n_layers = 0;
+    int32_t     dec_hidden   = 0;
+    int32_t     dec_n_heads  = 0;
+    int32_t     dec_inner    = 0;
+    int32_t     dec_max_seq  = 0;
     std::string dec_activation;  // "relu" or "silu"
 
     // Token IDs.
@@ -80,11 +80,11 @@ struct CohereHParams {
 
     // Derived.
     int32_t enc_head_dim() const { return enc_n_heads > 0 ? enc_d_model / enc_n_heads : 0; }
+
     int32_t dec_head_dim() const { return dec_n_heads > 0 ? dec_hidden / dec_n_heads : 0; }
 };
 
-transcribe_status read_cohere_hparams(const gguf_context * gguf,
-                                      CohereHParams &      hp);
+transcribe_status read_cohere_hparams(const gguf_context * gguf, CohereHParams & hp);
 
 struct CoherePreEncode {
     // Same structure as Parakeet: dw_striding subsampling.
@@ -113,33 +113,33 @@ struct CohereBlock {
     ggml_tensor * ff1_lin2_b = nullptr;
 
     // Self-attention with relative positional encoding.
-    ggml_tensor * norm_attn_w  = nullptr;
-    ggml_tensor * norm_attn_b  = nullptr;
-    ggml_tensor * attn_q_w     = nullptr;
-    ggml_tensor * attn_q_b     = nullptr;
-    ggml_tensor * attn_k_w     = nullptr;
-    ggml_tensor * attn_k_b     = nullptr;
-    ggml_tensor * attn_v_w     = nullptr;
-    ggml_tensor * attn_v_b     = nullptr;
-    ggml_tensor * attn_out_w   = nullptr;
-    ggml_tensor * attn_out_b   = nullptr;
-    ggml_tensor * attn_pos_w   = nullptr;  // linear_pos (no bias)
-    ggml_tensor * attn_pos_u   = nullptr;
-    ggml_tensor * attn_pos_v   = nullptr;
+    ggml_tensor * norm_attn_w = nullptr;
+    ggml_tensor * norm_attn_b = nullptr;
+    ggml_tensor * attn_q_w    = nullptr;
+    ggml_tensor * attn_q_b    = nullptr;
+    ggml_tensor * attn_k_w    = nullptr;
+    ggml_tensor * attn_k_b    = nullptr;
+    ggml_tensor * attn_v_w    = nullptr;
+    ggml_tensor * attn_v_b    = nullptr;
+    ggml_tensor * attn_out_w  = nullptr;
+    ggml_tensor * attn_out_b  = nullptr;
+    ggml_tensor * attn_pos_w  = nullptr;  // linear_pos (no bias)
+    ggml_tensor * attn_pos_u  = nullptr;
+    ggml_tensor * attn_pos_v  = nullptr;
 
     // Convolution module.
-    ggml_tensor * norm_conv_w  = nullptr;
-    ggml_tensor * norm_conv_b  = nullptr;
-    ggml_tensor * conv_pw1_w   = nullptr;
-    ggml_tensor * conv_pw1_b   = nullptr;
-    ggml_tensor * conv_dw_w    = nullptr;
-    ggml_tensor * conv_dw_b    = nullptr;
-    ggml_tensor * conv_pw2_w   = nullptr;
-    ggml_tensor * conv_pw2_b   = nullptr;
-    ggml_tensor * conv_bn_w    = nullptr;
-    ggml_tensor * conv_bn_b    = nullptr;
-    ggml_tensor * conv_bn_rm   = nullptr;
-    ggml_tensor * conv_bn_rv   = nullptr;
+    ggml_tensor * norm_conv_w         = nullptr;
+    ggml_tensor * norm_conv_b         = nullptr;
+    ggml_tensor * conv_pw1_w          = nullptr;
+    ggml_tensor * conv_pw1_b          = nullptr;
+    ggml_tensor * conv_dw_w           = nullptr;
+    ggml_tensor * conv_dw_b           = nullptr;
+    ggml_tensor * conv_pw2_w          = nullptr;
+    ggml_tensor * conv_pw2_b          = nullptr;
+    ggml_tensor * conv_bn_w           = nullptr;
+    ggml_tensor * conv_bn_b           = nullptr;
+    ggml_tensor * conv_bn_rm          = nullptr;
+    ggml_tensor * conv_bn_rv          = nullptr;
     // Fused BN (computed at load time).
     ggml_tensor * conv_bn_fused_scale = nullptr;
     ggml_tensor * conv_bn_fused_bias  = nullptr;
@@ -218,17 +218,15 @@ struct CohereHead {
 };
 
 struct CohereWeights {
-    CoherePreEncode              pre_encode;
-    std::vector<CohereBlock>     blocks;
-    CohereEncDecProj             enc_dec_proj;
-    CohereDecEmbed               dec_embed;
-    std::vector<CohereDecBlock>  dec_blocks;
-    CohereDecFinal               dec_final;
-    CohereHead                   head;
+    CoherePreEncode             pre_encode;
+    std::vector<CohereBlock>    blocks;
+    CohereEncDecProj            enc_dec_proj;
+    CohereDecEmbed              dec_embed;
+    std::vector<CohereDecBlock> dec_blocks;
+    CohereDecFinal              dec_final;
+    CohereHead                  head;
 };
 
-transcribe_status build_cohere_weights(ggml_context *         ctx_meta,
-                                       const CohereHParams &  hp,
-                                       CohereWeights &        weights);
+transcribe_status build_cohere_weights(ggml_context * ctx_meta, const CohereHParams & hp, CohereWeights & weights);
 
-} // namespace transcribe::cohere
+}  // namespace transcribe::cohere
diff --git a/src/arch/funasr_nano/adaptor.cpp b/src/arch/funasr_nano/adaptor.cpp
index 8075e3c7..4d480ee5 100644
--- a/src/arch/funasr_nano/adaptor.cpp
+++ b/src/arch/funasr_nano/adaptor.cpp
@@ -2,12 +2,10 @@
 
 #include "adaptor.h"
 
-#include "weights.h"
-
+#include "ggml.h"
 #include "transcribe-debug.h"
 #include "transcribe-log.h"
-
-#include "ggml.h"
+#include "weights.h"
 
 #include <cmath>
 #include <cstdio>
@@ -18,7 +16,9 @@ namespace transcribe::funasr_nano {
 namespace {
 
 ggml_tensor * named(ggml_tensor * t, const char * name) {
-    if (t != nullptr && name != nullptr) ggml_set_name(t, name);
+    if (t != nullptr && name != nullptr) {
+        ggml_set_name(t, name);
+    }
     return t;
 }
 
@@ -34,35 +34,31 @@ ggml_tensor * mul_mat_f32acc(ggml_context * ctx, ggml_tensor * w, ggml_tensor *
     return y;
 }
 
-ggml_tensor * layer_norm(ggml_context * ctx,
-                         ggml_tensor *  x,
-                         ggml_tensor *  gamma,
-                         ggml_tensor *  beta,
-                         float          eps)
-{
+ggml_tensor * layer_norm(ggml_context * ctx, ggml_tensor * x, ggml_tensor * gamma, ggml_tensor * beta, float eps) {
     ggml_tensor * y = ggml_norm(ctx, x, eps);
-    y = ggml_mul(ctx, y, gamma);
-    if (beta != nullptr) y = ggml_add(ctx, y, beta);
+    y               = ggml_mul(ctx, y, gamma);
+    if (beta != nullptr) {
+        y = ggml_add(ctx, y, beta);
+    }
     return y;
 }
 
-ggml_tensor * adaptor_attention(ggml_context *      ctx,
-                                ggml_tensor *       x,
+ggml_tensor * adaptor_attention(ggml_context *       ctx,
+                                ggml_tensor *        x,
                                 const AdaptorBlock & b,
-                                int                 n_heads,
-                                int                 head_dim,
-                                int                 llm_dim)
-{
-    const int64_t T    = x->ne[1];
-    const float scale  = 1.0f / std::sqrt(static_cast<float>(head_dim));
+                                int                  n_heads,
+                                int                  head_dim,
+                                int                  llm_dim) {
+    const int64_t T     = x->ne[1];
+    const float   scale = 1.0f / std::sqrt(static_cast<float>(head_dim));
 
     // q, k, v: separate linears with biases (plain MultiHeadedAttention).
     ggml_tensor * q = mul_mat_f32acc(ctx, b.attn_q_w, x);
-    q = ggml_add(ctx, q, b.attn_q_b);
+    q               = ggml_add(ctx, q, b.attn_q_b);
     ggml_tensor * k = mul_mat_f32acc(ctx, b.attn_k_w, x);
-    k = ggml_add(ctx, k, b.attn_k_b);
+    k               = ggml_add(ctx, k, b.attn_k_b);
     ggml_tensor * v = mul_mat_f32acc(ctx, b.attn_v_w, x);
-    v = ggml_add(ctx, v, b.attn_v_b);
+    v               = ggml_add(ctx, v, b.attn_v_b);
 
     auto split_heads = [&](ggml_tensor * t) {
         return ggml_reshape_4d(ctx, t, head_dim, n_heads, T, 1);
@@ -72,16 +68,15 @@ ggml_tensor * adaptor_attention(ggml_context *      ctx,
     v = split_heads(v);
 
     auto to_attn_layout = [&](ggml_tensor * t) {
-        t = ggml_permute(ctx, t, 0, 2, 1, 3);   // [head_dim, T, n_heads, 1]
+        t = ggml_permute(ctx, t, 0, 2, 1, 3);  // [head_dim, T, n_heads, 1]
         return ggml_cont(ctx, t);
     };
     q = to_attn_layout(q);
     k = to_attn_layout(k);
     v = to_attn_layout(v);
 
-    ggml_tensor * o = ggml_flash_attn_ext(
-        ctx, q, k, v, /*mask=*/nullptr,
-        scale, /*max_bias=*/0.0f, /*logit_softcap=*/0.0f);
+    ggml_tensor * o =
+        ggml_flash_attn_ext(ctx, q, k, v, /*mask=*/nullptr, scale, /*max_bias=*/0.0f, /*logit_softcap=*/0.0f);
     o = ggml_cont(ctx, o);
     o = ggml_reshape_2d(ctx, o, llm_dim, T);
 
@@ -90,34 +85,30 @@ ggml_tensor * adaptor_attention(ggml_context *      ctx,
     return o;
 }
 
-ggml_tensor * adaptor_ffn(ggml_context *      ctx,
-                          ggml_tensor *       x,
-                          const AdaptorBlock & b)
-{
+ggml_tensor * adaptor_ffn(ggml_context * ctx, ggml_tensor * x, const AdaptorBlock & b) {
     ggml_tensor * h = mul_mat_f32acc(ctx, b.ffn_fc1_w, x);
-    h = ggml_add(ctx, h, b.ffn_fc1_b);
-    h = ggml_relu(ctx, h);
-    h = mul_mat_f32acc(ctx, b.ffn_fc2_w, h);
-    h = ggml_add(ctx, h, b.ffn_fc2_b);
+    h               = ggml_add(ctx, h, b.ffn_fc1_b);
+    h               = ggml_relu(ctx, h);
+    h               = mul_mat_f32acc(ctx, b.ffn_fc2_w, h);
+    h               = ggml_add(ctx, h, b.ffn_fc2_b);
     return h;
 }
 
-ggml_tensor * adaptor_block(ggml_context *      ctx,
-                            ggml_tensor *       x,
+ggml_tensor * adaptor_block(ggml_context *       ctx,
+                            ggml_tensor *        x,
                             const AdaptorBlock & b,
-                            int                 n_heads,
-                            int                 head_dim,
-                            int                 llm_dim,
-                            float               eps)
-{
+                            int                  n_heads,
+                            int                  head_dim,
+                            int                  llm_dim,
+                            float                eps) {
     // Pre-LN MHA + residual.
     ggml_tensor * y = layer_norm(ctx, x, b.norm_attn_w, b.norm_attn_b, eps);
-    y = adaptor_attention(ctx, y, b, n_heads, head_dim, llm_dim);
-    x = ggml_add(ctx, x, y);
+    y               = adaptor_attention(ctx, y, b, n_heads, head_dim, llm_dim);
+    x               = ggml_add(ctx, x, y);
 
     // Pre-LN FFN + residual.
     ggml_tensor * z = layer_norm(ctx, x, b.norm_ffn_w, b.norm_ffn_b, eps);
-    z = adaptor_ffn(ctx, z, b);
+    z               = adaptor_ffn(ctx, z, b);
     return ggml_add(ctx, x, z);
 }
 
@@ -127,34 +118,34 @@ void mark_dump(ggml_tensor *& slot, ggml_tensor * t, const char * name) {
     slot = t;
 }
 
-} // namespace
+}  // namespace
 
 int compute_fake_token_len(int T_lfr, bool use_low_frame_rate) {
-    if (!use_low_frame_rate) return T_lfr;
+    if (!use_low_frame_rate) {
+        return T_lfr;
+    }
     // Floor division over PyTorch ints; T_lfr ≥ 0.
     int o1 = 1 + (T_lfr - 3 + 2) / 2;
-    int o2 = 1 + (o1    - 3 + 2) / 2;
+    int o2 = 1 + (o1 - 3 + 2) / 2;
     int o3 = (o2 - 1) / 2 + 1;
     return o3;
 }
 
-AdaptorBuild build_adaptor_graph(ggml_context *             ctx,
-                                 const FunAsrNanoWeights &  w,
-                                 const FunAsrNanoHParams &  hp,
-                                 int                        T_in)
-{
-    AdaptorBuild ab {};
+AdaptorBuild build_adaptor_graph(ggml_context *            ctx,
+                                 const FunAsrNanoWeights & w,
+                                 const FunAsrNanoHParams & hp,
+                                 int                       T_in) {
+    AdaptorBuild ab{};
     if (ctx == nullptr || T_in <= 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "funasr_nano adaptor: invalid arg (T_in=%d)", T_in);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "funasr_nano adaptor: invalid arg (T_in=%d)", T_in);
         return ab;
     }
 
-    const int encoder_dim = hp.adaptor_encoder_dim;
-    const int llm_dim     = hp.adaptor_llm_dim;
-    const int n_heads     = hp.adaptor_n_heads;
-    const int head_dim    = hp.adaptor_d_head;
-    const float eps       = hp.adaptor_layer_norm_eps;
+    const int   encoder_dim = hp.adaptor_encoder_dim;
+    const int   llm_dim     = hp.adaptor_llm_dim;
+    const int   n_heads     = hp.adaptor_n_heads;
+    const int   head_dim    = hp.adaptor_d_head;
+    const float eps         = hp.adaptor_layer_norm_eps;
 
     ab.enc_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, encoder_dim, T_in);
     named(ab.enc_in, "adaptor.enc_in");
@@ -162,7 +153,7 @@ AdaptorBuild build_adaptor_graph(ggml_context *             ctx,
 
     // linear1 (512 → 2048) + bias.
     ggml_tensor * x = mul_mat_f32acc(ctx, w.adaptor.linear1_w, ab.enc_in);
-    x = ggml_add(ctx, x, w.adaptor.linear1_b);
+    x               = ggml_add(ctx, x, w.adaptor.linear1_b);
     mark_dump(ab.dumps.linear1_out, x, "adaptor.linear1.out");
 
     x = ggml_relu(ctx, x);
@@ -175,8 +166,7 @@ AdaptorBuild build_adaptor_graph(ggml_context *             ctx,
     // Transformer blocks.
     const int n_b = static_cast<int>(w.adaptor.blocks.size());
     for (int i = 0; i < n_b; ++i) {
-        x = adaptor_block(ctx, x, w.adaptor.blocks[i],
-                          n_heads, head_dim, llm_dim, eps);
+        x = adaptor_block(ctx, x, w.adaptor.blocks[i], n_heads, head_dim, llm_dim, eps);
         if (i == 0) {
             mark_dump(ab.dumps.block0_out, x, "adaptor.blocks.0.out");
         }
@@ -188,12 +178,11 @@ AdaptorBuild build_adaptor_graph(ggml_context *             ctx,
 
     ab.graph = ggml_new_graph_custom(ctx, /*size=*/2048, /*grads=*/false);
     if (ab.graph == nullptr) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "funasr_nano adaptor: ggml_new_graph_custom failed");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "funasr_nano adaptor: ggml_new_graph_custom failed");
         return ab;
     }
     ggml_build_forward_expand(ab.graph, ab.out);
     return ab;
 }
 
-} // namespace transcribe::funasr_nano
+}  // namespace transcribe::funasr_nano
diff --git a/src/arch/funasr_nano/adaptor.h b/src/arch/funasr_nano/adaptor.h
index 19056bdc..299eba5a 100644
--- a/src/arch/funasr_nano/adaptor.h
+++ b/src/arch/funasr_nano/adaptor.h
@@ -22,23 +22,23 @@ struct FunAsrNanoHParams;
 struct FunAsrNanoWeights;
 
 struct AdaptorDumps {
-    ggml_tensor * linear1_out  = nullptr;  // post-linear, pre-ReLU
-    ggml_tensor * linear2_out  = nullptr;
-    ggml_tensor * block0_out   = nullptr;
-    ggml_tensor * adaptor_out  = nullptr;
+    ggml_tensor * linear1_out = nullptr;  // post-linear, pre-ReLU
+    ggml_tensor * linear2_out = nullptr;
+    ggml_tensor * block0_out  = nullptr;
+    ggml_tensor * adaptor_out = nullptr;
 };
 
 struct AdaptorBuild {
-    ggml_tensor * enc_in  = nullptr;   // [encoder_dim, T_lfr] f32
-    ggml_tensor * out     = nullptr;   // [llm_dim, T_lfr]
-    AdaptorDumps  dumps {};
-    ggml_cgraph * graph   = nullptr;
+    ggml_tensor * enc_in = nullptr;  // [encoder_dim, T_lfr] f32
+    ggml_tensor * out    = nullptr;  // [llm_dim, T_lfr]
+    AdaptorDumps  dumps{};
+    ggml_cgraph * graph = nullptr;
 };
 
-AdaptorBuild build_adaptor_graph(ggml_context *             compute_ctx,
-                                 const FunAsrNanoWeights &  weights,
-                                 const FunAsrNanoHParams &  hp,
-                                 int                        T_in);
+AdaptorBuild build_adaptor_graph(ggml_context *            compute_ctx,
+                                 const FunAsrNanoWeights & weights,
+                                 const FunAsrNanoHParams & hp,
+                                 int                       T_in);
 
 // Compute the LLM-injected slice length for use_low_frame_rate=true.
 // Mirrors FunASR's data_load_speech formula:
@@ -51,4 +51,4 @@ AdaptorBuild build_adaptor_graph(ggml_context *             compute_ctx,
 // equals the input frame count.
 int compute_fake_token_len(int T_lfr, bool use_low_frame_rate);
 
-} // namespace transcribe::funasr_nano
+}  // namespace transcribe::funasr_nano
diff --git a/src/arch/funasr_nano/capabilities.cpp b/src/arch/funasr_nano/capabilities.cpp
index e02599c9..b3c163c7 100644
--- a/src/arch/funasr_nano/capabilities.cpp
+++ b/src/arch/funasr_nano/capabilities.cpp
@@ -15,7 +15,7 @@ void apply_family_invariants(transcribe_model & model) {
     // from the .pt file), so it is intentionally skipped at convert.
     caps.max_timestamp_kind = TRANSCRIBE_TIMESTAMPS_NONE;
 
-    caps.supports_translate            = false;
+    caps.supports_translate = false;
 
     // Feature bits: cancellation is wired at the run level. FunASR-Nano
     // exposes a runtime ITN toggle via the LLM system-prompt suffix
@@ -23,7 +23,7 @@ void apply_family_invariants(transcribe_model & model) {
     // The generic transcribe_run_params::itn enum routes here. No PNC
     // runtime toggle.
     transcribe::set_feature(&model, TRANSCRIBE_FEATURE_CANCELLATION, true);
-    transcribe::set_feature(&model, TRANSCRIBE_FEATURE_ITN,          true);
+    transcribe::set_feature(&model, TRANSCRIBE_FEATURE_ITN, true);
 }
 
-} // namespace transcribe::funasr_nano
+}  // namespace transcribe::funasr_nano
diff --git a/src/arch/funasr_nano/decoder.cpp b/src/arch/funasr_nano/decoder.cpp
index 899a480d..cdd5d53f 100644
--- a/src/arch/funasr_nano/decoder.cpp
+++ b/src/arch/funasr_nano/decoder.cpp
@@ -21,11 +21,10 @@
 #include "decoder.h"
 
 #include "causal_lm/causal_lm.h"
+#include "ggml.h"
 #include "transcribe-debug.h"
 #include "transcribe-log.h"
 
-#include "ggml.h"
-
 #include <cmath>
 #include <cstdio>
 
@@ -34,12 +33,14 @@ namespace transcribe::funasr_nano {
 namespace {
 
 ggml_tensor * named(ggml_tensor * t, const char * name) {
-    if (t != nullptr && name != nullptr) ggml_set_name(t, name);
+    if (t != nullptr && name != nullptr) {
+        ggml_set_name(t, name);
+    }
     return t;
 }
 
 causal_lm::BlockView to_block_view(const DecBlock & b) {
-    causal_lm::BlockView v {};
+    causal_lm::BlockView v{};
     v.norm_attn_w   = b.norm_attn_w;
     v.norm_ffn_w    = b.norm_ffn_w;
     v.attn_q_w      = b.attn_q_w;
@@ -54,7 +55,7 @@ causal_lm::BlockView to_block_view(const DecBlock & b) {
 }
 
 causal_lm::BlockParams to_block_params(const FunAsrNanoHParams & hp) {
-    causal_lm::BlockParams p {};
+    causal_lm::BlockParams p{};
     p.n_heads      = hp.dec_n_heads;
     p.n_kv_heads   = hp.dec_n_kv_heads;
     p.head_dim     = hp.dec_head_dim;
@@ -64,37 +65,33 @@ causal_lm::BlockParams to_block_params(const FunAsrNanoHParams & hp) {
     return p;
 }
 
-} // namespace
+}  // namespace
 
-PrefillBuild build_prefill_graph(ggml_context *                  ctx,
-                                 const FunAsrNanoWeights &       weights,
-                                 const FunAsrNanoHParams &       hp,
+PrefillBuild build_prefill_graph(ggml_context *                   ctx,
+                                 const FunAsrNanoWeights &        weights,
+                                 const FunAsrNanoHParams &        hp,
                                  transcribe::causal_lm::KvCache & kv_cache,
-                                 int                             T_prompt,
-                                 int                             T_audio,
-                                 int                             prefix_len,
-                                 int                             suffix_len,
-                                 bool                            use_flash,
-                                 bool                            slice_last)
-{
-    PrefillBuild pb {};
+                                 int                              T_prompt,
+                                 int                              T_audio,
+                                 int                              prefix_len,
+                                 int                              suffix_len,
+                                 bool                             use_flash,
+                                 bool                             slice_last) {
+    PrefillBuild pb{};
     pb.T_prompt   = T_prompt;
     pb.T_audio    = T_audio;
     pb.prefix_len = prefix_len;
     pb.suffix_len = suffix_len;
 
     if (ctx == nullptr || T_prompt <= 0 || T_audio < 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "funasr_nano decoder: invalid arg (T_prompt=%d, T_audio=%d)",
-                     T_prompt, T_audio);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "funasr_nano decoder: invalid arg (T_prompt=%d, T_audio=%d)", T_prompt,
+                T_audio);
         return pb;
     }
-    if (prefix_len < 0 || suffix_len < 0 ||
-        prefix_len + T_audio + suffix_len != T_prompt)
-    {
+    if (prefix_len < 0 || suffix_len < 0 || prefix_len + T_audio + suffix_len != T_prompt) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "funasr_nano decoder: prefix_len(%d) + T_audio(%d) + suffix_len(%d) != T_prompt(%d)",
-                     prefix_len, T_audio, suffix_len, T_prompt);
+                "funasr_nano decoder: prefix_len(%d) + T_audio(%d) + suffix_len(%d) != T_prompt(%d)", prefix_len,
+                T_audio, suffix_len, T_prompt);
         return pb;
     }
     if (kv_cache.self_k == nullptr || kv_cache.self_v == nullptr) {
@@ -102,9 +99,8 @@ PrefillBuild build_prefill_graph(ggml_context *                  ctx,
         return pb;
     }
     if (T_prompt > kv_cache.n_ctx) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "funasr_nano decoder: T_prompt=%d exceeds kv_cache.n_ctx=%d",
-                     T_prompt, kv_cache.n_ctx);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "funasr_nano decoder: T_prompt=%d exceeds kv_cache.n_ctx=%d", T_prompt,
+                kv_cache.n_ctx);
         return pb;
     }
 
@@ -136,44 +132,41 @@ PrefillBuild build_prefill_graph(ggml_context *                  ctx,
 
     ggml_cgraph * gf = ggml_new_graph_custom(ctx, /*size=*/16384, /*grads=*/false);
     if (gf == nullptr) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "funasr_nano decoder: ggml_new_graph_custom failed");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "funasr_nano decoder: ggml_new_graph_custom failed");
         return pb;
     }
     pb.graph = gf;
 
     // ---------- Token embedding ----------
-    ggml_tensor * token_emb_all = ggml_get_rows(
-        ctx, weights.dec_embed.token_w, pb.input_ids_in);
+    ggml_tensor * token_emb_all = ggml_get_rows(ctx, weights.dec_embed.token_w, pb.input_ids_in);
     named(token_emb_all, "dec.token_emb");
     pb.dumps.token_emb = token_emb_all;
     transcribe::debug::mark_tensor_for_dump(token_emb_all);
 
     // ---------- Audio injection via 3-way concat ----------
-    const size_t emb_elem = ggml_element_size(token_emb_all);
+    const size_t  emb_elem = ggml_element_size(token_emb_all);
     ggml_tensor * x_prefix = nullptr;
     if (prefix_len > 0) {
-        x_prefix = ggml_view_2d(ctx, token_emb_all,
-                                hidden, prefix_len,
-                                emb_elem * hidden, /*off=*/0);
+        x_prefix = ggml_view_2d(ctx, token_emb_all, hidden, prefix_len, emb_elem * hidden, /*off=*/0);
         x_prefix = ggml_cont(ctx, x_prefix);
     }
 
     ggml_tensor * x_suffix = nullptr;
     if (suffix_len > 0) {
-        x_suffix = ggml_view_2d(ctx, token_emb_all,
-                                hidden, suffix_len,
-                                emb_elem * hidden,
-                                emb_elem * hidden *
-                                    static_cast<size_t>(prefix_len + T_audio));
+        x_suffix = ggml_view_2d(ctx, token_emb_all, hidden, suffix_len, emb_elem * hidden,
+                                emb_elem * hidden * static_cast<size_t>(prefix_len + T_audio));
         x_suffix = ggml_cont(ctx, x_suffix);
     }
 
     ggml_tensor * x;
     if (T_audio > 0) {
         x = pb.audio_in;
-        if (x_prefix != nullptr) x = ggml_concat(ctx, x_prefix, x, /*dim=*/1);
-        if (x_suffix != nullptr) x = ggml_concat(ctx, x, x_suffix, /*dim=*/1);
+        if (x_prefix != nullptr) {
+            x = ggml_concat(ctx, x_prefix, x, /*dim=*/1);
+        }
+        if (x_suffix != nullptr) {
+            x = ggml_concat(ctx, x, x_suffix, /*dim=*/1);
+        }
     } else {
         x = token_emb_all;
     }
@@ -183,20 +176,12 @@ PrefillBuild build_prefill_graph(ggml_context *                  ctx,
 
     // ---------- Block stack ----------
     for (int il = 0; il < n_layer; ++il) {
-        causal_lm::BlockOpts opts {};
+        causal_lm::BlockOpts opts{};
         opts.use_flash             = use_flash;
         opts.slice_last_before_ffn = slice_last && (il == n_layer - 1);
 
-        x = causal_lm::block_prefill(
-            ctx, gf, x,
-            to_block_view(weights.dec_blocks[il]),
-            block_params,
-            kv_cache,
-            il,
-            T_prompt,
-            pb.mask_in,
-            pb.positions_in,
-            opts);
+        x = causal_lm::block_prefill(ctx, gf, x, to_block_view(weights.dec_blocks[il]), block_params, kv_cache, il,
+                                     T_prompt, pb.mask_in, pb.positions_in, opts);
 
         if (il == 0) {
             named(x, "dec.block.0.out");
@@ -212,8 +197,7 @@ PrefillBuild build_prefill_graph(ggml_context *                  ctx,
     }
 
     // ---------- Final RMSNorm + tied lm_head ----------
-    x = ggml_mul(ctx, ggml_rms_norm(ctx, x, rms_eps),
-                 weights.dec_final.norm_w);
+    x = ggml_mul(ctx, ggml_rms_norm(ctx, x, rms_eps), weights.dec_final.norm_w);
     named(x, "dec.out_before_head");
     pb.dumps.out_before_head = x;
     transcribe::debug::mark_tensor_for_dump(x);
@@ -222,15 +206,13 @@ PrefillBuild build_prefill_graph(ggml_context *                  ctx,
     if (slice_last) {
         last_x = x;
     } else {
-        last_x = ggml_view_2d(
-            ctx, x, hidden, 1,
-            ggml_element_size(x) * hidden,
-            ggml_element_size(x) * hidden * static_cast<size_t>(T_prompt - 1));
+        last_x = ggml_view_2d(ctx, x, hidden, 1, ggml_element_size(x) * hidden,
+                              ggml_element_size(x) * hidden * static_cast<size_t>(T_prompt - 1));
         last_x = ggml_cont(ctx, last_x);
     }
 
     ggml_tensor * logits = ggml_mul_mat(ctx, weights.dec_embed.token_w, last_x);
-    logits = ggml_reshape_1d(ctx, logits, vocab);
+    logits               = ggml_reshape_1d(ctx, logits, vocab);
     named(logits, "dec.logits_raw.prefill");
     pb.dumps.logits_raw = logits;
     transcribe::debug::mark_tensor_for_dump(logits);
@@ -239,11 +221,21 @@ PrefillBuild build_prefill_graph(ggml_context *                  ctx,
     ggml_set_output(pb.out);
 
     ggml_build_forward_expand(gf, pb.out);
-    if (pb.dumps.token_emb)       ggml_build_forward_expand(gf, pb.dumps.token_emb);
-    if (pb.dumps.audio_injected)  ggml_build_forward_expand(gf, pb.dumps.audio_injected);
-    if (pb.dumps.block_0_out)     ggml_build_forward_expand(gf, pb.dumps.block_0_out);
-    if (pb.dumps.block_last_out)  ggml_build_forward_expand(gf, pb.dumps.block_last_out);
-    if (pb.dumps.out_before_head) ggml_build_forward_expand(gf, pb.dumps.out_before_head);
+    if (pb.dumps.token_emb) {
+        ggml_build_forward_expand(gf, pb.dumps.token_emb);
+    }
+    if (pb.dumps.audio_injected) {
+        ggml_build_forward_expand(gf, pb.dumps.audio_injected);
+    }
+    if (pb.dumps.block_0_out) {
+        ggml_build_forward_expand(gf, pb.dumps.block_0_out);
+    }
+    if (pb.dumps.block_last_out) {
+        ggml_build_forward_expand(gf, pb.dumps.block_last_out);
+    }
+    if (pb.dumps.out_before_head) {
+        ggml_build_forward_expand(gf, pb.dumps.out_before_head);
+    }
 
     return pb;
 }
@@ -252,19 +244,17 @@ PrefillBuild build_prefill_graph(ggml_context *                  ctx,
 // Step graph (single-token decode)
 // ---------------------------------------------------------------------------
 
-StepBuild build_step_graph(ggml_context *                  ctx,
-                           const FunAsrNanoWeights &       weights,
-                           const FunAsrNanoHParams &       hp,
+StepBuild build_step_graph(ggml_context *                   ctx,
+                           const FunAsrNanoWeights &        weights,
+                           const FunAsrNanoHParams &        hp,
                            transcribe::causal_lm::KvCache & kv_cache,
-                           int                             max_n_kv,
-                           bool                            use_flash)
-{
-    StepBuild sb {};
+                           int                              max_n_kv,
+                           bool                             use_flash) {
+    StepBuild sb{};
     sb.max_n_kv = max_n_kv;
 
     if (ctx == nullptr || max_n_kv <= 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "funasr_nano step: invalid arg (max_n_kv=%d)", max_n_kv);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "funasr_nano step: invalid arg (max_n_kv=%d)", max_n_kv);
         return sb;
     }
     if (kv_cache.self_k == nullptr) {
@@ -272,9 +262,8 @@ StepBuild build_step_graph(ggml_context *                  ctx,
         return sb;
     }
     if (max_n_kv > kv_cache.n_ctx) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "funasr_nano step: max_n_kv=%d exceeds kv_cache.n_ctx=%d",
-                     max_n_kv, kv_cache.n_ctx);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "funasr_nano step: max_n_kv=%d exceeds kv_cache.n_ctx=%d", max_n_kv,
+                kv_cache.n_ctx);
         return sb;
     }
 
@@ -302,33 +291,21 @@ StepBuild build_step_graph(ggml_context *                  ctx,
 
     ggml_cgraph * gf = ggml_new_graph_custom(ctx, /*size=*/8192, /*grads=*/false);
     if (gf == nullptr) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "funasr_nano step: ggml_new_graph_custom failed");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "funasr_nano step: ggml_new_graph_custom failed");
         return sb;
     }
     sb.graph = gf;
 
-    ggml_tensor * x = ggml_get_rows(ctx, weights.dec_embed.token_w,
-                                    sb.input_id_in);
+    ggml_tensor * x = ggml_get_rows(ctx, weights.dec_embed.token_w, sb.input_id_in);
 
     for (int il = 0; il < n_layer; ++il) {
-        x = causal_lm::block_step(
-            ctx, gf, x,
-            to_block_view(weights.dec_blocks[il]),
-            block_params,
-            kv_cache,
-            il,
-            max_n_kv,
-            sb.mask_in,
-            sb.position_in,
-            sb.kv_idx_in,
-            use_flash);
+        x = causal_lm::block_step(ctx, gf, x, to_block_view(weights.dec_blocks[il]), block_params, kv_cache, il,
+                                  max_n_kv, sb.mask_in, sb.position_in, sb.kv_idx_in, use_flash);
     }
 
-    x = ggml_mul(ctx, ggml_rms_norm(ctx, x, rms_eps),
-                 weights.dec_final.norm_w);
+    x                    = ggml_mul(ctx, ggml_rms_norm(ctx, x, rms_eps), weights.dec_final.norm_w);
     ggml_tensor * logits = ggml_mul_mat(ctx, weights.dec_embed.token_w, x);
-    logits = ggml_reshape_1d(ctx, logits, vocab);
+    logits               = ggml_reshape_1d(ctx, logits, vocab);
     ggml_set_name(logits, "step.logits");
 
     ggml_tensor * amax = ggml_argmax(ctx, logits);
@@ -347,35 +324,31 @@ StepBuild build_step_graph(ggml_context *                  ctx,
 // Batched prefill / step (offline transcribe_run_batch)
 // ---------------------------------------------------------------------------
 
-PrefillBuildBatched build_prefill_graph_batched(
-    ggml_context *                  ctx,
-    const FunAsrNanoWeights &       weights,
-    const FunAsrNanoHParams &       hp,
-    transcribe::causal_lm::KvCache & kv_cache,
-    int                             T_prompt_max,
-    int                             T_audio_max,
-    int                             n_batch,
-    bool                            use_flash)
-{
-    PrefillBuildBatched pb {};
+PrefillBuildBatched build_prefill_graph_batched(ggml_context *                   ctx,
+                                                const FunAsrNanoWeights &        weights,
+                                                const FunAsrNanoHParams &        hp,
+                                                transcribe::causal_lm::KvCache & kv_cache,
+                                                int                              T_prompt_max,
+                                                int                              T_audio_max,
+                                                int                              n_batch,
+                                                bool                             use_flash) {
+    PrefillBuildBatched pb{};
     pb.T_prompt_max = T_prompt_max;
     pb.T_audio_max  = T_audio_max;
     pb.n_batch      = n_batch;
 
-    if (ctx == nullptr || T_prompt_max <= 0 || T_audio_max <= 0 ||
-        n_batch <= 0 || !use_flash ||
-        kv_cache.self_k == nullptr || kv_cache.n_batch != n_batch ||
-        T_prompt_max > kv_cache.n_ctx) {
+    if (ctx == nullptr || T_prompt_max <= 0 || T_audio_max <= 0 || n_batch <= 0 || !use_flash ||
+        kv_cache.self_k == nullptr || kv_cache.n_batch != n_batch || T_prompt_max > kv_cache.n_ctx) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "funasr_nano prefill(batched): invalid arg");
         return pb;
     }
 
-    const int64_t hidden  = hp.dec_hidden;
-    const int64_t vocab   = hp.dec_vocab_size;
-    const int     n_layer = hp.dec_n_layers;
-    const float   rms_eps = hp.dec_rms_norm_eps;
-    const int     B       = n_batch;
-    const auto block_params = to_block_params(hp);
+    const int64_t hidden       = hp.dec_hidden;
+    const int64_t vocab        = hp.dec_vocab_size;
+    const int     n_layer      = hp.dec_n_layers;
+    const float   rms_eps      = hp.dec_rms_norm_eps;
+    const int     B            = n_batch;
+    const auto    block_params = to_block_params(hp);
 
     pb.input_ids_in = ggml_new_tensor_2d(ctx, GGML_TYPE_I32, T_prompt_max, B);
     ggml_set_input(pb.input_ids_in);
@@ -383,11 +356,9 @@ PrefillBuildBatched build_prefill_graph_batched(
     // set_rows): a k-quant token_embd get_rows is unsupported on CUDA and runs
     // on CPU; a set_rows consuming that CPU tensor straddles the CPU/CUDA split
     // and faults. x*keep_mask + audio_dense crosses the split cleanly.
-    pb.audio_dense_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, hidden,
-                                           static_cast<int64_t>(T_prompt_max) * B);
+    pb.audio_dense_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, hidden, static_cast<int64_t>(T_prompt_max) * B);
     ggml_set_input(pb.audio_dense_in);
-    pb.keep_mask_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, 1,
-                                         static_cast<int64_t>(T_prompt_max) * B);
+    pb.keep_mask_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, 1, static_cast<int64_t>(T_prompt_max) * B);
     ggml_set_input(pb.keep_mask_in);
     pb.positions_in = ggml_new_tensor_1d(ctx, GGML_TYPE_I32, T_prompt_max);
     ggml_set_input(pb.positions_in);
@@ -399,65 +370,62 @@ PrefillBuildBatched build_prefill_graph_batched(
     ggml_set_input(pb.last_idx_in);
 
     ggml_cgraph * gf = ggml_new_graph_custom(ctx, /*size=*/16384, /*grads=*/false);
-    if (gf == nullptr) return pb;
+    if (gf == nullptr) {
+        return pb;
+    }
     pb.graph = gf;
 
-    ggml_tensor * ids_flat =
-        ggml_reshape_1d(ctx, pb.input_ids_in,
-                        static_cast<int64_t>(T_prompt_max) * B);
+    ggml_tensor * ids_flat = ggml_reshape_1d(ctx, pb.input_ids_in, static_cast<int64_t>(T_prompt_max) * B);
     // x is 2D [hidden, T_prompt_max*B] (contiguous). Blend the audio embeds in
     // elementwise: x = x*keep_mask + audio_dense. keep_mask broadcasts over
     // hidden (ne[0]). Then reshape to 3D for the batched block stack.
-    ggml_tensor * x = ggml_get_rows(ctx, weights.dec_embed.token_w, ids_flat);
-    x = ggml_add(ctx, ggml_mul(ctx, x, pb.keep_mask_in), pb.audio_dense_in);
-    x = ggml_reshape_3d(ctx, x, hidden, T_prompt_max, B);
+    ggml_tensor * x        = ggml_get_rows(ctx, weights.dec_embed.token_w, ids_flat);
+    x                      = ggml_add(ctx, ggml_mul(ctx, x, pb.keep_mask_in), pb.audio_dense_in);
+    x                      = ggml_reshape_3d(ctx, x, hidden, T_prompt_max, B);
 
     for (int il = 0; il < n_layer; ++il) {
-        x = causal_lm::block_prefill_batched(
-            ctx, gf, x, to_block_view(weights.dec_blocks[il]),
-            block_params, kv_cache, il, T_prompt_max, B,
-            pb.mask_in, pb.positions_in, pb.kv_idx_in, use_flash);
-        if (x == nullptr) { pb.graph = nullptr; return pb; }
+        x = causal_lm::block_prefill_batched(ctx, gf, x, to_block_view(weights.dec_blocks[il]), block_params, kv_cache,
+                                             il, T_prompt_max, B, pb.mask_in, pb.positions_in, pb.kv_idx_in, use_flash);
+        if (x == nullptr) {
+            pb.graph = nullptr;
+            return pb;
+        }
     }
 
     ggml_tensor * x_last = ggml_get_rows(ctx, x, pb.last_idx_in);
-    x_last = ggml_reshape_2d(ctx, x_last, hidden, B);
-    x_last = ggml_mul(ctx, ggml_rms_norm(ctx, x_last, rms_eps),
-                      weights.dec_final.norm_w);
+    x_last               = ggml_reshape_2d(ctx, x_last, hidden, B);
+    x_last               = ggml_mul(ctx, ggml_rms_norm(ctx, x_last, rms_eps), weights.dec_final.norm_w);
     ggml_tensor * logits = ggml_mul_mat(ctx, weights.dec_embed.token_w, x_last);
-    logits = ggml_reshape_2d(ctx, logits, vocab, B);
-    pb.logits = logits;
-    pb.out = ggml_argmax(ctx, logits);
+    logits               = ggml_reshape_2d(ctx, logits, vocab, B);
+    pb.logits            = logits;
+    pb.out               = ggml_argmax(ctx, logits);
     ggml_set_output(pb.out);
     ggml_build_forward_expand(gf, pb.out);
     ggml_build_forward_expand(gf, logits);
     return pb;
 }
 
-StepBuildBatched build_step_graph_batched(
-    ggml_context *                  ctx,
-    const FunAsrNanoWeights &       weights,
-    const FunAsrNanoHParams &       hp,
-    transcribe::causal_lm::KvCache & kv_cache,
-    int                             max_n_kv,
-    int                             n_batch,
-    bool                            use_flash)
-{
-    StepBuildBatched sb {};
+StepBuildBatched build_step_graph_batched(ggml_context *                   ctx,
+                                          const FunAsrNanoWeights &        weights,
+                                          const FunAsrNanoHParams &        hp,
+                                          transcribe::causal_lm::KvCache & kv_cache,
+                                          int                              max_n_kv,
+                                          int                              n_batch,
+                                          bool                             use_flash) {
+    StepBuildBatched sb{};
     sb.max_n_kv = max_n_kv;
     sb.n_batch  = n_batch;
-    if (ctx == nullptr || max_n_kv <= 0 || n_batch <= 0 || !use_flash ||
-        kv_cache.self_k == nullptr || kv_cache.n_batch != n_batch ||
-        max_n_kv > kv_cache.n_ctx) {
+    if (ctx == nullptr || max_n_kv <= 0 || n_batch <= 0 || !use_flash || kv_cache.self_k == nullptr ||
+        kv_cache.n_batch != n_batch || max_n_kv > kv_cache.n_ctx) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "funasr_nano step(batched): invalid arg");
         return sb;
     }
 
-    const int64_t vocab   = hp.dec_vocab_size;
-    const int     n_layer = hp.dec_n_layers;
-    const float   rms_eps = hp.dec_rms_norm_eps;
-    const int     B       = n_batch;
-    const auto block_params = to_block_params(hp);
+    const int64_t vocab        = hp.dec_vocab_size;
+    const int     n_layer      = hp.dec_n_layers;
+    const float   rms_eps      = hp.dec_rms_norm_eps;
+    const int     B            = n_batch;
+    const auto    block_params = to_block_params(hp);
 
     sb.input_ids_in = ggml_new_tensor_1d(ctx, GGML_TYPE_I32, B);
     ggml_set_input(sb.input_ids_in);
@@ -469,28 +437,31 @@ StepBuildBatched build_step_graph_batched(
     ggml_set_input(sb.mask_in);
 
     ggml_cgraph * gf = ggml_new_graph_custom(ctx, /*size=*/8192, /*grads=*/false);
-    if (gf == nullptr) return sb;
+    if (gf == nullptr) {
+        return sb;
+    }
     sb.graph = gf;
 
     ggml_tensor * x = ggml_get_rows(ctx, weights.dec_embed.token_w,
                                     sb.input_ids_in);  // [hidden, B]
     for (int il = 0; il < n_layer; ++il) {
-        x = causal_lm::block_step_batched(
-            ctx, gf, x, to_block_view(weights.dec_blocks[il]),
-            block_params, kv_cache, il, max_n_kv, B,
-            sb.mask_in, sb.position_in, sb.kv_idx_in, use_flash);
-        if (x == nullptr) { sb.graph = nullptr; return sb; }
+        x = causal_lm::block_step_batched(ctx, gf, x, to_block_view(weights.dec_blocks[il]), block_params, kv_cache, il,
+                                          max_n_kv, B, sb.mask_in, sb.position_in, sb.kv_idx_in, use_flash);
+        if (x == nullptr) {
+            sb.graph = nullptr;
+            return sb;
+        }
     }
 
-    x = ggml_mul(ctx, ggml_rms_norm(ctx, x, rms_eps), weights.dec_final.norm_w);
+    x                    = ggml_mul(ctx, ggml_rms_norm(ctx, x, rms_eps), weights.dec_final.norm_w);
     ggml_tensor * logits = ggml_mul_mat(ctx, weights.dec_embed.token_w, x);
-    logits = ggml_reshape_2d(ctx, logits, vocab, B);
-    sb.logits = logits;
-    sb.out = ggml_argmax(ctx, logits);
+    logits               = ggml_reshape_2d(ctx, logits, vocab, B);
+    sb.logits            = logits;
+    sb.out               = ggml_argmax(ctx, logits);
     ggml_set_output(sb.out);
     ggml_build_forward_expand(gf, sb.out);
     ggml_build_forward_expand(gf, logits);
     return sb;
 }
 
-} // namespace transcribe::funasr_nano
+}  // namespace transcribe::funasr_nano
diff --git a/src/arch/funasr_nano/decoder.h b/src/arch/funasr_nano/decoder.h
index 95f52ac8..924a5a94 100644
--- a/src/arch/funasr_nano/decoder.h
+++ b/src/arch/funasr_nano/decoder.h
@@ -7,11 +7,10 @@
 
 #pragma once
 
-#include "funasr_nano.h"
 #include "causal_lm/causal_lm.h"
-#include "weights.h"
-
+#include "funasr_nano.h"
 #include "ggml.h"
+#include "weights.h"
 
 struct ggml_context;
 struct ggml_cgraph;
@@ -34,8 +33,8 @@ struct PrefillBuild {
     ggml_tensor * positions_in = nullptr;  // [T_prompt] i32
     ggml_tensor * mask_in      = nullptr;  // [T_prompt, T_prompt] f16
     ggml_tensor * out          = nullptr;  // [vocab]
-    DecoderDumps  dumps {};
-    ggml_cgraph * graph        = nullptr;
+    DecoderDumps  dumps{};
+    ggml_cgraph * graph = nullptr;
 
     int T_prompt   = 0;
     int T_audio    = 0;
@@ -43,16 +42,16 @@ struct PrefillBuild {
     int suffix_len = 0;
 };
 
-PrefillBuild build_prefill_graph(ggml_context *                  ctx,
-                                 const FunAsrNanoWeights &       weights,
-                                 const FunAsrNanoHParams &       hp,
+PrefillBuild build_prefill_graph(ggml_context *                   ctx,
+                                 const FunAsrNanoWeights &        weights,
+                                 const FunAsrNanoHParams &        hp,
                                  transcribe::causal_lm::KvCache & kv_cache,
-                                 int                             T_prompt,
-                                 int                             T_audio,
-                                 int                             prefix_len,
-                                 int                             suffix_len,
-                                 bool                            use_flash,
-                                 bool                            slice_last);
+                                 int                              T_prompt,
+                                 int                              T_audio,
+                                 int                              prefix_len,
+                                 int                              suffix_len,
+                                 bool                             use_flash,
+                                 bool                             slice_last);
 
 struct StepBuild {
     ggml_tensor * input_id_in = nullptr;  // [1] i32
@@ -66,12 +65,12 @@ struct StepBuild {
     int max_n_kv = 0;
 };
 
-StepBuild build_step_graph(ggml_context *                  ctx,
-                           const FunAsrNanoWeights &       weights,
-                           const FunAsrNanoHParams &       hp,
+StepBuild build_step_graph(ggml_context *                   ctx,
+                           const FunAsrNanoWeights &        weights,
+                           const FunAsrNanoHParams &        hp,
                            transcribe::causal_lm::KvCache & kv_cache,
-                           int                             max_n_kv,
-                           bool                            use_flash);
+                           int                              max_n_kv,
+                           bool                             use_flash);
 
 // ---------- Batched prefill / step (offline transcribe_run_batch) ----------
 // Mirror arch/qwen3_asr's batched builders; the only family difference is the
@@ -79,7 +78,7 @@ StepBuild build_step_graph(ggml_context *                  ctx,
 // causal_lm::block_prefill_batched / block_step_batched.
 
 struct PrefillBuildBatched {
-    ggml_tensor * input_ids_in = nullptr;  // [T_prompt_max, B] i32
+    ggml_tensor * input_ids_in   = nullptr;  // [T_prompt_max, B] i32
     // Audio injection via elementwise blend (no set_rows): audio_dense holds
     // the audio embeds scattered (host-side) into their prompt positions, zero
     // elsewhere; keep_mask is 0 at audio positions and 1 elsewhere. The block
@@ -87,27 +86,26 @@ struct PrefillBuildBatched {
     // split (forced by k-quant token_embd get_rows) cleanly, unlike a set_rows.
     ggml_tensor * audio_dense_in = nullptr;  // [hidden, T_prompt_max*B] f32
     ggml_tensor * keep_mask_in   = nullptr;  // [1, T_prompt_max*B] f32 (0=audio,1=keep)
-    ggml_tensor * positions_in = nullptr;  // [T_prompt_max] i32
-    ggml_tensor * mask_in      = nullptr;  // [T_prompt_max, T_prompt_max] f16
-    ggml_tensor * kv_idx_in    = nullptr;  // [T_prompt_max, B] i64
-    ggml_tensor * last_idx_in  = nullptr;  // [1, B] i32
-    ggml_tensor * logits       = nullptr;  // [vocab, B]
-    ggml_tensor * out          = nullptr;  // [B] i32 argmax
-    ggml_cgraph * graph        = nullptr;
-    int T_prompt_max = 0;
-    int T_audio_max  = 0;
-    int n_batch      = 0;
+    ggml_tensor * positions_in   = nullptr;  // [T_prompt_max] i32
+    ggml_tensor * mask_in        = nullptr;  // [T_prompt_max, T_prompt_max] f16
+    ggml_tensor * kv_idx_in      = nullptr;  // [T_prompt_max, B] i64
+    ggml_tensor * last_idx_in    = nullptr;  // [1, B] i32
+    ggml_tensor * logits         = nullptr;  // [vocab, B]
+    ggml_tensor * out            = nullptr;  // [B] i32 argmax
+    ggml_cgraph * graph          = nullptr;
+    int           T_prompt_max   = 0;
+    int           T_audio_max    = 0;
+    int           n_batch        = 0;
 };
 
-PrefillBuildBatched build_prefill_graph_batched(
-    ggml_context *                  ctx,
-    const FunAsrNanoWeights &       weights,
-    const FunAsrNanoHParams &       hp,
-    transcribe::causal_lm::KvCache & kv_cache,
-    int                             T_prompt_max,
-    int                             T_audio_max,
-    int                             n_batch,
-    bool                            use_flash);
+PrefillBuildBatched build_prefill_graph_batched(ggml_context *                   ctx,
+                                                const FunAsrNanoWeights &        weights,
+                                                const FunAsrNanoHParams &        hp,
+                                                transcribe::causal_lm::KvCache & kv_cache,
+                                                int                              T_prompt_max,
+                                                int                              T_audio_max,
+                                                int                              n_batch,
+                                                bool                             use_flash);
 
 struct StepBuildBatched {
     ggml_tensor * input_ids_in = nullptr;  // [B] i32
@@ -117,17 +115,16 @@ struct StepBuildBatched {
     ggml_tensor * logits       = nullptr;  // [vocab, B]
     ggml_tensor * out          = nullptr;  // [B] i32 argmax
     ggml_cgraph * graph        = nullptr;
-    int max_n_kv = 0;
-    int n_batch  = 0;
+    int           max_n_kv     = 0;
+    int           n_batch      = 0;
 };
 
-StepBuildBatched build_step_graph_batched(
-    ggml_context *                  ctx,
-    const FunAsrNanoWeights &       weights,
-    const FunAsrNanoHParams &       hp,
-    transcribe::causal_lm::KvCache & kv_cache,
-    int                             max_n_kv,
-    int                             n_batch,
-    bool                            use_flash);
+StepBuildBatched build_step_graph_batched(ggml_context *                   ctx,
+                                          const FunAsrNanoWeights &        weights,
+                                          const FunAsrNanoHParams &        hp,
+                                          transcribe::causal_lm::KvCache & kv_cache,
+                                          int                              max_n_kv,
+                                          int                              n_batch,
+                                          bool                             use_flash);
 
-} // namespace transcribe::funasr_nano
+}  // namespace transcribe::funasr_nano
diff --git a/src/arch/funasr_nano/encoder.cpp b/src/arch/funasr_nano/encoder.cpp
index 4fa8940c..dfe11594 100644
--- a/src/arch/funasr_nano/encoder.cpp
+++ b/src/arch/funasr_nano/encoder.cpp
@@ -11,14 +11,12 @@
 
 #include "encoder.h"
 
-#include "weights.h"
-
 #include "conformer/conformer.h"
+#include "ggml.h"
 #include "sanm/sanm.h"
 #include "transcribe-debug.h"
 #include "transcribe-log.h"
-
-#include "ggml.h"
+#include "weights.h"
 
 #include <cmath>
 #include <cstdio>
@@ -56,19 +54,18 @@ void mark_dump(ggml_tensor *& slot, ggml_tensor * t, const char * name) {
     slot = t;
 }
 
-} // namespace
+}  // namespace
 
-EncoderBuild build_encoder_graph(ggml_context *             ctx,
-                                 const FunAsrNanoWeights &  w,
-                                 const FunAsrNanoHParams &  hp,
-                                 int                        n_lfr_frames)
-{
-    EncoderBuild eb {};
+EncoderBuild build_encoder_graph(ggml_context *            ctx,
+                                 const FunAsrNanoWeights & w,
+                                 const FunAsrNanoHParams & hp,
+                                 int                       n_lfr_frames) {
+    EncoderBuild eb{};
     if (ctx == nullptr || n_lfr_frames <= 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "funasr_nano encoder: invalid arg "
-                     "(ctx=%p, n_lfr_frames=%d)",
-                     static_cast<void *>(ctx), n_lfr_frames);
+                "funasr_nano encoder: invalid arg "
+                "(ctx=%p, n_lfr_frames=%d)",
+                static_cast<void *>(ctx), n_lfr_frames);
         return eb;
     }
 
@@ -76,7 +73,7 @@ EncoderBuild build_encoder_graph(ggml_context *             ctx,
     const int d_model = hp.enc_d_model;
     const int T       = n_lfr_frames;
 
-    const sanm::SanmBlockParams block_params {
+    const sanm::SanmBlockParams block_params{
         /*n_heads=*/hp.enc_n_heads,
         /*d_model=*/d_model,
         /*kernel=*/hp.enc_kernel,
@@ -92,9 +89,9 @@ EncoderBuild build_encoder_graph(ggml_context *             ctx,
     ggml_set_input(eb.pe_in);
 
     // Embedding scale + PE add.
-    const float embed_scale = std::sqrt(static_cast<float>(d_model));
-    ggml_tensor * x = ggml_scale(ctx, eb.frontend_in, embed_scale);
-    x = ggml_add(ctx, x, eb.pe_in);
+    const float   embed_scale = std::sqrt(static_cast<float>(d_model));
+    ggml_tensor * x           = ggml_scale(ctx, eb.frontend_in, embed_scale);
+    x                         = ggml_add(ctx, x, eb.pe_in);
     mark_dump(eb.dumps.embed_out, x, "enc.embed.out");
 
     // encoders0[0] (560 → 512 projection).
@@ -106,8 +103,7 @@ EncoderBuild build_encoder_graph(ggml_context *             ctx,
         const int last_idx = n_main - 1;
         const int mid_idx  = n_main / 2;
         for (int i = 0; i < n_main; ++i) {
-            x = sanm::sanm_block_residual(
-                ctx, x, to_sanm_view(w.encoders[i]), block_params);
+            x = sanm::sanm_block_residual(ctx, x, to_sanm_view(w.encoders[i]), block_params);
             if (i == 0) {
                 mark_dump(eb.dumps.encoders_first, x, "enc.encoders.0.out");
             } else if (i == mid_idx) {
@@ -130,8 +126,7 @@ EncoderBuild build_encoder_graph(ggml_context *             ctx,
         const int last_idx = n_tp - 1;
         const int mid_idx  = n_tp / 2;
         for (int i = 0; i < n_tp; ++i) {
-            x = sanm::sanm_block_residual(
-                ctx, x, to_sanm_view(w.tp_encoders[i]), block_params);
+            x = sanm::sanm_block_residual(ctx, x, to_sanm_view(w.tp_encoders[i]), block_params);
             if (i == 0) {
                 mark_dump(eb.dumps.tp_encoders_first, x, "enc.tp_encoders.0.out");
             } else if (i == mid_idx) {
@@ -161,4 +156,4 @@ EncoderBuild build_encoder_graph(ggml_context *             ctx,
     return eb;
 }
 
-} // namespace transcribe::funasr_nano
+}  // namespace transcribe::funasr_nano
diff --git a/src/arch/funasr_nano/encoder.h b/src/arch/funasr_nano/encoder.h
index bb0b606d..9772d405 100644
--- a/src/arch/funasr_nano/encoder.h
+++ b/src/arch/funasr_nano/encoder.h
@@ -41,13 +41,13 @@ struct EncoderBuild {
     ggml_tensor * frontend_in = nullptr;  // [d_input, T_lfr] f32 input
     ggml_tensor * pe_in       = nullptr;  // [d_input, T_lfr] f32 sinusoidal PE
     ggml_tensor * out         = nullptr;  // [d_model, T_lfr]
-    EncoderDumps  dumps {};
+    EncoderDumps  dumps{};
     ggml_cgraph * graph = nullptr;
 };
 
-EncoderBuild build_encoder_graph(ggml_context *             compute_ctx,
-                                 const FunAsrNanoWeights &  weights,
-                                 const FunAsrNanoHParams &  hp,
-                                 int                        n_lfr_frames);
+EncoderBuild build_encoder_graph(ggml_context *            compute_ctx,
+                                 const FunAsrNanoWeights & weights,
+                                 const FunAsrNanoHParams & hp,
+                                 int                       n_lfr_frames);
 
-} // namespace transcribe::funasr_nano
+}  // namespace transcribe::funasr_nano
diff --git a/src/arch/funasr_nano/funasr_nano.h b/src/arch/funasr_nano/funasr_nano.h
index 5642c2f2..b08eb0fb 100644
--- a/src/arch/funasr_nano/funasr_nano.h
+++ b/src/arch/funasr_nano/funasr_nano.h
@@ -5,14 +5,13 @@
 
 #pragma once
 
-#include "weights.h"
-
 #include "causal_lm/causal_lm.h"
 #include "transcribe-backend.h"
-#include "transcribe-session.h"
 #include "transcribe-kaldi-fbank.h"
 #include "transcribe-model.h"
+#include "transcribe-session.h"
 #include "transcribe-tokenizer.h"
+#include "weights.h"
 
 #include <cstdint>
 #include <memory>
@@ -49,13 +48,13 @@ struct ChatTokens {
 // ---------------------------------------------------------------------------
 
 struct FunAsrNanoModel final : public transcribe_model {
-    Tokenizer            tok;
-    FunAsrNanoHParams    hparams;
-    FunAsrNanoWeights    weights;
-    ggml_context *       ctx_meta = nullptr;
+    Tokenizer         tok;
+    FunAsrNanoHParams hparams;
+    FunAsrNanoWeights weights;
+    ggml_context *    ctx_meta = nullptr;
 
-    transcribe::BackendPlan       plan;
-    ggml_backend_buffer_t         backend_buffer = nullptr;
+    transcribe::BackendPlan                    plan;
+    ggml_backend_buffer_t                      backend_buffer = nullptr;
     transcribe::causal_lm::PackedGateUpHandles packed_gate_up;
 
     // Constructed once at load() time; const-after-construction. Kaldi
@@ -82,15 +81,14 @@ struct FunAsrNanoSession final : public transcribe_session {
 
     // Batched KV cache for offline transcribe_run_batch (n_batch slabs).
     transcribe::causal_lm::KvCache kv_cache_batch;
-    int                           kv_batch_cap   = 0;
-    int                           kv_batch_n_ctx = 0;
-
+    int                            kv_batch_cap   = 0;
+    int                            kv_batch_n_ctx = 0;
 
     // Reusable host scratch.
-    std::vector<float> frontend_buf;   // [T_lfr, d_input]
-    std::vector<float> pe_buf;         // [T_lfr, d_input]  sinusoidal PE
-    std::vector<float> enc_host;       // encoder output [d_model, T_lfr]
-    std::vector<float> adaptor_host;   // adaptor output [llm_dim, T_lfr]
+    std::vector<float> frontend_buf;  // [T_lfr, d_input]
+    std::vector<float> pe_buf;        // [T_lfr, d_input]  sinusoidal PE
+    std::vector<float> enc_host;      // encoder output [d_model, T_lfr]
+    std::vector<float> adaptor_host;  // adaptor output [llm_dim, T_lfr]
 
     bool encoder_use_flash = true;
     bool decoder_use_flash = true;
@@ -99,4 +97,4 @@ struct FunAsrNanoSession final : public transcribe_session {
     ~FunAsrNanoSession() override;
 };
 
-} // namespace transcribe::funasr_nano
+}  // namespace transcribe::funasr_nano
diff --git a/src/arch/funasr_nano/model.cpp b/src/arch/funasr_nano/model.cpp
index 985e5ddf..45f365f4 100644
--- a/src/arch/funasr_nano/model.cpp
+++ b/src/arch/funasr_nano/model.cpp
@@ -1,28 +1,25 @@
 // arch/funasr_nano/model.cpp - FunASR-Nano family handler.
 
-#include "funasr_nano.h"
-
 #include "adaptor.h"
+#include "causal_lm/causal_lm.h"
 #include "decoder.h"
 #include "encoder.h"
-#include "weights.h"
-
-#include "causal_lm/causal_lm.h"
+#include "funasr_nano.h"
+#include "ggml-alloc.h"
+#include "ggml-backend.h"
+#include "ggml.h"
+#include "gguf.h"
 #include "sanm/sanm.h"
 #include "transcribe-arch.h"
-#include "transcribe-debug.h"
 #include "transcribe-batch-util.h"
+#include "transcribe-debug.h"
 #include "transcribe-flash-policy.h"
 #include "transcribe-kaldi-fbank.h"
 #include "transcribe-load-common.h"
 #include "transcribe-loader.h"
 #include "transcribe-log.h"
 #include "transcribe-meta.h"
-
-#include "ggml.h"
-#include "ggml-alloc.h"
-#include "ggml-backend.h"
-#include "gguf.h"
+#include "weights.h"
 
 #include <algorithm>
 #include <cmath>
@@ -39,7 +36,7 @@ namespace transcribe::funasr_nano {
 
 extern const Arch arch;
 
-static_assert(std::is_base_of_v<transcribe_model,   FunAsrNanoModel>);
+static_assert(std::is_base_of_v<transcribe_model, FunAsrNanoModel>);
 static_assert(std::is_base_of_v<transcribe_session, FunAsrNanoSession>);
 
 // ---------------------------------------------------------------------------
@@ -69,9 +66,7 @@ FunAsrNanoModel::~FunAsrNanoModel() {
         backend_buffer = nullptr;
     }
     packed_gate_up.free();
-    for (auto it = plan.scheduler_list.rbegin();
-         it != plan.scheduler_list.rend(); ++it)
-    {
+    for (auto it = plan.scheduler_list.rbegin(); it != plan.scheduler_list.rend(); ++it) {
         ggml_backend_free(*it);
     }
     plan.scheduler_list.clear();
@@ -112,42 +107,38 @@ int funasr_nano_context_ceiling(int32_t n_ctx_knob, const FunAsrNanoHParams & hp
 // ms ≈ audio_tokens * folds * lfr_n * hop * 1000 / sr. Returns 0
 // ("unknown / unbounded") if the rate constants are missing.
 int64_t funasr_nano_max_audio_ms(const FunAsrNanoHParams & hp) {
-    if (hp.dec_max_position_embeddings <= 0 ||
-        hp.fe_hop_length <= 0 || hp.fe_sample_rate <= 0 ||
-        hp.fe_lfr_n <= 0) {
+    if (hp.dec_max_position_embeddings <= 0 || hp.fe_hop_length <= 0 || hp.fe_sample_rate <= 0 || hp.fe_lfr_n <= 0) {
         return 0;
     }
     constexpr int k_prompt_overhead = 48;  // chat affixes; advisory
-    const int max_audio_tokens =
-        hp.dec_max_position_embeddings - k_prompt_overhead - k_max_new;
+    const int     max_audio_tokens  = hp.dec_max_position_embeddings - k_prompt_overhead - k_max_new;
     if (max_audio_tokens <= 0) {
         return 0;
     }
-    const int folds = hp.adaptor_use_low_frame_rate ? 8 : 1;
-    const int64_t samples = static_cast<int64_t>(max_audio_tokens) *
-                            folds * hp.fe_lfr_n * hp.fe_hop_length;
+    const int     folds   = hp.adaptor_use_low_frame_rate ? 8 : 1;
+    const int64_t samples = static_cast<int64_t>(max_audio_tokens) * folds * hp.fe_lfr_n * hp.fe_hop_length;
     return samples * 1000 / hp.fe_sample_rate;
 }
 
 // Resolve chat-template special-token ids at load time.
-transcribe_status resolve_chat_tokens(const transcribe::Tokenizer & tok,
-                                      ChatTokens & out)
-{
-    struct PieceSlot { const char * piece; int32_t * slot; };
+transcribe_status resolve_chat_tokens(const transcribe::Tokenizer & tok, ChatTokens & out) {
+    struct PieceSlot {
+        const char * piece;
+        int32_t *    slot;
+    };
+
     const PieceSlot pieces[] = {
-        { "<|im_start|>",  &out.im_start       },
-        { "<|im_end|>",    &out.im_end         },
-        { "\xC4\x8A",      &out.newline        },   // byte-level "\n"
-        { "system",        &out.role_system    },
-        { "user",          &out.role_user      },
-        { "assistant",     &out.role_assistant },
+        { "<|im_start|>", &out.im_start       },
+        { "<|im_end|>",   &out.im_end         },
+        { "\xC4\x8A",     &out.newline        }, // byte-level "\n"
+        { "system",       &out.role_system    },
+        { "user",         &out.role_user      },
+        { "assistant",    &out.role_assistant },
     };
     for (const auto & p : pieces) {
         const int id = tok.find(p.piece);
         if (id < 0) {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "funasr_nano: chat-template piece \"%s\" not in tokenizer",
-                         p.piece);
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "funasr_nano: chat-template piece \"%s\" not in tokenizer", p.piece);
             return TRANSCRIBE_ERR_GGUF;
         }
         *p.slot = id;
@@ -168,10 +159,11 @@ std::string build_funasr_prompt_text(const char * lang, bool use_itn) {
     }
     if (!use_itn) {
         // ，不进行文本规整 = "; do not apply text normalization"
-        out += "\xEF\xBC\x8C\xE4\xB8\x8D\xE8\xBF\x9B\xE8\xA1\x8C"
-               "\xE6\x96\x87\xE6\x9C\xAC\xE8\xA7\x84\xE6\x95\xB4";
+        out +=
+            "\xEF\xBC\x8C\xE4\xB8\x8D\xE8\xBF\x9B\xE8\xA1\x8C"
+            "\xE6\x96\x87\xE6\x9C\xAC\xE8\xA7\x84\xE6\x95\xB4";
     }
-    out += "\xEF\xBC\x9A";   // 全角冒号 = "："
+    out += "\xEF\xBC\x9A";  // 全角冒号 = "："
     return out;
 }
 
@@ -182,32 +174,33 @@ std::string build_funasr_prompt_text(const char * lang, bool use_itn) {
 transcribe_status encode_with_chat_specials(const transcribe::Tokenizer & tok,
                                             const ChatTokens &            ct,
                                             const std::string &           text,
-                                            std::vector<int32_t> &        out_ids)
-{
+                                            std::vector<int32_t> &        out_ids) {
     static const std::string k_im_start = "<|im_start|>";
     static const std::string k_im_end   = "<|im_end|>";
 
     size_t cursor = 0;
     while (cursor < text.size()) {
         size_t s_idx = text.find(k_im_start, cursor);
-        size_t e_idx = text.find(k_im_end,   cursor);
+        size_t e_idx = text.find(k_im_end, cursor);
         size_t next  = std::min(s_idx, e_idx);
         if (next == std::string::npos) {
             // Tail: BPE-encode whatever remains.
             const std::string tail = text.substr(cursor);
             if (!tail.empty()) {
                 std::vector<int32_t> ids;
-                if (const transcribe_status st = tok.encode(tail, ids);
-                    st != TRANSCRIBE_OK) return st;
+                if (const transcribe_status st = tok.encode(tail, ids); st != TRANSCRIBE_OK) {
+                    return st;
+                }
                 out_ids.insert(out_ids.end(), ids.begin(), ids.end());
             }
             return TRANSCRIBE_OK;
         }
         if (next > cursor) {
-            const std::string seg = text.substr(cursor, next - cursor);
+            const std::string    seg = text.substr(cursor, next - cursor);
             std::vector<int32_t> ids;
-            if (const transcribe_status st = tok.encode(seg, ids);
-                st != TRANSCRIBE_OK) return st;
+            if (const transcribe_status st = tok.encode(seg, ids); st != TRANSCRIBE_OK) {
+                return st;
+            }
             out_ids.insert(out_ids.end(), ids.begin(), ids.end());
         }
         if (next == s_idx) {
@@ -238,8 +231,7 @@ transcribe_status build_funasr_nano_prompt(const transcribe::Tokenizer & tok,
                                            bool                          use_itn,
                                            int                           fake_token_len,
                                            std::vector<int32_t> &        out_ids,
-                                           int &                         out_fbank_beg)
-{
+                                           int &                         out_fbank_beg) {
     out_ids.clear();
     out_fbank_beg = 0;
 
@@ -249,18 +241,19 @@ transcribe_status build_funasr_nano_prompt(const transcribe::Tokenizer & tok,
         "<|im_start|>system\nYou are a helpful assistant.<|im_end|>\n"
         "<|im_start|>user\n";
     seg_a += prompt_text;
-    if (const transcribe_status st = encode_with_chat_specials(
-            tok, ct, seg_a, out_ids);
-        st != TRANSCRIBE_OK) return st;
+    if (const transcribe_status st = encode_with_chat_specials(tok, ct, seg_a, out_ids); st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     out_fbank_beg = static_cast<int>(out_ids.size());
-    for (int i = 0; i < fake_token_len; ++i) out_ids.push_back(0);
+    for (int i = 0; i < fake_token_len; ++i) {
+        out_ids.push_back(0);
+    }
 
-    const std::string seg_c =
-        "<|im_end|>\n<|im_start|>assistant\n";
-    if (const transcribe_status st = encode_with_chat_specials(
-            tok, ct, seg_c, out_ids);
-        st != TRANSCRIBE_OK) return st;
+    const std::string seg_c = "<|im_end|>\n<|im_start|>assistant\n";
+    if (const transcribe_status st = encode_with_chat_specials(tok, ct, seg_c, out_ids); st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     return TRANSCRIBE_OK;
 }
@@ -273,14 +266,10 @@ void apply_thread_policy(FunAsrNanoSession * cc) {
 // load
 // ---------------------------------------------------------------------------
 
-transcribe_status load(
-    Loader &                          loader,
-    const transcribe_model_load_params *   params,
-    transcribe_model **               out_model)
-{
+transcribe_status load(Loader & loader, const transcribe_model_load_params * params, transcribe_model ** out_model) {
     const int64_t t_load_start = ggml_time_us();
 
-    auto m = std::make_unique<FunAsrNanoModel>();
+    auto m       = std::make_unique<FunAsrNanoModel>();
     m->arch      = &arch;
     m->t_load_us = 0;
     m->variant   = loader.variant().empty() ? k_default_variant : loader.variant();
@@ -290,23 +279,30 @@ transcribe_status load(
     m->caps.n_languages = 0;
     m->caps.languages   = nullptr;
 
-    if (auto st = read_capability_kv(loader.gguf(), m->caps); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_languages_kv (loader.gguf(), *m);       st != TRANSCRIBE_OK) return st;
+    if (auto st = read_capability_kv(loader.gguf(), m->caps); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_languages_kv(loader.gguf(), *m); st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Tokenizer (gpt2 byte-level BPE; pretokenizer "qwen2").
-    if (auto st = m->tok.load(loader.gguf()); st != TRANSCRIBE_OK) return st;
+    if (auto st = m->tok.load(loader.gguf()); st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Chat template — required; absence is a hard fail because the
     // prompt builder needs the structure.
-    (void)read_optional_string_kv(
-        loader.gguf(), "tokenizer.chat_template", "funasr_nano",
-        "", m->chat_template);
+    (void) read_optional_string_kv(loader.gguf(), "tokenizer.chat_template", "funasr_nano", "", m->chat_template);
 
     // Resolve special token ids.
-    if (auto st = resolve_chat_tokens(m->tok, m->chat_tokens); st != TRANSCRIBE_OK) return st;
+    if (auto st = resolve_chat_tokens(m->tok, m->chat_tokens); st != TRANSCRIBE_OK) {
+        return st;
+    }
 
-    if (auto st = read_funasr_nano_hparams(loader.gguf(), m->hparams);
-        st != TRANSCRIBE_OK) return st;
+    if (auto st = read_funasr_nano_hparams(loader.gguf(), m->hparams); st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Publish the input-length ceiling now that the decoder context window
     // and frontend rate are known. See docs/input-limits.md.
@@ -315,20 +311,17 @@ transcribe_status load(
     // Basis for the session-level limits query (transcribe_session_get_limits):
     // the same constants funasr_nano_max_audio_ms uses, kept so the effective
     // limit can be recomputed at a lowered session n_ctx.
-    if (m->hparams.dec_max_position_embeddings > 0 &&
-        m->hparams.fe_hop_length > 0 && m->hparams.fe_sample_rate > 0 &&
+    if (m->hparams.dec_max_position_embeddings > 0 && m->hparams.fe_hop_length > 0 && m->hparams.fe_sample_rate > 0 &&
         m->hparams.fe_lfr_n > 0) {
-        const int folds = m->hparams.adaptor_use_low_frame_rate ? 8 : 1;
-        m->limits.has_context_cap = true;
-        m->limits.model_max_ctx   = m->hparams.dec_max_position_embeddings;
-        m->limits.prompt_overhead = 48;
-        m->limits.gen_reserve     = k_max_new;
-        m->limits.ms_per_audio_token =
-            static_cast<double>(folds) * m->hparams.fe_lfr_n *
-            m->hparams.fe_hop_length * 1000.0 / m->hparams.fe_sample_rate;
+        const int folds              = m->hparams.adaptor_use_low_frame_rate ? 8 : 1;
+        m->limits.has_context_cap    = true;
+        m->limits.model_max_ctx      = m->hparams.dec_max_position_embeddings;
+        m->limits.prompt_overhead    = 48;
+        m->limits.gen_reserve        = k_max_new;
+        m->limits.ms_per_audio_token = static_cast<double>(folds) * m->hparams.fe_lfr_n * m->hparams.fe_hop_length *
+                                       1000.0 / m->hparams.fe_sample_rate;
         m->limits.kv_elems_per_ctx_token =
-            (int64_t) m->hparams.dec_n_kv_heads *
-            m->hparams.dec_head_dim * m->hparams.dec_n_layers * 2;
+            (int64_t) m->hparams.dec_n_kv_heads * m->hparams.dec_head_dim * m->hparams.dec_n_layers * 2;
     }
 
     m->hparams.vocab_size   = m->tok.n_tokens();
@@ -336,62 +329,51 @@ transcribe_status load(
     m->hparams.eos_token_id = m->tok.eos_id();
 
     if (m->hparams.vocab_size != m->hparams.dec_vocab_size) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "funasr_nano: tokenizer vocab (%d) != decoder vocab_size (%d)",
-                     m->hparams.vocab_size, m->hparams.dec_vocab_size);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "funasr_nano: tokenizer vocab (%d) != decoder vocab_size (%d)",
+                m->hparams.vocab_size, m->hparams.dec_vocab_size);
         return TRANSCRIBE_ERR_GGUF;
     }
     if (m->hparams.eos_token_id < 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "funasr_nano: GGUF tokenizer has no eos_token_id");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "funasr_nano: GGUF tokenizer has no eos_token_id");
         return TRANSCRIBE_ERR_GGUF;
     }
 
     // Reopen with no_alloc to bind the tensor catalog.
-    gguf_init_params init_params {};
+    gguf_init_params init_params{};
     init_params.no_alloc = true;
     init_params.ctx      = &m->ctx_meta;
 
-    gguf_context * gguf_data = gguf_init_from_file(loader.path().c_str(),
-                                                   init_params);
+    gguf_context * gguf_data = gguf_init_from_file(loader.path().c_str(), init_params);
     if (gguf_data == nullptr) {
         return TRANSCRIBE_ERR_GGUF;
     }
 
-    if (auto st = build_funasr_nano_weights(m->ctx_meta, m->hparams, m->weights);
-        st != TRANSCRIBE_OK)
-    {
+    if (auto st = build_funasr_nano_weights(m->ctx_meta, m->hparams, m->weights); st != TRANSCRIBE_OK) {
         gguf_free(gguf_data);
         return st;
     }
 
-    const transcribe_backend_request backend_req =
-        (params != nullptr) ? params->backend : TRANSCRIBE_BACKEND_AUTO;
-    if (auto st = transcribe::load_common::init_backends(
-            backend_req, (params != nullptr) ? params->gpu_device : 0, "funasr_nano", m->plan); st != TRANSCRIBE_OK)
-    {
+    const transcribe_backend_request backend_req = (params != nullptr) ? params->backend : TRANSCRIBE_BACKEND_AUTO;
+    if (auto st = transcribe::load_common::init_backends(backend_req, (params != nullptr) ? params->gpu_device : 0,
+                                                         "funasr_nano", m->plan);
+        st != TRANSCRIBE_OK) {
         gguf_free(gguf_data);
         return st;
     }
-    m->backend = ggml_backend_name(m->plan.primary);
+    m->backend         = ggml_backend_name(m->plan.primary);
     m->primary_backend = m->plan.primary;
 
-    ggml_backend_buffer_t weights_buffer =
-        ggml_backend_alloc_ctx_tensors(m->ctx_meta, m->plan.primary);
+    ggml_backend_buffer_t weights_buffer = ggml_backend_alloc_ctx_tensors(m->ctx_meta, m->plan.primary);
     if (weights_buffer == nullptr) {
         gguf_free(gguf_data);
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "funasr_nano: ggml_backend_alloc_ctx_tensors failed");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "funasr_nano: ggml_backend_alloc_ctx_tensors failed");
         return TRANSCRIBE_ERR_GGUF;
     }
     m->backend_buffer = weights_buffer;
-    ggml_backend_buffer_set_usage(weights_buffer,
-                                  GGML_BACKEND_BUFFER_USAGE_WEIGHTS);
+    ggml_backend_buffer_set_usage(weights_buffer, GGML_BACKEND_BUFFER_USAGE_WEIGHTS);
 
-    if (auto st = transcribe::load_common::stream_tensor_data(
-            loader.path(), gguf_data, m->ctx_meta, "funasr_nano");
-        st != TRANSCRIBE_OK)
-    {
+    if (auto st = transcribe::load_common::stream_tensor_data(loader.path(), gguf_data, m->ctx_meta, "funasr_nano");
+        st != TRANSCRIBE_OK) {
         gguf_free(gguf_data);
         return st;
     }
@@ -403,23 +385,17 @@ transcribe_status load(
         std::vector<transcribe::causal_lm::GateUpEntry> entries;
         entries.reserve(m->weights.dec_blocks.size());
         for (auto & b : m->weights.dec_blocks) {
-            entries.push_back({b.ffn_gate_w, b.ffn_up_w, &b.ffn_gate_up_w});
+            entries.push_back({ b.ffn_gate_w, b.ffn_up_w, &b.ffn_gate_up_w });
         }
-        if (!transcribe::causal_lm::pack_gate_up(
-                m->plan.primary,
-                m->hparams.dec_hidden,
-                m->hparams.dec_intermediate,
-                entries,
-                m->packed_gate_up,
-                "funasr_nano"))
-        {
+        if (!transcribe::causal_lm::pack_gate_up(m->plan.primary, m->hparams.dec_hidden, m->hparams.dec_intermediate,
+                                                 entries, m->packed_gate_up, "funasr_nano")) {
             m->packed_gate_up.free();
             return TRANSCRIBE_ERR_GGUF;
         }
     }
 
     {
-        const auto & hp_ = m->hparams;
+        const auto &                 hp_ = m->hparams;
         transcribe::KaldiFbankParams fe_params;
         fe_params.n_mels          = hp_.fe_num_mels;
         fe_params.sample_rate     = hp_.fe_sample_rate;
@@ -432,23 +408,22 @@ transcribe_status load(
         fe_params.apply_cmvn      = hp_.fe_apply_cmvn;
         // Fun-ASR-Nano trains on raw LFR features (apply_cmvn=false), so
         // the cmvn_shift / cmvn_scale buffers are intentionally empty.
-        m->frontend = std::make_unique<transcribe::KaldiFbankFrontend>(
-            std::move(fe_params));
+        m->frontend               = std::make_unique<transcribe::KaldiFbankFrontend>(std::move(fe_params));
     }
 
     m->t_load_us = ggml_time_us() - t_load_start;
-    *out_model = m.release();
+    *out_model   = m.release();
     return TRANSCRIBE_OK;
 }
 
-transcribe_status init_context(
-    transcribe_model *                model,
-    const transcribe_session_params * params,
-    transcribe_session **             out_ctx)
-{
-    if (model->arch != &arch) return TRANSCRIBE_ERR_INVALID_ARG;
+transcribe_status init_context(transcribe_model *                model,
+                               const transcribe_session_params * params,
+                               transcribe_session **             out_ctx) {
+    if (model->arch != &arch) {
+        return TRANSCRIBE_ERR_INVALID_ARG;
+    }
 
-    auto cc = std::make_unique<FunAsrNanoSession>();
+    auto cc       = std::make_unique<FunAsrNanoSession>();
     cc->model     = model;
     cc->n_threads = params->n_threads;
     cc->kv_type   = params->kv_type;
@@ -461,20 +436,17 @@ transcribe_status init_context(
     auto * cm = static_cast<FunAsrNanoModel *>(model);
     {
         ggml_type kv_type = GGML_TYPE_F16;
-        if (cc->kv_type == TRANSCRIBE_KV_TYPE_F32) kv_type = GGML_TYPE_F32;
+        if (cc->kv_type == TRANSCRIBE_KV_TYPE_F32) {
+            kv_type = GGML_TYPE_F32;
+        }
         if (!transcribe::causal_lm::kv_init(cc->kv_cache, cm->plan.primary,
-                                           /*n_ctx=*/2048,
-                                           cm->hparams.dec_n_kv_heads,
-                                           cm->hparams.dec_head_dim,
-                                           cm->hparams.dec_n_layers,
-                                           kv_type))
-        {
+                                            /*n_ctx=*/2048, cm->hparams.dec_n_kv_heads, cm->hparams.dec_head_dim,
+                                            cm->hparams.dec_n_layers, kv_type)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "funasr_nano init_context: KV cache allocation failed "
-                "(n_ctx=2048, %d kv-heads x %d head-dim x %d layers) — "
-                "out of memory.",
-                cm->hparams.dec_n_kv_heads, cm->hparams.dec_head_dim,
-                cm->hparams.dec_n_layers);
+                                "funasr_nano init_context: KV cache allocation failed "
+                                "(n_ctx=2048, %d kv-heads x %d head-dim x %d layers) — "
+                                "out of memory.",
+                                cm->hparams.dec_n_kv_heads, cm->hparams.dec_head_dim, cm->hparams.dec_n_layers);
             return TRANSCRIBE_ERR_OOM;
         }
     }
@@ -487,25 +459,23 @@ transcribe_status init_context(
 // run
 // ---------------------------------------------------------------------------
 
-transcribe_status run(
-    transcribe_session *      session,
-    const float *             pcm,
-    int                       n_samples,
-    const transcribe_run_params * params)
-{
+transcribe_status run(transcribe_session *          session,
+                      const float *                 pcm,
+                      int                           n_samples,
+                      const transcribe_run_params * params) {
     if (session == nullptr || pcm == nullptr || n_samples <= 0) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
 
     auto * cc = static_cast<FunAsrNanoSession *>(session);
     auto * cm = static_cast<FunAsrNanoModel *>(cc->model);
-    if (cm == nullptr || cm->plan.scheduler_list.empty() ||
-        cm->frontend == nullptr)
-    {
+    if (cm == nullptr || cm->plan.scheduler_list.empty() || cm->frontend == nullptr) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
 
-    if (cc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
+    if (cc->poll_abort()) {
+        return TRANSCRIBE_ERR_ABORTED;
+    }
 
     transcribe::debug::init();
     cc->clear_result();
@@ -514,15 +484,12 @@ transcribe_status run(
 
     // ---- Frontend (host-side) ----
     const int64_t t_mel_start = ggml_time_us();
-    const int T_lfr = cm->frontend->compute(
-        pcm, static_cast<size_t>(n_samples), cc->frontend_buf);
-    cc->t_mel_us = ggml_time_us() - t_mel_start;
+    const int     T_lfr       = cm->frontend->compute(pcm, static_cast<size_t>(n_samples), cc->frontend_buf);
+    cc->t_mel_us              = ggml_time_us() - t_mel_start;
 
     if (T_lfr <= 0) {
-        transcribe::log_msg(
-            TRANSCRIBE_LOG_LEVEL_ERROR,
-            "funasr_nano run: input too short (n_samples=%d -> T_lfr=0)",
-            n_samples);
+        transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "funasr_nano run: input too short (n_samples=%d -> T_lfr=0)",
+                            n_samples);
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
 
@@ -530,10 +497,9 @@ transcribe_status run(
         // dump_host_f32's `shape` arg is numpy/row-major (slow-to-fast).
         // The frontend buffer is [T_lfr, d_input] row-major (T outer).
         const long long shape[2] = { T_lfr, hp.enc_d_input };
-        transcribe::debug::dump_host_f32(
-            "frontend.fbank.lfr.cmvn.out", cc->frontend_buf.data(),
-            static_cast<long long>(cc->frontend_buf.size()),
-            shape, 2, "frontend.lfr.cmvn");
+        transcribe::debug::dump_host_f32("frontend.fbank.lfr.cmvn.out", cc->frontend_buf.data(),
+                                         static_cast<long long>(cc->frontend_buf.size()), shape, 2,
+                                         "frontend.lfr.cmvn");
     }
 
     // ---- Reset compute context ----
@@ -542,30 +508,27 @@ transcribe_status run(
         cc->compute_ctx = nullptr;
     }
     {
-        ggml_init_params ip {};
-        ip.mem_size   = 32 * 1024 * 1024;  // generous for 70 SAN-M blocks + adaptor + 28 LM blocks
-        ip.mem_buffer = nullptr;
-        ip.no_alloc   = true;
+        ggml_init_params ip{};
+        ip.mem_size     = 32 * 1024 * 1024;  // generous for 70 SAN-M blocks + adaptor + 28 LM blocks
+        ip.mem_buffer   = nullptr;
+        ip.no_alloc     = true;
         cc->compute_ctx = ggml_init(ip);
         if (cc->compute_ctx == nullptr) {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "funasr_nano run: ggml_init for compute_ctx failed");
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "funasr_nano run: ggml_init for compute_ctx failed");
             return TRANSCRIBE_ERR_GGUF;
         }
     }
 
     // ---- Build encoder graph ----
-    EncoderBuild eb = build_encoder_graph(cc->compute_ctx, cm->weights,
-                                          hp, T_lfr);
+    EncoderBuild eb = build_encoder_graph(cc->compute_ctx, cm->weights, hp, T_lfr);
     if (eb.graph == nullptr || eb.out == nullptr) {
         return TRANSCRIBE_ERR_GGUF;
     }
 
     if (cc->sched == nullptr) {
-        cc->sched = ggml_backend_sched_new(
-            cm->plan.scheduler_list.data(), nullptr,
-            static_cast<int>(cm->plan.scheduler_list.size()),
-            16384, /*parallel=*/false, /*op_offload=*/true);
+        cc->sched = ggml_backend_sched_new(cm->plan.scheduler_list.data(), nullptr,
+                                           static_cast<int>(cm->plan.scheduler_list.size()), 16384, /*parallel=*/false,
+                                           /*op_offload=*/true);
         if (cc->sched == nullptr) {
             log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "funasr_nano run: ggml_backend_sched_new failed");
             return TRANSCRIBE_ERR_GGUF;
@@ -574,38 +537,35 @@ transcribe_status run(
     ggml_backend_sched_reset(cc->sched);
     if (!ggml_backend_sched_alloc_graph(cc->sched, eb.graph)) {
         transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "funasr_nano run: encoder graph allocation failed — out of memory.");
+                            "funasr_nano run: encoder graph allocation failed — out of memory.");
         return TRANSCRIBE_ERR_OOM;
     }
 
     // Upload frontend output and PE.
-    ggml_backend_tensor_set(eb.frontend_in, cc->frontend_buf.data(),
-                            0, cc->frontend_buf.size() * sizeof(float));
+    ggml_backend_tensor_set(eb.frontend_in, cc->frontend_buf.data(), 0, cc->frontend_buf.size() * sizeof(float));
     transcribe::sanm::build_sinusoidal_pe(cc->pe_buf, hp.enc_d_input, T_lfr);
-    ggml_backend_tensor_set(eb.pe_in, cc->pe_buf.data(),
-                            0, cc->pe_buf.size() * sizeof(float));
+    ggml_backend_tensor_set(eb.pe_in, cc->pe_buf.data(), 0, cc->pe_buf.size() * sizeof(float));
 
     apply_thread_policy(cc);
 
     const int64_t t_enc_start = ggml_time_us();
-    if (const ggml_status gs =
-            ggml_backend_sched_graph_compute(cc->sched, eb.graph);
-        gs != GGML_STATUS_SUCCESS)
-    {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "funasr_nano run: encoder graph compute failed (%d)",
-                     static_cast<int>(gs));
+    if (const ggml_status gs = ggml_backend_sched_graph_compute(cc->sched, eb.graph); gs != GGML_STATUS_SUCCESS) {
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "funasr_nano run: encoder graph compute failed (%d)", static_cast<int>(gs));
         return TRANSCRIBE_ERR_GGUF;
     }
     cc->t_encode_us = ggml_time_us() - t_enc_start;
 
     // Dump encoder intermediates.
     auto try_dump = [](const char * name, ggml_tensor * t, const char * stage) {
-        if (t != nullptr) transcribe::debug::dump_tensor(name, t, stage);
+        if (t != nullptr) {
+            transcribe::debug::dump_tensor(name, t, stage);
+        }
     };
-    try_dump("enc.embed.out",        eb.dumps.embed_out,        "encoder.embed.pos_added");
-    try_dump("enc.encoders0.0.out",  eb.dumps.encoders0_0_out,  "encoder.encoders0.0");
-    if (eb.dumps.encoders_first) try_dump("enc.encoders.0.out", eb.dumps.encoders_first, "encoder.encoders.0");
+    try_dump("enc.embed.out", eb.dumps.embed_out, "encoder.embed.pos_added");
+    try_dump("enc.encoders0.0.out", eb.dumps.encoders0_0_out, "encoder.encoders0.0");
+    if (eb.dumps.encoders_first) {
+        try_dump("enc.encoders.0.out", eb.dumps.encoders_first, "encoder.encoders.0");
+    }
     if (eb.dumps.encoders_mid) {
         const char * nm = eb.dumps.encoders_mid->name;
         try_dump(nm, eb.dumps.encoders_mid, "encoder.encoders.mid");
@@ -614,8 +574,10 @@ transcribe_status run(
         const char * nm = eb.dumps.encoders_last->name;
         try_dump(nm, eb.dumps.encoders_last, "encoder.encoders.last");
     }
-    try_dump("enc.after_norm.out",   eb.dumps.after_norm_out,   "encoder.after_norm");
-    if (eb.dumps.tp_encoders_first) try_dump("enc.tp_encoders.0.out", eb.dumps.tp_encoders_first, "encoder.tp_encoders.0");
+    try_dump("enc.after_norm.out", eb.dumps.after_norm_out, "encoder.after_norm");
+    if (eb.dumps.tp_encoders_first) {
+        try_dump("enc.tp_encoders.0.out", eb.dumps.tp_encoders_first, "encoder.tp_encoders.0");
+    }
     if (eb.dumps.tp_encoders_mid) {
         const char * nm = eb.dumps.tp_encoders_mid->name;
         try_dump(nm, eb.dumps.tp_encoders_mid, "encoder.tp_encoders.mid");
@@ -624,13 +586,11 @@ transcribe_status run(
         const char * nm = eb.dumps.tp_encoders_last->name;
         try_dump(nm, eb.dumps.tp_encoders_last, "encoder.tp_encoders.last");
     }
-    try_dump("enc.tp_norm.out",      eb.dumps.tp_norm_out,      "encoder.tp_norm");
+    try_dump("enc.tp_norm.out", eb.dumps.tp_norm_out, "encoder.tp_norm");
 
     // Read encoder output to host.
-    cc->enc_host.resize(static_cast<size_t>(hp.enc_d_model) *
-                        static_cast<size_t>(T_lfr));
-    ggml_backend_tensor_get(eb.out, cc->enc_host.data(), 0,
-                            cc->enc_host.size() * sizeof(float));
+    cc->enc_host.resize(static_cast<size_t>(hp.enc_d_model) * static_cast<size_t>(T_lfr));
+    ggml_backend_tensor_get(eb.out, cc->enc_host.data(), 0, cc->enc_host.size() * sizeof(float));
 
     // ---- Build adaptor graph ----
     if (cc->compute_ctx != nullptr) {
@@ -638,10 +598,10 @@ transcribe_status run(
         cc->compute_ctx = nullptr;
     }
     {
-        ggml_init_params ip {};
-        ip.mem_size   = 8 * 1024 * 1024;
-        ip.mem_buffer = nullptr;
-        ip.no_alloc   = true;
+        ggml_init_params ip{};
+        ip.mem_size     = 8 * 1024 * 1024;
+        ip.mem_buffer   = nullptr;
+        ip.no_alloc     = true;
         cc->compute_ctx = ggml_init(ip);
     }
 
@@ -652,59 +612,54 @@ transcribe_status run(
     ggml_backend_sched_reset(cc->sched);
     if (!ggml_backend_sched_alloc_graph(cc->sched, ab.graph)) {
         transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "funasr_nano run: adaptor graph allocation failed — out of memory.");
+                            "funasr_nano run: adaptor graph allocation failed — out of memory.");
         return TRANSCRIBE_ERR_OOM;
     }
-    ggml_backend_tensor_set(ab.enc_in, cc->enc_host.data(),
-                            0, cc->enc_host.size() * sizeof(float));
+    ggml_backend_tensor_set(ab.enc_in, cc->enc_host.data(), 0, cc->enc_host.size() * sizeof(float));
 
-    if (const ggml_status gs =
-            ggml_backend_sched_graph_compute(cc->sched, ab.graph);
-        gs != GGML_STATUS_SUCCESS)
-    {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "funasr_nano run: adaptor graph compute failed (%d)",
-                     static_cast<int>(gs));
+    if (const ggml_status gs = ggml_backend_sched_graph_compute(cc->sched, ab.graph); gs != GGML_STATUS_SUCCESS) {
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "funasr_nano run: adaptor graph compute failed (%d)", static_cast<int>(gs));
         return TRANSCRIBE_ERR_GGUF;
     }
 
-    try_dump("adaptor.linear1.out",  ab.dumps.linear1_out,  "adaptor.linear1");
-    try_dump("adaptor.linear2.out",  ab.dumps.linear2_out,  "adaptor.linear2");
-    try_dump("adaptor.blocks.0.out", ab.dumps.block0_out,   "adaptor.blocks.0");
-    try_dump("adaptor.out",          ab.dumps.adaptor_out,  "adaptor.out");
+    try_dump("adaptor.linear1.out", ab.dumps.linear1_out, "adaptor.linear1");
+    try_dump("adaptor.linear2.out", ab.dumps.linear2_out, "adaptor.linear2");
+    try_dump("adaptor.blocks.0.out", ab.dumps.block0_out, "adaptor.blocks.0");
+    try_dump("adaptor.out", ab.dumps.adaptor_out, "adaptor.out");
 
-    cc->adaptor_host.resize(static_cast<size_t>(hp.adaptor_llm_dim) *
-                            static_cast<size_t>(T_lfr));
-    ggml_backend_tensor_get(ab.out, cc->adaptor_host.data(), 0,
-                            cc->adaptor_host.size() * sizeof(float));
+    cc->adaptor_host.resize(static_cast<size_t>(hp.adaptor_llm_dim) * static_cast<size_t>(T_lfr));
+    ggml_backend_tensor_get(ab.out, cc->adaptor_host.data(), 0, cc->adaptor_host.size() * sizeof(float));
 
     // ---- Build prompt + audio splice ----
-    const int fake_token_len =
-        compute_fake_token_len(T_lfr, hp.adaptor_use_low_frame_rate);
+    const int fake_token_len = compute_fake_token_len(T_lfr, hp.adaptor_use_low_frame_rate);
 
-    const char * lang = (params != nullptr) ? params->language : nullptr;
+    const char * lang    = (params != nullptr) ? params->language : nullptr;
     // Generic transcribe_run_params::itn routes here. DEFAULT maps to the
     // family's shipping default (use_itn=false; matches the upstream
     // `itn=False` Python path). OFF / ON override explicitly. The
     // dispatcher's advisory WARN only fires when transcribe_model_supports(
     // model, TRANSCRIBE_FEATURE_ITN) is false; funasr_nano sets
     // TRANSCRIBE_FEATURE_ITN so the probe returns true and no WARN here.
-    bool use_itn = false;
+    bool         use_itn = false;
     if (params != nullptr) {
         switch (params->itn) {
-            case TRANSCRIBE_ITN_MODE_DEFAULT: use_itn = false; break;
-            case TRANSCRIBE_ITN_MODE_OFF:     use_itn = false; break;
-            case TRANSCRIBE_ITN_MODE_ON:      use_itn = true;  break;
+            case TRANSCRIBE_ITN_MODE_DEFAULT:
+                use_itn = false;
+                break;
+            case TRANSCRIBE_ITN_MODE_OFF:
+                use_itn = false;
+                break;
+            case TRANSCRIBE_ITN_MODE_ON:
+                use_itn = true;
+                break;
         }
     }
 
     std::vector<int32_t> prompt_ids;
-    int fbank_beg = 0;
-    if (const transcribe_status st = build_funasr_nano_prompt(
-            cm->tok, cm->chat_tokens, lang, use_itn, fake_token_len,
-            prompt_ids, fbank_beg);
-        st != TRANSCRIBE_OK)
-    {
+    int                  fbank_beg = 0;
+    if (const transcribe_status st =
+            build_funasr_nano_prompt(cm->tok, cm->chat_tokens, lang, use_itn, fake_token_len, prompt_ids, fbank_beg);
+        st != TRANSCRIBE_OK) {
         return st;
     }
 
@@ -720,13 +675,12 @@ transcribe_status run(
     // KV alloc / prefill / decode, instead of walling at a fixed size.
     const int ceiling = funasr_nano_context_ceiling(cc->n_ctx, hp);
     if (T_prompt + k_max_new > ceiling) {
-        transcribe::log_msg(
-            TRANSCRIBE_LOG_LEVEL_ERROR,
-            "funasr_nano run: input too long — %d audio + %d prompt tokens "
-            "leave no room for output within the %d-token context (need %d). "
-            "Shorten the audio (see transcribe_capabilities.max_audio_ms) or "
-            "split it into segments.",
-            T_audio, prefix_len + suffix_len, ceiling, T_prompt + k_max_new);
+        transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
+                            "funasr_nano run: input too long — %d audio + %d prompt tokens "
+                            "leave no room for output within the %d-token context (need %d). "
+                            "Shorten the audio (see transcribe_capabilities.max_audio_ms) or "
+                            "split it into segments.",
+                            T_audio, prefix_len + suffix_len, ceiling, T_prompt + k_max_new);
         return TRANSCRIBE_ERR_INPUT_TOO_LONG;
     }
 
@@ -736,27 +690,28 @@ transcribe_status run(
     // flash-attn path). The cache grows across runs as audio length demands;
     // a pre-allocated smaller cache is freed and re-allocated.
     int want_n_ctx = 1024;
-    while (want_n_ctx < T_prompt + k_max_new) want_n_ctx *= 2;
-    if (want_n_ctx > ceiling) want_n_ctx = ceiling;
+    while (want_n_ctx < T_prompt + k_max_new) {
+        want_n_ctx *= 2;
+    }
+    if (want_n_ctx > ceiling) {
+        want_n_ctx = ceiling;
+    }
     if (cc->kv_cache.ctx != nullptr && cc->kv_cache.n_ctx < want_n_ctx) {
         cc->kv_cache.free();
     }
     if (cc->kv_cache.ctx == nullptr) {
         ggml_type kv_type = GGML_TYPE_F16;
-        if (cc->kv_type == TRANSCRIBE_KV_TYPE_F32) kv_type = GGML_TYPE_F32;
-        if (!transcribe::causal_lm::kv_init(cc->kv_cache, cm->plan.primary,
-                                           want_n_ctx,
-                                           cm->hparams.dec_n_kv_heads,
-                                           cm->hparams.dec_head_dim,
-                                           cm->hparams.dec_n_layers,
-                                           kv_type))
-        {
+        if (cc->kv_type == TRANSCRIBE_KV_TYPE_F32) {
+            kv_type = GGML_TYPE_F32;
+        }
+        if (!transcribe::causal_lm::kv_init(cc->kv_cache, cm->plan.primary, want_n_ctx, cm->hparams.dec_n_kv_heads,
+                                            cm->hparams.dec_head_dim, cm->hparams.dec_n_layers, kv_type)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "funasr_nano run: KV cache allocation failed (n_ctx=%d, "
-                "%d kv-heads x %d head-dim x %d layers) — out of memory. "
-                "Lower transcribe_session_params.n_ctx or shorten the audio.",
-                want_n_ctx, cm->hparams.dec_n_kv_heads,
-                cm->hparams.dec_head_dim, cm->hparams.dec_n_layers);
+                                "funasr_nano run: KV cache allocation failed (n_ctx=%d, "
+                                "%d kv-heads x %d head-dim x %d layers) — out of memory. "
+                                "Lower transcribe_session_params.n_ctx or shorten the audio.",
+                                want_n_ctx, cm->hparams.dec_n_kv_heads, cm->hparams.dec_head_dim,
+                                cm->hparams.dec_n_layers);
             return TRANSCRIBE_ERR_OOM;
         }
     } else {
@@ -775,19 +730,17 @@ transcribe_status run(
         cc->compute_ctx = nullptr;
     }
     {
-        ggml_init_params ip {};
-        ip.mem_size   = 16 * 1024 * 1024;
-        ip.mem_buffer = nullptr;
-        ip.no_alloc   = true;
+        ggml_init_params ip{};
+        ip.mem_size     = 16 * 1024 * 1024;
+        ip.mem_buffer   = nullptr;
+        ip.no_alloc     = true;
         cc->compute_ctx = ggml_init(ip);
     }
 
-    const bool dumps_on  = transcribe::debug::enabled();
-    const bool slice_last = !dumps_on;
-    PrefillBuild pb = build_prefill_graph(
-        cc->compute_ctx, cm->weights, hp,
-        cc->kv_cache, T_prompt, T_audio, prefix_len, suffix_len,
-        cc->decoder_use_flash, slice_last);
+    const bool   dumps_on   = transcribe::debug::enabled();
+    const bool   slice_last = !dumps_on;
+    PrefillBuild pb = build_prefill_graph(cc->compute_ctx, cm->weights, hp, cc->kv_cache, T_prompt, T_audio, prefix_len,
+                                          suffix_len, cc->decoder_use_flash, slice_last);
     if (pb.graph == nullptr || pb.out == nullptr) {
         return TRANSCRIBE_ERR_GGUF;
     }
@@ -795,136 +748,129 @@ transcribe_status run(
     ggml_backend_sched_reset(cc->sched);
     if (!ggml_backend_sched_alloc_graph(cc->sched, pb.graph)) {
         transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "funasr_nano run: prefill graph allocation failed (T_prompt=%d) — "
-            "out of memory. Lower transcribe_session_params.n_ctx or shorten "
-            "the audio.", T_prompt);
+                            "funasr_nano run: prefill graph allocation failed (T_prompt=%d) — "
+                            "out of memory. Lower transcribe_session_params.n_ctx or shorten "
+                            "the audio.",
+                            T_prompt);
         return TRANSCRIBE_ERR_OOM;
     }
 
-    ggml_backend_tensor_set(pb.input_ids_in, prompt_ids.data(),
-                            0, prompt_ids.size() * sizeof(int32_t));
+    ggml_backend_tensor_set(pb.input_ids_in, prompt_ids.data(), 0, prompt_ids.size() * sizeof(int32_t));
 
     if (T_audio > 0 && pb.audio_in != nullptr) {
         // Upload first fake_token_len rows of adaptor_out. adaptor_host
         // is row-major [T_lfr, llm_dim]; upload llm_dim * fake_token_len
         // floats.
-        const size_t bytes =
-            static_cast<size_t>(T_audio) * hp.adaptor_llm_dim * sizeof(float);
-        ggml_backend_tensor_set(pb.audio_in, cc->adaptor_host.data(),
-                                0, bytes);
+        const size_t bytes = static_cast<size_t>(T_audio) * hp.adaptor_llm_dim * sizeof(float);
+        ggml_backend_tensor_set(pb.audio_in, cc->adaptor_host.data(), 0, bytes);
     }
 
     {
         std::vector<int32_t> positions(T_prompt);
-        for (int i = 0; i < T_prompt; ++i) positions[i] = i;
-        ggml_backend_tensor_set(pb.positions_in, positions.data(),
-                                0, positions.size() * sizeof(int32_t));
+        for (int i = 0; i < T_prompt; ++i) {
+            positions[i] = i;
+        }
+        ggml_backend_tensor_set(pb.positions_in, positions.data(), 0, positions.size() * sizeof(int32_t));
     }
     {
-        const ggml_fp16_t mask_zero    = ggml_fp32_to_fp16(0.0f);
-        const ggml_fp16_t mask_neg_inf = ggml_fp32_to_fp16(-INFINITY);
-        std::vector<ggml_fp16_t> mask(
-            static_cast<size_t>(T_prompt) * T_prompt, mask_neg_inf);
+        const ggml_fp16_t        mask_zero    = ggml_fp32_to_fp16(0.0f);
+        const ggml_fp16_t        mask_neg_inf = ggml_fp32_to_fp16(-INFINITY);
+        std::vector<ggml_fp16_t> mask(static_cast<size_t>(T_prompt) * T_prompt, mask_neg_inf);
         for (int r = 0; r < T_prompt; ++r) {
             for (int c = 0; c <= r; ++c) {
                 mask[static_cast<size_t>(r) * T_prompt + c] = mask_zero;
             }
         }
-        ggml_backend_tensor_set(pb.mask_in, mask.data(),
-                                0, mask.size() * sizeof(ggml_fp16_t));
+        ggml_backend_tensor_set(pb.mask_in, mask.data(), 0, mask.size() * sizeof(ggml_fp16_t));
     }
 
-    if (const ggml_status gs =
-            ggml_backend_sched_graph_compute(cc->sched, pb.graph);
-        gs != GGML_STATUS_SUCCESS)
-    {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "funasr_nano run: prefill graph compute failed (%d)",
-                     static_cast<int>(gs));
+    if (const ggml_status gs = ggml_backend_sched_graph_compute(cc->sched, pb.graph); gs != GGML_STATUS_SUCCESS) {
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "funasr_nano run: prefill graph compute failed (%d)", static_cast<int>(gs));
         return TRANSCRIBE_ERR_GGUF;
     }
 
     cc->kv_cache.n    = T_prompt;
     cc->kv_cache.head = T_prompt;
 
-    try_dump("dec.token_emb",                 pb.dumps.token_emb,       "dec.token_emb");
-    try_dump("dec.inputs_embeds.with_audio",  pb.dumps.audio_injected,  "dec.audio_injected");
-    try_dump("dec.block.0.out",               pb.dumps.block_0_out,     "dec.block.0");
+    try_dump("dec.token_emb", pb.dumps.token_emb, "dec.token_emb");
+    try_dump("dec.inputs_embeds.with_audio", pb.dumps.audio_injected, "dec.audio_injected");
+    try_dump("dec.block.0.out", pb.dumps.block_0_out, "dec.block.0");
     if (pb.dumps.block_last_out) {
         char nm[64];
         std::snprintf(nm, sizeof(nm), "dec.block.%d.out", hp.dec_n_layers - 1);
         try_dump(nm, pb.dumps.block_last_out, "dec.block.last");
     }
-    try_dump("dec.out_before_head",           pb.dumps.out_before_head, "dec.out_before_head");
-    try_dump("dec.logits_raw.prefill",        pb.dumps.logits_raw,      "decoder.logits.prefill");
+    try_dump("dec.out_before_head", pb.dumps.out_before_head, "dec.out_before_head");
+    try_dump("dec.logits_raw.prefill", pb.dumps.logits_raw, "decoder.logits.prefill");
 
-    const int vocab = hp.dec_vocab_size;
+    const int          vocab = hp.dec_vocab_size;
     std::vector<float> logits(vocab);
-    ggml_backend_tensor_get(pb.out, logits.data(), 0,
-                            logits.size() * sizeof(float));
+    ggml_backend_tensor_get(pb.out, logits.data(), 0, logits.size() * sizeof(float));
 
     auto argmax = [&](const std::vector<float> & v) -> int32_t {
-        int32_t best = 0;
+        int32_t best   = 0;
         float   best_v = v[0];
         for (int32_t i = 1; i < static_cast<int32_t>(v.size()); ++i) {
-            if (v[i] > best_v) { best_v = v[i]; best = i; }
+            if (v[i] > best_v) {
+                best_v = v[i];
+                best   = i;
+            }
         }
         return best;
     };
 
     std::vector<int32_t> generated_ids;
-    int32_t next_tok = argmax(logits);
+    int32_t              next_tok = argmax(logits);
     generated_ids.push_back(next_tok);
 
     // ---- Step loop ----
-    const int32_t eos_id = hp.eos_token_id;
-    const int max_new = k_max_new;
-    int cur_past = T_prompt;
+    const int32_t eos_id   = hp.eos_token_id;
+    const int     max_new  = k_max_new;
+    int           cur_past = T_prompt;
 
     // Static step-graph shape: T_prompt prefilled + up to max_new generated.
     // Clamp to cc->kv_cache.n_ctx (the grown cache size) so the attention
     // width never exceeds the allocation.
     int max_n_kv = 1024;
-    while (max_n_kv < T_prompt + max_new) max_n_kv *= 2;
-    if (max_n_kv > cc->kv_cache.n_ctx) max_n_kv = cc->kv_cache.n_ctx;
+    while (max_n_kv < T_prompt + max_new) {
+        max_n_kv *= 2;
+    }
+    if (max_n_kv > cc->kv_cache.n_ctx) {
+        max_n_kv = cc->kv_cache.n_ctx;
+    }
 
     if (cc->compute_ctx != nullptr) {
         ggml_free(cc->compute_ctx);
         cc->compute_ctx = nullptr;
     }
     {
-        ggml_init_params ip {};
-        ip.mem_size   = 8 * 1024 * 1024;
-        ip.mem_buffer = nullptr;
-        ip.no_alloc   = true;
+        ggml_init_params ip{};
+        ip.mem_size     = 8 * 1024 * 1024;
+        ip.mem_buffer   = nullptr;
+        ip.no_alloc     = true;
         cc->compute_ctx = ggml_init(ip);
     }
-    StepBuild sb = build_step_graph(cc->compute_ctx, cm->weights, hp,
-                                    cc->kv_cache, max_n_kv,
-                                    cc->decoder_use_flash);
+    StepBuild sb = build_step_graph(cc->compute_ctx, cm->weights, hp, cc->kv_cache, max_n_kv, cc->decoder_use_flash);
     if (sb.graph == nullptr || sb.out == nullptr) {
         return TRANSCRIBE_ERR_GGUF;
     }
     ggml_backend_sched_reset(cc->sched);
     if (!ggml_backend_sched_alloc_graph(cc->sched, sb.graph)) {
         transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "funasr_nano step: decode graph allocation failed — out of memory. "
-            "Lower transcribe_session_params.n_ctx or shorten the audio.");
+                            "funasr_nano step: decode graph allocation failed — out of memory. "
+                            "Lower transcribe_session_params.n_ctx or shorten the audio.");
         return TRANSCRIBE_ERR_OOM;
     }
 
-    const ggml_fp16_t mask_zero    = ggml_fp32_to_fp16(0.0f);
-    const ggml_fp16_t mask_neg_inf = ggml_fp32_to_fp16(-INFINITY);
+    const ggml_fp16_t        mask_zero    = ggml_fp32_to_fp16(0.0f);
+    const ggml_fp16_t        mask_neg_inf = ggml_fp32_to_fp16(-INFINITY);
     std::vector<ggml_fp16_t> step_mask(max_n_kv, mask_neg_inf);
 
     // Mid-generation logits dump. The reference captures the 9th lm_head call
     // (prefill = 1st call, iter K = (K+2)th call), so dump when n_steps == 7.
     const int gen_dump_step = 7;
-    int n_steps = 0;
-    while (next_tok != eos_id &&
-           static_cast<int32_t>(generated_ids.size()) < max_new &&
-           cur_past + 1 <= max_n_kv)
-    {
+    int       n_steps       = 0;
+    while (next_tok != eos_id && static_cast<int32_t>(generated_ids.size()) < max_new && cur_past + 1 <= max_n_kv) {
         ggml_backend_tensor_set(sb.input_id_in, &next_tok, 0, sizeof(int32_t));
         const int32_t pos_val = cur_past;
         ggml_backend_tensor_set(sb.position_in, &pos_val, 0, sizeof(int32_t));
@@ -932,22 +878,15 @@ transcribe_status run(
         ggml_backend_tensor_set(sb.kv_idx_in, &kv_idx_val, 0, sizeof(int64_t));
 
         if (cur_past == T_prompt) {
-            std::fill(step_mask.begin(),
-                      step_mask.begin() + cur_past + 1, mask_zero);
+            std::fill(step_mask.begin(), step_mask.begin() + cur_past + 1, mask_zero);
         } else {
             step_mask[cur_past] = mask_zero;
         }
-        ggml_backend_tensor_set(sb.mask_in, step_mask.data(), 0,
-                                static_cast<size_t>(max_n_kv) *
-                                sizeof(ggml_fp16_t));
+        ggml_backend_tensor_set(sb.mask_in, step_mask.data(), 0, static_cast<size_t>(max_n_kv) * sizeof(ggml_fp16_t));
 
-        if (const ggml_status gs =
-                ggml_backend_sched_graph_compute(cc->sched, sb.graph);
-            gs != GGML_STATUS_SUCCESS)
-        {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "funasr_nano run: step graph compute failed (%d)",
-                         static_cast<int>(gs));
+        if (const ggml_status gs = ggml_backend_sched_graph_compute(cc->sched, sb.graph); gs != GGML_STATUS_SUCCESS) {
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "funasr_nano run: step graph compute failed (%d)",
+                    static_cast<int>(gs));
             return TRANSCRIBE_ERR_GGUF;
         }
 
@@ -963,7 +902,7 @@ transcribe_status run(
         cur_past += 1;
         n_steps += 1;
     }
-    (void)n_steps;
+    (void) n_steps;
 
     // The decode stopped at EOS (complete) or at the generation budget /
     // context width (truncated). Surface the latter via
@@ -971,42 +910,38 @@ transcribe_status run(
     // shortened transcript. See docs/input-limits.md.
     if (next_tok != eos_id) {
         cc->was_truncated = true;
-        transcribe::log_msg(
-            TRANSCRIBE_LOG_LEVEL_WARN,
-            "funasr_nano run: output truncated at %d tokens — decode reached "
-            "the generation budget before end-of-stream; the transcript may be "
-            "incomplete.",
-            static_cast<int>(generated_ids.size()));
+        transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_WARN,
+                            "funasr_nano run: output truncated at %d tokens — decode reached "
+                            "the generation budget before end-of-stream; the transcript may be "
+                            "incomplete.",
+                            static_cast<int>(generated_ids.size()));
     }
 
     if (!generated_ids.empty() && generated_ids.back() == eos_id) {
         generated_ids.pop_back();
     }
 
-    std::string transcript = cm->tok.decode(
-        generated_ids.data(), static_cast<int>(generated_ids.size()));
+    std::string transcript = cm->tok.decode(generated_ids.data(), static_cast<int>(generated_ids.size()));
 
     cc->t_decode_us = ggml_time_us() - t_dec_start;
 
-    cc->full_text = transcript;
+    cc->full_text   = transcript;
     cc->result_kind = TRANSCRIBE_TIMESTAMPS_NONE;
-    cc->has_result = true;
+    cc->has_result  = true;
 
-    transcribe_session::SegmentEntry seg {};
+    transcribe_session::SegmentEntry seg{};
     seg.text  = transcript;
     seg.t0_ms = 0;
-    seg.t1_ms = static_cast<int64_t>(n_samples) * 1000
-              / static_cast<int64_t>(hp.fe_sample_rate);
+    seg.t1_ms = static_cast<int64_t>(n_samples) * 1000 / static_cast<int64_t>(hp.fe_sample_rate);
     cc->segments.push_back(std::move(seg));
 
     // The partial transcript is fully populated above; a truncated decode
     // returns the hard OUTPUT_TRUNCATED status (the result stays readable,
     // like an aborted run). See docs/input-limits.md.
-    return cc->was_truncated ? TRANSCRIBE_ERR_OUTPUT_TRUNCATED
-                             : TRANSCRIBE_OK;
+    return cc->was_truncated ? TRANSCRIBE_ERR_OUTPUT_TRUNCATED : TRANSCRIBE_OK;
 }
 
-} // namespace
+}  // namespace
 
 // ===========================================================================
 // Offline batched decode (transcribe_run_batch)
@@ -1023,10 +958,10 @@ transcribe_status reset_ctx(FunAsrNanoSession * cc, int mb) {
         ggml_free(cc->compute_ctx);
         cc->compute_ctx = nullptr;
     }
-    ggml_init_params ip {};
-    ip.mem_size   = static_cast<size_t>(mb) * 1024 * 1024;
-    ip.mem_buffer = nullptr;
-    ip.no_alloc   = true;
+    ggml_init_params ip{};
+    ip.mem_size     = static_cast<size_t>(mb) * 1024 * 1024;
+    ip.mem_buffer   = nullptr;
+    ip.no_alloc     = true;
     cc->compute_ctx = ggml_init(ip);
     return cc->compute_ctx != nullptr ? TRANSCRIBE_OK : TRANSCRIBE_ERR_GGUF;
 }
@@ -1034,77 +969,88 @@ transcribe_status reset_ctx(FunAsrNanoSession * cc, int mb) {
 // encoder + adaptor for one utterance from a PRECOMPUTED frontend buffer
 // (the mel/fbank is computed in parallel by the caller) → audio embedding
 // [hidden, T_audio]. Mirrors run()'s encoder/adaptor section (serial).
-transcribe_status audio_embed_one(
-    FunAsrNanoSession * cc, FunAsrNanoModel * cm,
-    const std::vector<float> & frontend_buf, int T_lfr,
-    std::vector<float> & audio_host, int & T_audio_out,
-    int64_t & enc_us) {
+transcribe_status audio_embed_one(FunAsrNanoSession *        cc,
+                                  FunAsrNanoModel *          cm,
+                                  const std::vector<float> & frontend_buf,
+                                  int                        T_lfr,
+                                  std::vector<float> &       audio_host,
+                                  int &                      T_audio_out,
+                                  int64_t &                  enc_us) {
     const auto & hp = cm->hparams;
-    if (T_lfr <= 0) return TRANSCRIBE_ERR_INVALID_ARG;
+    if (T_lfr <= 0) {
+        return TRANSCRIBE_ERR_INVALID_ARG;
+    }
 
     // Encoder.
-    if (const transcribe_status st = reset_ctx(cc, 32); st != TRANSCRIBE_OK) return st;
+    if (const transcribe_status st = reset_ctx(cc, 32); st != TRANSCRIBE_OK) {
+        return st;
+    }
     EncoderBuild eb = build_encoder_graph(cc->compute_ctx, cm->weights, hp, T_lfr);
-    if (eb.graph == nullptr || eb.out == nullptr) return TRANSCRIBE_ERR_GGUF;
+    if (eb.graph == nullptr || eb.out == nullptr) {
+        return TRANSCRIBE_ERR_GGUF;
+    }
     if (cc->sched == nullptr) {
-        cc->sched = ggml_backend_sched_new(
-            cm->plan.scheduler_list.data(), nullptr,
-            static_cast<int>(cm->plan.scheduler_list.size()),
-            16384, false, true);
-        if (cc->sched == nullptr) return TRANSCRIBE_ERR_GGUF;
+        cc->sched = ggml_backend_sched_new(cm->plan.scheduler_list.data(), nullptr,
+                                           static_cast<int>(cm->plan.scheduler_list.size()), 16384, false, true);
+        if (cc->sched == nullptr) {
+            return TRANSCRIBE_ERR_GGUF;
+        }
     }
     ggml_backend_sched_reset(cc->sched);
-    if (!ggml_backend_sched_alloc_graph(cc->sched, eb.graph)) return TRANSCRIBE_ERR_GGUF;
-    ggml_backend_tensor_set(eb.frontend_in, frontend_buf.data(),
-                            0, frontend_buf.size() * sizeof(float));
+    if (!ggml_backend_sched_alloc_graph(cc->sched, eb.graph)) {
+        return TRANSCRIBE_ERR_GGUF;
+    }
+    ggml_backend_tensor_set(eb.frontend_in, frontend_buf.data(), 0, frontend_buf.size() * sizeof(float));
     transcribe::sanm::build_sinusoidal_pe(cc->pe_buf, hp.enc_d_input, T_lfr);
-    ggml_backend_tensor_set(eb.pe_in, cc->pe_buf.data(),
-                            0, cc->pe_buf.size() * sizeof(float));
+    ggml_backend_tensor_set(eb.pe_in, cc->pe_buf.data(), 0, cc->pe_buf.size() * sizeof(float));
     apply_thread_policy(cc);
     const int64_t t_enc0 = ggml_time_us();
-    if (ggml_backend_sched_graph_compute(cc->sched, eb.graph) != GGML_STATUS_SUCCESS)
+    if (ggml_backend_sched_graph_compute(cc->sched, eb.graph) != GGML_STATUS_SUCCESS) {
         return TRANSCRIBE_ERR_GGUF;
+    }
     enc_us += ggml_time_us() - t_enc0;
     cc->enc_host.resize(static_cast<size_t>(hp.enc_d_model) * T_lfr);
-    ggml_backend_tensor_get(eb.out, cc->enc_host.data(), 0,
-                            cc->enc_host.size() * sizeof(float));
+    ggml_backend_tensor_get(eb.out, cc->enc_host.data(), 0, cc->enc_host.size() * sizeof(float));
 
     // Adaptor.
-    if (const transcribe_status st = reset_ctx(cc, 8); st != TRANSCRIBE_OK) return st;
+    if (const transcribe_status st = reset_ctx(cc, 8); st != TRANSCRIBE_OK) {
+        return st;
+    }
     AdaptorBuild ab = build_adaptor_graph(cc->compute_ctx, cm->weights, hp, T_lfr);
-    if (ab.graph == nullptr || ab.out == nullptr) return TRANSCRIBE_ERR_GGUF;
+    if (ab.graph == nullptr || ab.out == nullptr) {
+        return TRANSCRIBE_ERR_GGUF;
+    }
     ggml_backend_sched_reset(cc->sched);
-    if (!ggml_backend_sched_alloc_graph(cc->sched, ab.graph)) return TRANSCRIBE_ERR_GGUF;
-    ggml_backend_tensor_set(ab.enc_in, cc->enc_host.data(),
-                            0, cc->enc_host.size() * sizeof(float));
+    if (!ggml_backend_sched_alloc_graph(cc->sched, ab.graph)) {
+        return TRANSCRIBE_ERR_GGUF;
+    }
+    ggml_backend_tensor_set(ab.enc_in, cc->enc_host.data(), 0, cc->enc_host.size() * sizeof(float));
     const int64_t t_enc1 = ggml_time_us();
-    if (ggml_backend_sched_graph_compute(cc->sched, ab.graph) != GGML_STATUS_SUCCESS)
+    if (ggml_backend_sched_graph_compute(cc->sched, ab.graph) != GGML_STATUS_SUCCESS) {
         return TRANSCRIBE_ERR_GGUF;
+    }
     enc_us += ggml_time_us() - t_enc1;
     cc->adaptor_host.resize(static_cast<size_t>(hp.adaptor_llm_dim) * T_lfr);
-    ggml_backend_tensor_get(ab.out, cc->adaptor_host.data(), 0,
-                            cc->adaptor_host.size() * sizeof(float));
-
-    const int fake_token_len =
-        compute_fake_token_len(T_lfr, hp.adaptor_use_low_frame_rate);
-    T_audio_out = fake_token_len;
-    audio_host.assign(
-        cc->adaptor_host.begin(),
-        cc->adaptor_host.begin() +
-            static_cast<size_t>(fake_token_len) * hp.adaptor_llm_dim);
+    ggml_backend_tensor_get(ab.out, cc->adaptor_host.data(), 0, cc->adaptor_host.size() * sizeof(float));
+
+    const int fake_token_len = compute_fake_token_len(T_lfr, hp.adaptor_use_low_frame_rate);
+    T_audio_out              = fake_token_len;
+    audio_host.assign(cc->adaptor_host.begin(),
+                      cc->adaptor_host.begin() + static_cast<size_t>(fake_token_len) * hp.adaptor_llm_dim);
     return TRANSCRIBE_OK;
 }
 
-transcribe_status run_batch_serial(FunAsrNanoSession * cc,
-                                   const float * const * pcm,
-                                   const int * n_samples, int n,
+transcribe_status run_batch_serial(FunAsrNanoSession *           cc,
+                                   const float * const *         pcm,
+                                   const int *                   n_samples,
+                                   int                           n,
                                    const transcribe_run_params * params) {
     for (int i = 0; i < n; ++i) {
-        if (cc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
-        const transcribe_status st =
-            (pcm[i] == nullptr || n_samples[i] <= 0)
-                ? TRANSCRIBE_ERR_INVALID_ARG
-                : run(cc, pcm[i], n_samples[i], params);
+        if (cc->poll_abort()) {
+            return TRANSCRIBE_ERR_ABORTED;
+        }
+        const transcribe_status st = (pcm[i] == nullptr || n_samples[i] <= 0) ? TRANSCRIBE_ERR_INVALID_ARG :
+                                                                                run(cc, pcm[i], n_samples[i], params);
         if (st == TRANSCRIBE_OK) {
             cc->batch_results.push_back(cc->capture_result(st));
         } else {
@@ -1116,39 +1062,41 @@ transcribe_status run_batch_serial(FunAsrNanoSession * cc,
     return TRANSCRIBE_OK;
 }
 
-} // namespace
+}  // namespace
 
-transcribe_status run_batch(
-    transcribe_session *          session,
-    const float * const *         pcm,
-    const int *                   n_samples,
-    int                           n,
-    const transcribe_run_params * params) {
-    if (session == nullptr || pcm == nullptr || n_samples == nullptr || n <= 0)
+transcribe_status run_batch(transcribe_session *          session,
+                            const float * const *         pcm,
+                            const int *                   n_samples,
+                            int                           n,
+                            const transcribe_run_params * params) {
+    if (session == nullptr || pcm == nullptr || n_samples == nullptr || n <= 0) {
         return TRANSCRIBE_ERR_INVALID_ARG;
+    }
     auto * cc = static_cast<FunAsrNanoSession *>(session);
     auto * cm = static_cast<FunAsrNanoModel *>(cc->model);
-    if (cm == nullptr || cm->plan.scheduler_list.empty() || cm->frontend == nullptr)
+    if (cm == nullptr || cm->plan.scheduler_list.empty() || cm->frontend == nullptr) {
         return TRANSCRIBE_ERR_INVALID_ARG;
+    }
 
-    if (!cc->decoder_use_flash || transcribe::debug::enabled() || n == 1)
+    if (!cc->decoder_use_flash || transcribe::debug::enabled() || n == 1) {
         return run_batch_serial(cc, pcm, n_samples, n, params);
+    }
 
     transcribe::debug::init();
     const auto & hp = cm->hparams;
 
     // ---- Pass 1: per-utterance frontend + encoder + adaptor (serial) ----
-    std::vector<char> valid(n, 0);
+    std::vector<char>                 valid(n, 0);
     // Per-utterance failure status for the result capture below. Defaults to
     // INVALID_ARG (bad pcm / frontend / encode / prompt); the input-length gate
     // upgrades it to INPUT_TOO_LONG for over-length clips.
-    std::vector<transcribe_status> fail_status(n, TRANSCRIBE_ERR_INVALID_ARG);
-    std::vector<std::vector<float>> audio_hosts(n);
-    std::vector<int> T_audio(n, 0);
+    std::vector<transcribe_status>    fail_status(n, TRANSCRIBE_ERR_INVALID_ARG);
+    std::vector<std::vector<float>>   audio_hosts(n);
+    std::vector<int>                  T_audio(n, 0);
     std::vector<std::vector<int32_t>> prompt_ids(n);
-    std::vector<int> T_prompt(n, 0);
-    int prefix_len = 0;
-    int64_t mel_us = 0, enc_us = 0;
+    std::vector<int>                  T_prompt(n, 0);
+    int                               prefix_len = 0;
+    int64_t                           mel_us = 0, enc_us = 0;
 
     // Decoder context ceiling for the per-utterance input-length gate (see
     // docs/input-limits.md). Same value the single-utterance run() enforces;
@@ -1156,37 +1104,45 @@ transcribe_status run_batch(
     // rather than walling at a fixed KV size.
     const int ceiling = funasr_nano_context_ceiling(cc->n_ctx, hp);
 
-    const char * lang = (params != nullptr) ? params->language : nullptr;
-    bool use_itn = (params != nullptr && params->itn == TRANSCRIBE_ITN_MODE_ON);
+    const char * lang    = (params != nullptr) ? params->language : nullptr;
+    bool         use_itn = (params != nullptr && params->itn == TRANSCRIBE_ITN_MODE_ON);
 
     // ---- Pass 0: parallel frontend (kaldi-fbank, host-side, thread-safe) ----
     std::vector<std::vector<float>> fbufs(n);
-    std::vector<int> T_lfr(n, 0);
-    int n_mel_threads = cc->n_threads;
-    if (n_mel_threads <= 0)
+    std::vector<int>                T_lfr(n, 0);
+    int                             n_mel_threads = cc->n_threads;
+    if (n_mel_threads <= 0) {
         n_mel_threads = transcribe::default_n_threads();
+    }
     const int64_t t_mel0 = ggml_time_us();
     transcribe::parallel_for_all(n, n_mel_threads, [&](int b) {
-        if (pcm[b] == nullptr || n_samples[b] <= 0) return true;
-        const int t = cm->frontend->compute(
-            pcm[b], static_cast<size_t>(n_samples[b]), fbufs[b]);
-        if (t > 0) T_lfr[b] = t;
+        if (pcm[b] == nullptr || n_samples[b] <= 0) {
+            return true;
+        }
+        const int t = cm->frontend->compute(pcm[b], static_cast<size_t>(n_samples[b]), fbufs[b]);
+        if (t > 0) {
+            T_lfr[b] = t;
+        }
         return true;
     });
     mel_us += ggml_time_us() - t_mel0;
 
     // ---- Pass 1: per-utterance encoder + adaptor (serial) ----
     for (int b = 0; b < n; ++b) {
-        if (cc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
-        if (T_lfr[b] <= 0) continue;
-        if (audio_embed_one(cc, cm, fbufs[b], T_lfr[b],
-                            audio_hosts[b], T_audio[b], enc_us) != TRANSCRIBE_OK)
+        if (cc->poll_abort()) {
+            return TRANSCRIBE_ERR_ABORTED;
+        }
+        if (T_lfr[b] <= 0) {
+            continue;
+        }
+        if (audio_embed_one(cc, cm, fbufs[b], T_lfr[b], audio_hosts[b], T_audio[b], enc_us) != TRANSCRIBE_OK) {
             continue;
+        }
         int fbank_beg = 0;
-        if (build_funasr_nano_prompt(cm->tok, cm->chat_tokens, lang, use_itn,
-                                     T_audio[b], prompt_ids[b], fbank_beg)
-            != TRANSCRIBE_OK)
+        if (build_funasr_nano_prompt(cm->tok, cm->chat_tokens, lang, use_itn, T_audio[b], prompt_ids[b], fbank_beg) !=
+            TRANSCRIBE_OK) {
             continue;
+        }
         T_prompt[b] = static_cast<int>(prompt_ids[b].size());
         prefix_len  = fbank_beg;
 
@@ -1196,102 +1152,115 @@ transcribe_status run_batch(
         // single-shot run() gate (T_prompt + k_max_new > ceiling).
         if (T_prompt[b] + k_max_new > ceiling) {
             const int suffix = T_prompt[b] - fbank_beg - T_audio[b];
-            transcribe::log_msg(
-                TRANSCRIBE_LOG_LEVEL_ERROR,
-                "funasr_nano run_batch: utterance %d input too long — %d audio + "
-                "%d prompt tokens leave no room for output within the %d-token "
-                "context (need %d). Shorten the audio (see "
-                "transcribe_capabilities.max_audio_ms) or split it.",
-                b, T_audio[b], fbank_beg + suffix, ceiling,
-                T_prompt[b] + k_max_new);
+            transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
+                                "funasr_nano run_batch: utterance %d input too long — %d audio + "
+                                "%d prompt tokens leave no room for output within the %d-token "
+                                "context (need %d). Shorten the audio (see "
+                                "transcribe_capabilities.max_audio_ms) or split it.",
+                                b, T_audio[b], fbank_beg + suffix, ceiling, T_prompt[b] + k_max_new);
             fail_status[b] = TRANSCRIBE_ERR_INPUT_TOO_LONG;
             continue;
         }
-        valid[b]    = 1;
+        valid[b] = 1;
     }
 
     int max_T_prompt = 0;
-    for (int b = 0; b < n; ++b) if (valid[b]) max_T_prompt = std::max(max_T_prompt, T_prompt[b]);
+    for (int b = 0; b < n; ++b) {
+        if (valid[b]) {
+            max_T_prompt = std::max(max_T_prompt, T_prompt[b]);
+        }
+    }
     if (max_T_prompt == 0) {
         for (int b = 0; b < n; ++b) {
-            transcribe_session::ResultSet rs; rs.status = fail_status[b];
+            transcribe_session::ResultSet rs;
+            rs.status = fail_status[b];
             cc->batch_results.push_back(std::move(rs));
         }
         return TRANSCRIBE_OK;
     }
-    const int max_new = 256;
-    int max_n_kv = 1024;
-    while (max_n_kv < max_T_prompt + max_new) max_n_kv *= 2;
+    const int max_new  = 256;
+    int       max_n_kv = 1024;
+    while (max_n_kv < max_T_prompt + max_new) {
+        max_n_kv *= 2;
+    }
     // Honor the session context cap: clamp the pow2-rounded width to the
     // ceiling (the per-utterance gate guarantees every valid row fits).
-    if (max_n_kv > ceiling) max_n_kv = ceiling;
+    if (max_n_kv > ceiling) {
+        max_n_kv = ceiling;
+    }
 
     // ---- Allocate batched KV cache ----
-    ggml_type kv_type = (cc->kv_type == TRANSCRIBE_KV_TYPE_F32)
-                      ? GGML_TYPE_F32 : GGML_TYPE_F16;
-    if (cc->kv_cache_batch.self_k == nullptr ||
-        cc->kv_batch_cap != n || cc->kv_batch_n_ctx != max_n_kv) {
+    ggml_type kv_type = (cc->kv_type == TRANSCRIBE_KV_TYPE_F32) ? GGML_TYPE_F32 : GGML_TYPE_F16;
+    if (cc->kv_cache_batch.self_k == nullptr || cc->kv_batch_cap != n || cc->kv_batch_n_ctx != max_n_kv) {
         cc->kv_cache_batch.free();
-        if (!transcribe::causal_lm::kv_init_batched(
-                cc->kv_cache_batch, cm->plan.primary, max_n_kv,
-                hp.dec_n_kv_heads, hp.dec_head_dim, hp.dec_n_layers, n, kv_type)) {
+        if (!transcribe::causal_lm::kv_init_batched(cc->kv_cache_batch, cm->plan.primary, max_n_kv, hp.dec_n_kv_heads,
+                                                    hp.dec_head_dim, hp.dec_n_layers, n, kv_type)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "funasr_nano run_batch: batched KV cache allocation failed "
-                "(n_ctx=%d x %d utterances) — out of memory. Lower "
-                "transcribe_session_params.n_ctx or the batch size.",
-                max_n_kv, n);
+                                "funasr_nano run_batch: batched KV cache allocation failed "
+                                "(n_ctx=%d x %d utterances) — out of memory. Lower "
+                                "transcribe_session_params.n_ctx or the batch size.",
+                                max_n_kv, n);
             return TRANSCRIBE_ERR_OOM;
         }
-        cc->kv_batch_cap = n; cc->kv_batch_n_ctx = max_n_kv;
+        cc->kv_batch_cap   = n;
+        cc->kv_batch_n_ctx = max_n_kv;
     } else if (cc->kv_cache_batch.buffer != nullptr) {
         ggml_backend_buffer_clear(cc->kv_cache_batch.buffer, 0);
     }
 
     // ---- Pass 2: batched prefill ----
-    std::vector<int32_t> next_tok(n, 0);
-    std::vector<int> n_past(n, 0);
+    std::vector<int32_t>              next_tok(n, 0);
+    std::vector<int>                  n_past(n, 0);
     std::vector<std::vector<int32_t>> generated(n);
     {
         int T_audio_max = 0;
-        for (int b = 0; b < n; ++b) if (valid[b]) T_audio_max = std::max(T_audio_max, T_audio[b]);
+        for (int b = 0; b < n; ++b) {
+            if (valid[b]) {
+                T_audio_max = std::max(T_audio_max, T_audio[b]);
+            }
+        }
         T_audio_max = std::max(1, T_audio_max);
-        if (reset_ctx(cc, 32) != TRANSCRIBE_OK) return TRANSCRIBE_ERR_GGUF;
-        PrefillBuildBatched pb = build_prefill_graph_batched(
-            cc->compute_ctx, cm->weights, hp, cc->kv_cache_batch,
-            max_T_prompt, T_audio_max, n, cc->decoder_use_flash);
-        if (pb.graph == nullptr || pb.out == nullptr) return TRANSCRIBE_ERR_GGUF;
+        if (reset_ctx(cc, 32) != TRANSCRIBE_OK) {
+            return TRANSCRIBE_ERR_GGUF;
+        }
+        PrefillBuildBatched pb = build_prefill_graph_batched(cc->compute_ctx, cm->weights, hp, cc->kv_cache_batch,
+                                                             max_T_prompt, T_audio_max, n, cc->decoder_use_flash);
+        if (pb.graph == nullptr || pb.out == nullptr) {
+            return TRANSCRIBE_ERR_GGUF;
+        }
         ggml_backend_sched_reset(cc->sched);
-        if (!ggml_backend_sched_alloc_graph(cc->sched, pb.graph)) return TRANSCRIBE_ERR_GGUF;
+        if (!ggml_backend_sched_alloc_graph(cc->sched, pb.graph)) {
+            return TRANSCRIBE_ERR_GGUF;
+        }
 
-        const int hidden = hp.dec_hidden;
+        const int            hidden = hp.dec_hidden;
         std::vector<int32_t> ids(static_cast<size_t>(max_T_prompt) * n, 0);
         // Audio injection by elementwise blend: audio_dense holds each
         // utterance's audio embeds scattered into their prompt positions (zero
         // elsewhere), keep is 0 there and 1 elsewhere. x = x*keep + audio_dense.
-        std::vector<float> audio_dense(static_cast<size_t>(hidden) * max_T_prompt * n, 0.0f);
-        std::vector<float> keep(static_cast<size_t>(max_T_prompt) * n, 1.0f);
+        std::vector<float>   audio_dense(static_cast<size_t>(hidden) * max_T_prompt * n, 0.0f);
+        std::vector<float>   keep(static_cast<size_t>(max_T_prompt) * n, 1.0f);
         std::vector<int64_t> kidx(static_cast<size_t>(max_T_prompt) * n);
         std::vector<int32_t> lidx(n, 0);
         for (int b = 0; b < n; ++b) {
             const int ta = valid[b] ? T_audio[b] : 0;
             const int tp = valid[b] ? T_prompt[b] : 0;
             if (valid[b]) {
-                std::memcpy(ids.data() + static_cast<size_t>(b) * max_T_prompt,
-                            prompt_ids[b].data(),
+                std::memcpy(ids.data() + static_cast<size_t>(b) * max_T_prompt, prompt_ids[b].data(),
                             static_cast<size_t>(tp) * sizeof(int32_t));
                 // audio_hosts[b] is [hidden, ta] column-major; audio token j lands
                 // at prompt position prefix_len+j, flat column b*max_T_prompt+pos.
                 for (int j = 0; j < ta; ++j) {
-                    const size_t dst_col =
-                        static_cast<size_t>(b) * max_T_prompt + (prefix_len + j);
+                    const size_t dst_col = static_cast<size_t>(b) * max_T_prompt + (prefix_len + j);
                     std::memcpy(audio_dense.data() + dst_col * hidden,
                                 audio_hosts[b].data() + static_cast<size_t>(j) * hidden,
                                 static_cast<size_t>(hidden) * sizeof(float));
                     keep[dst_col] = 0.0f;
                 }
             }
-            for (int t = 0; t < max_T_prompt; ++t)
+            for (int t = 0; t < max_T_prompt; ++t) {
                 kidx[static_cast<size_t>(b) * max_T_prompt + t] = t;
+            }
             lidx[b] = valid[b] ? (tp - 1) : 0;
         }
         ggml_backend_tensor_set(pb.input_ids_in, ids.data(), 0, ids.size() * sizeof(int32_t));
@@ -1299,28 +1268,34 @@ transcribe_status run_batch(
         ggml_backend_tensor_set(pb.keep_mask_in, keep.data(), 0, keep.size() * sizeof(float));
         {
             std::vector<int32_t> pos(max_T_prompt);
-            for (int t = 0; t < max_T_prompt; ++t) pos[t] = t;
+            for (int t = 0; t < max_T_prompt; ++t) {
+                pos[t] = t;
+            }
             ggml_backend_tensor_set(pb.positions_in, pos.data(), 0, pos.size() * sizeof(int32_t));
         }
         {
-            const ggml_fp16_t mz = ggml_fp32_to_fp16(0.0f);
-            const ggml_fp16_t mn = ggml_fp32_to_fp16(-INFINITY);
+            const ggml_fp16_t        mz = ggml_fp32_to_fp16(0.0f);
+            const ggml_fp16_t        mn = ggml_fp32_to_fp16(-INFINITY);
             std::vector<ggml_fp16_t> mask(static_cast<size_t>(max_T_prompt) * max_T_prompt, mn);
-            for (int q = 0; q < max_T_prompt; ++q)
+            for (int q = 0; q < max_T_prompt; ++q) {
                 std::fill(mask.begin() + static_cast<size_t>(q) * max_T_prompt,
                           mask.begin() + static_cast<size_t>(q) * max_T_prompt + q + 1, mz);
+            }
             ggml_backend_tensor_set(pb.mask_in, mask.data(), 0, mask.size() * sizeof(ggml_fp16_t));
         }
         ggml_backend_tensor_set(pb.kv_idx_in, kidx.data(), 0, kidx.size() * sizeof(int64_t));
         ggml_backend_tensor_set(pb.last_idx_in, lidx.data(), 0, lidx.size() * sizeof(int32_t));
         apply_thread_policy(cc);
-        if (ggml_backend_sched_graph_compute(cc->sched, pb.graph) != GGML_STATUS_SUCCESS)
+        if (ggml_backend_sched_graph_compute(cc->sched, pb.graph) != GGML_STATUS_SUCCESS) {
             return TRANSCRIBE_ERR_GGUF;
+        }
         std::vector<int32_t> amax(n, 0);
         ggml_backend_tensor_get(pb.out, amax.data(), 0, amax.size() * sizeof(int32_t));
         for (int b = 0; b < n; ++b) {
-            if (!valid[b]) continue;
-            n_past[b] = T_prompt[b];
+            if (!valid[b]) {
+                continue;
+            }
+            n_past[b]   = T_prompt[b];
             next_tok[b] = amax[b];
             generated[b].push_back(amax[b]);
         }
@@ -1329,15 +1304,20 @@ transcribe_status run_batch(
     // ---- Pass 3: batched step loop (shared causal_lm driver) ----
     const int32_t eos_id = cm->hparams.eos_token_id;
 
-    if (reset_ctx(cc, 16) != TRANSCRIBE_OK) return TRANSCRIBE_ERR_GGUF;
-    StepBuildBatched sb = build_step_graph_batched(
-        cc->compute_ctx, cm->weights, hp, cc->kv_cache_batch,
-        max_n_kv, n, cc->decoder_use_flash);
-    if (sb.graph == nullptr || sb.out == nullptr) return TRANSCRIBE_ERR_GGUF;
+    if (reset_ctx(cc, 16) != TRANSCRIBE_OK) {
+        return TRANSCRIBE_ERR_GGUF;
+    }
+    StepBuildBatched sb = build_step_graph_batched(cc->compute_ctx, cm->weights, hp, cc->kv_cache_batch, max_n_kv, n,
+                                                   cc->decoder_use_flash);
+    if (sb.graph == nullptr || sb.out == nullptr) {
+        return TRANSCRIBE_ERR_GGUF;
+    }
     ggml_backend_sched_reset(cc->sched);
-    if (!ggml_backend_sched_alloc_graph(cc->sched, sb.graph)) return TRANSCRIBE_ERR_GGUF;
+    if (!ggml_backend_sched_alloc_graph(cc->sched, sb.graph)) {
+        return TRANSCRIBE_ERR_GGUF;
+    }
 
-    transcribe::causal_lm::StepBatchedIO io {};
+    transcribe::causal_lm::StepBatchedIO io{};
     io.input_ids = sb.input_ids_in;
     io.positions = sb.position_in;
     io.kv_idx    = sb.kv_idx_in;
@@ -1351,46 +1331,47 @@ transcribe_status run_batch(
     step_state.n_past   = n_past;
 
     transcribe::causal_lm::StepLoopStats step_stats;
-    std::vector<char> truncated;
+    std::vector<char>                    truncated;
     if (const transcribe_status st = transcribe::causal_lm::run_batched_step_loop(
-            cc, cc->sched, io, n, max_n_kv, eos_id, max_new, step_state,
-            generated, &step_stats, &truncated); st != TRANSCRIBE_OK) {
+            cc, cc->sched, io, n, max_n_kv, eos_id, max_new, step_state, generated, &step_stats, &truncated);
+        st != TRANSCRIBE_OK) {
         return st;
     }
     const int64_t step_us = step_stats.step_us;
 
     // ---- Capture results ----
-    const int valid_count = std::max(1, static_cast<int>(
-        std::count(valid.begin(), valid.end(), char(1))));
+    const int valid_count = std::max(1, static_cast<int>(std::count(valid.begin(), valid.end(), char(1))));
     for (int b = 0; b < n; ++b) {
         if (!valid[b]) {
-            transcribe_session::ResultSet rs; rs.status = fail_status[b];
+            transcribe_session::ResultSet rs;
+            rs.status = fail_status[b];
             cc->batch_results.push_back(std::move(rs));
             continue;
         }
         std::vector<int32_t> gen = generated[b];
-        if (!gen.empty() && gen.back() == eos_id) gen.pop_back();
-        std::string transcript = cm->tok.decode(gen.data(), static_cast<int>(gen.size()));
+        if (!gen.empty() && gen.back() == eos_id) {
+            gen.pop_back();
+        }
+        std::string                   transcript = cm->tok.decode(gen.data(), static_cast<int>(gen.size()));
         transcribe_session::ResultSet rs;
-        rs.full_text = transcript;
+        rs.full_text   = transcript;
         rs.result_kind = TRANSCRIBE_TIMESTAMPS_NONE;
-        rs.has_result = true;
-        rs.status = TRANSCRIBE_OK;
-        transcribe_session::SegmentEntry seg {};
-        seg.text = transcript; seg.t0_ms = 0;
-        seg.t1_ms = static_cast<int64_t>(n_samples[b]) * 1000
-                  / static_cast<int64_t>(hp.fe_sample_rate);
+        rs.has_result  = true;
+        rs.status      = TRANSCRIBE_OK;
+        transcribe_session::SegmentEntry seg{};
+        seg.text  = transcript;
+        seg.t0_ms = 0;
+        seg.t1_ms = static_cast<int64_t>(n_samples[b]) * 1000 / static_cast<int64_t>(hp.fe_sample_rate);
         rs.segments.push_back(std::move(seg));
         // Per-utterance truncation parity with single-shot run(): a row cut at
         // the generation budget / KV window before eos reports
         // TRANSCRIBE_ERR_OUTPUT_TRUNCATED (partial transcript retained). Only
         // override a TRANSCRIBE_OK status, never a worse one.
-        if (b < static_cast<int>(truncated.size()) && truncated[b] &&
-            rs.status == TRANSCRIBE_OK) {
+        if (b < static_cast<int>(truncated.size()) && truncated[b] && rs.status == TRANSCRIBE_OK) {
             cc->was_truncated = true;
-            rs.status = TRANSCRIBE_ERR_OUTPUT_TRUNCATED;
+            rs.status         = TRANSCRIBE_ERR_OUTPUT_TRUNCATED;
         }
-        rs.t_mel_us = mel_us / valid_count;
+        rs.t_mel_us    = mel_us / valid_count;
         rs.t_encode_us = enc_us / valid_count;
         rs.t_decode_us = step_us / valid_count;
         cc->batch_results.push_back(std::move(rs));
@@ -1412,4 +1393,4 @@ extern const Arch arch = {
     /* .accepts_ext_kind = */ nullptr,
 };
 
-} // namespace transcribe::funasr_nano
+}  // namespace transcribe::funasr_nano
diff --git a/src/arch/funasr_nano/weights.cpp b/src/arch/funasr_nano/weights.cpp
index b0744189..565304ab 100644
--- a/src/arch/funasr_nano/weights.cpp
+++ b/src/arch/funasr_nano/weights.cpp
@@ -3,12 +3,11 @@
 
 #include "weights.h"
 
-#include "transcribe-meta.h"
-#include "transcribe-weights-util.h"
-#include "transcribe-log.h"
-
 #include "ggml.h"
 #include "gguf.h"
+#include "transcribe-log.h"
+#include "transcribe-meta.h"
+#include "transcribe-weights-util.h"
 
 #include <cstdio>
 
@@ -18,171 +17,298 @@ namespace {
 constexpr const char * kFamilyTag = "funasr_nano";
 }
 
-transcribe_status read_funasr_nano_hparams(const gguf_context *  gguf,
-                                           FunAsrNanoHParams &   hp)
-{
+transcribe_status read_funasr_nano_hparams(const gguf_context * gguf, FunAsrNanoHParams & hp) {
     if (gguf == nullptr) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
 
     // Encoder.
-    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.encoder.n_blocks",   kFamilyTag, hp.enc_n_blocks);    st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.encoder.tp_blocks",  kFamilyTag, hp.enc_tp_blocks);   st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.encoder.d_model",    kFamilyTag, hp.enc_d_model);     st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.encoder.d_input",    kFamilyTag, hp.enc_d_input);     st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.encoder.n_heads",    kFamilyTag, hp.enc_n_heads);     st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.encoder.d_ff",       kFamilyTag, hp.enc_d_ff);        st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.encoder.kernel_size",kFamilyTag, hp.enc_kernel);      st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.encoder.sanm_shift", kFamilyTag, hp.enc_sanm_shift);  st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.funasr_nano.encoder.attention_type", kFamilyTag, hp.enc_attn_type); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_bool_kv(gguf, "stt.funasr_nano.encoder.normalize_before", kFamilyTag, true, hp.enc_normalize_before); st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.encoder.n_blocks", kFamilyTag, hp.enc_n_blocks);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.encoder.tp_blocks", kFamilyTag, hp.enc_tp_blocks);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.encoder.d_model", kFamilyTag, hp.enc_d_model);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.encoder.d_input", kFamilyTag, hp.enc_d_input);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.encoder.n_heads", kFamilyTag, hp.enc_n_heads);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.encoder.d_ff", kFamilyTag, hp.enc_d_ff);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.encoder.kernel_size", kFamilyTag, hp.enc_kernel);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.encoder.sanm_shift", kFamilyTag, hp.enc_sanm_shift);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_string_kv(gguf, "stt.funasr_nano.encoder.attention_type", kFamilyTag, hp.enc_attn_type);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_bool_kv(gguf, "stt.funasr_nano.encoder.normalize_before", kFamilyTag, true,
+                                        hp.enc_normalize_before);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Adaptor.
-    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.adaptor.n_blocks",      kFamilyTag, hp.adaptor_n_blocks);      st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.adaptor.encoder_dim",   kFamilyTag, hp.adaptor_encoder_dim);   st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.adaptor.llm_dim",       kFamilyTag, hp.adaptor_llm_dim);       st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.adaptor.pre_ffn_dim",   kFamilyTag, hp.adaptor_pre_ffn_dim);   st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.adaptor.block_ffn_dim", kFamilyTag, hp.adaptor_block_ffn_dim); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.adaptor.n_heads",       kFamilyTag, hp.adaptor_n_heads);       st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.adaptor.d_head",        kFamilyTag, hp.adaptor_d_head);        st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf, "stt.funasr_nano.adaptor.layer_norm_eps", kFamilyTag, hp.adaptor_layer_norm_eps); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.funasr_nano.adaptor.activation", kFamilyTag, hp.adaptor_activation); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.adaptor.downsample_rate", kFamilyTag, hp.adaptor_downsample_rate); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_bool_kv(gguf, "stt.funasr_nano.adaptor.use_low_frame_rate", kFamilyTag, true, hp.adaptor_use_low_frame_rate); st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.adaptor.n_blocks", kFamilyTag, hp.adaptor_n_blocks);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.adaptor.encoder_dim", kFamilyTag, hp.adaptor_encoder_dim);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.adaptor.llm_dim", kFamilyTag, hp.adaptor_llm_dim);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.adaptor.pre_ffn_dim", kFamilyTag, hp.adaptor_pre_ffn_dim);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st =
+            read_required_u32_kv(gguf, "stt.funasr_nano.adaptor.block_ffn_dim", kFamilyTag, hp.adaptor_block_ffn_dim);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.adaptor.n_heads", kFamilyTag, hp.adaptor_n_heads);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.adaptor.d_head", kFamilyTag, hp.adaptor_d_head);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st =
+            read_required_f32_kv(gguf, "stt.funasr_nano.adaptor.layer_norm_eps", kFamilyTag, hp.adaptor_layer_norm_eps);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st =
+            read_required_string_kv(gguf, "stt.funasr_nano.adaptor.activation", kFamilyTag, hp.adaptor_activation);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.adaptor.downsample_rate", kFamilyTag,
+                                       hp.adaptor_downsample_rate);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_bool_kv(gguf, "stt.funasr_nano.adaptor.use_low_frame_rate", kFamilyTag, true,
+                                        hp.adaptor_use_low_frame_rate);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Decoder (Qwen3-0.6B).
-    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.decoder.n_layers",        kFamilyTag, hp.dec_n_layers);     st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.decoder.hidden_size",     kFamilyTag, hp.dec_hidden);       st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.decoder.intermediate_size",kFamilyTag, hp.dec_intermediate); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.decoder.n_heads",         kFamilyTag, hp.dec_n_heads);      st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.decoder.n_kv_heads",      kFamilyTag, hp.dec_n_kv_heads);   st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.decoder.head_dim",        kFamilyTag, hp.dec_head_dim);     st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.decoder.vocab_size",      kFamilyTag, hp.dec_vocab_size);   st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.decoder.max_position_embeddings", kFamilyTag, hp.dec_max_position_embeddings); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf, "stt.funasr_nano.decoder.rms_norm_eps",    kFamilyTag, hp.dec_rms_norm_eps); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf, "stt.funasr_nano.decoder.rope_theta",      kFamilyTag, hp.dec_rope_theta);   st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_bool_kv(gguf, "stt.funasr_nano.decoder.tie_word_embeddings", kFamilyTag, true, hp.dec_tie_word_embeddings); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.funasr_nano.decoder.activation",   kFamilyTag, hp.dec_activation);   st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.decoder.n_layers", kFamilyTag, hp.dec_n_layers);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.decoder.hidden_size", kFamilyTag, hp.dec_hidden);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st =
+            read_required_u32_kv(gguf, "stt.funasr_nano.decoder.intermediate_size", kFamilyTag, hp.dec_intermediate);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.decoder.n_heads", kFamilyTag, hp.dec_n_heads);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.decoder.n_kv_heads", kFamilyTag, hp.dec_n_kv_heads);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.decoder.head_dim", kFamilyTag, hp.dec_head_dim);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.decoder.vocab_size", kFamilyTag, hp.dec_vocab_size);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.decoder.max_position_embeddings", kFamilyTag,
+                                       hp.dec_max_position_embeddings);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.funasr_nano.decoder.rms_norm_eps", kFamilyTag, hp.dec_rms_norm_eps);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.funasr_nano.decoder.rope_theta", kFamilyTag, hp.dec_rope_theta);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_bool_kv(gguf, "stt.funasr_nano.decoder.tie_word_embeddings", kFamilyTag, true,
+                                        hp.dec_tie_word_embeddings);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_string_kv(gguf, "stt.funasr_nano.decoder.activation", kFamilyTag, hp.dec_activation);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Frontend.
-    if (auto st = read_required_string_kv(gguf, "stt.frontend.type",      kFamilyTag, hp.fe_type);          st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf,    "stt.frontend.num_mels",  kFamilyTag, hp.fe_num_mels);      st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf,    "stt.frontend.sample_rate",kFamilyTag, hp.fe_sample_rate);  st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf,    "stt.frontend.n_fft",     kFamilyTag, hp.fe_n_fft);         st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf,    "stt.frontend.win_length",kFamilyTag, hp.fe_win_length);    st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf,    "stt.frontend.hop_length",kFamilyTag, hp.fe_hop_length);    st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.frontend.window",    kFamilyTag, hp.fe_window);        st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.frontend.normalize", kFamilyTag, hp.fe_normalize);     st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.frontend.fbank_style",kFamilyTag, hp.fe_fbank_style);  st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf,    "stt.frontend.dither",    kFamilyTag, hp.fe_dither);        st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_bool_kv(gguf,   "stt.frontend.upscale_samples", kFamilyTag, true, hp.fe_upscale_samples); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_bool_kv(gguf,   "stt.frontend.snip_edges", kFamilyTag, true, hp.fe_snip_edges); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf,    "stt.frontend.lfr_m",     kFamilyTag, hp.fe_lfr_m);         st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf,    "stt.frontend.lfr_n",     kFamilyTag, hp.fe_lfr_n);         st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_bool_kv(gguf,   "stt.frontend.apply_cmvn",kFamilyTag, false, hp.fe_apply_cmvn); st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_string_kv(gguf, "stt.frontend.type", kFamilyTag, hp.fe_type); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.num_mels", kFamilyTag, hp.fe_num_mels);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.sample_rate", kFamilyTag, hp.fe_sample_rate);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.n_fft", kFamilyTag, hp.fe_n_fft); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.win_length", kFamilyTag, hp.fe_win_length);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.hop_length", kFamilyTag, hp.fe_hop_length);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_string_kv(gguf, "stt.frontend.window", kFamilyTag, hp.fe_window); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_string_kv(gguf, "stt.frontend.normalize", kFamilyTag, hp.fe_normalize);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_string_kv(gguf, "stt.frontend.fbank_style", kFamilyTag, hp.fe_fbank_style);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.frontend.dither", kFamilyTag, hp.fe_dither); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_bool_kv(gguf, "stt.frontend.upscale_samples", kFamilyTag, true, hp.fe_upscale_samples);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_bool_kv(gguf, "stt.frontend.snip_edges", kFamilyTag, true, hp.fe_snip_edges);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.lfr_m", kFamilyTag, hp.fe_lfr_m); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.lfr_n", kFamilyTag, hp.fe_lfr_n); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_bool_kv(gguf, "stt.frontend.apply_cmvn", kFamilyTag, false, hp.fe_apply_cmvn);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Cross-field invariants.
-    if (hp.enc_n_blocks <= 1 || hp.enc_tp_blocks < 0 ||
-        hp.enc_d_model <= 0  || hp.enc_d_input <= 0 ||
-        hp.enc_n_heads <= 0  || hp.enc_d_ff <= 0    ||
-        hp.enc_kernel <= 0   || hp.enc_kernel % 2 == 0)
-    {
+    if (hp.enc_n_blocks <= 1 || hp.enc_tp_blocks < 0 || hp.enc_d_model <= 0 || hp.enc_d_input <= 0 ||
+        hp.enc_n_heads <= 0 || hp.enc_d_ff <= 0 || hp.enc_kernel <= 0 || hp.enc_kernel % 2 == 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "funasr_nano: encoder hparams invalid (n_blocks=%d "
-                     "tp_blocks=%d d_model=%d d_input=%d n_heads=%d d_ff=%d "
-                     "kernel=%d — kernel must be positive and odd)",
-                     hp.enc_n_blocks, hp.enc_tp_blocks, hp.enc_d_model,
-                     hp.enc_d_input, hp.enc_n_heads, hp.enc_d_ff, hp.enc_kernel);
+                "funasr_nano: encoder hparams invalid (n_blocks=%d "
+                "tp_blocks=%d d_model=%d d_input=%d n_heads=%d d_ff=%d "
+                "kernel=%d — kernel must be positive and odd)",
+                hp.enc_n_blocks, hp.enc_tp_blocks, hp.enc_d_model, hp.enc_d_input, hp.enc_n_heads, hp.enc_d_ff,
+                hp.enc_kernel);
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.enc_d_model % hp.enc_n_heads != 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "funasr_nano: encoder d_model (%d) not divisible by n_heads (%d)",
-                     hp.enc_d_model, hp.enc_n_heads);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "funasr_nano: encoder d_model (%d) not divisible by n_heads (%d)",
+                hp.enc_d_model, hp.enc_n_heads);
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.enc_d_input != hp.fe_num_mels * hp.fe_lfr_m) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "funasr_nano: encoder d_input (%d) must equal num_mels (%d) "
-                     "× lfr_m (%d) = %d",
-                     hp.enc_d_input, hp.fe_num_mels, hp.fe_lfr_m,
-                     hp.fe_num_mels * hp.fe_lfr_m);
+                "funasr_nano: encoder d_input (%d) must equal num_mels (%d) "
+                "× lfr_m (%d) = %d",
+                hp.enc_d_input, hp.fe_num_mels, hp.fe_lfr_m, hp.fe_num_mels * hp.fe_lfr_m);
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.enc_attn_type != "sanm") {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "funasr_nano: unsupported encoder attention type \"%s\"",
-                     hp.enc_attn_type.c_str());
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "funasr_nano: unsupported encoder attention type \"%s\"",
+                hp.enc_attn_type.c_str());
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.adaptor_n_heads <= 0 || hp.adaptor_d_head <= 0 ||
-        hp.adaptor_llm_dim != hp.adaptor_n_heads * hp.adaptor_d_head)
-    {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "funasr_nano: adaptor llm_dim (%d) != n_heads (%d) * d_head (%d)",
-                     hp.adaptor_llm_dim, hp.adaptor_n_heads, hp.adaptor_d_head);
+        hp.adaptor_llm_dim != hp.adaptor_n_heads * hp.adaptor_d_head) {
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "funasr_nano: adaptor llm_dim (%d) != n_heads (%d) * d_head (%d)",
+                hp.adaptor_llm_dim, hp.adaptor_n_heads, hp.adaptor_d_head);
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.adaptor_activation != "relu") {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "funasr_nano: unsupported adaptor activation \"%s\" "
-                     "(only \"relu\" is implemented)",
-                     hp.adaptor_activation.c_str());
+                "funasr_nano: unsupported adaptor activation \"%s\" "
+                "(only \"relu\" is implemented)",
+                hp.adaptor_activation.c_str());
         return TRANSCRIBE_ERR_GGUF;
     }
-    if (hp.dec_n_layers <= 0 || hp.dec_hidden <= 0 || hp.dec_n_heads <= 0 ||
-        hp.dec_n_kv_heads <= 0 || hp.dec_head_dim <= 0 || hp.dec_intermediate <= 0)
-    {
+    if (hp.dec_n_layers <= 0 || hp.dec_hidden <= 0 || hp.dec_n_heads <= 0 || hp.dec_n_kv_heads <= 0 ||
+        hp.dec_head_dim <= 0 || hp.dec_intermediate <= 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "funasr_nano: decoder hparams must be positive");
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.dec_n_heads % hp.dec_n_kv_heads != 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "funasr_nano: dec n_heads (%d) not divisible by n_kv_heads (%d)",
-                     hp.dec_n_heads, hp.dec_n_kv_heads);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "funasr_nano: dec n_heads (%d) not divisible by n_kv_heads (%d)",
+                hp.dec_n_heads, hp.dec_n_kv_heads);
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.dec_activation != "silu" && hp.dec_activation != "swish") {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "funasr_nano: unsupported decoder activation \"%s\"",
-                     hp.dec_activation.c_str());
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "funasr_nano: unsupported decoder activation \"%s\"",
+                hp.dec_activation.c_str());
         return TRANSCRIBE_ERR_GGUF;
     }
     if (!hp.dec_tie_word_embeddings) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "funasr_nano: decoder.tie_word_embeddings=false is not supported "
-                     "(graph reuses dec.token_embd.weight as the lm_head)");
+                "funasr_nano: decoder.tie_word_embeddings=false is not supported "
+                "(graph reuses dec.token_embd.weight as the lm_head)");
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.adaptor_llm_dim != hp.dec_hidden) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "funasr_nano: adaptor.llm_dim (%d) != decoder.hidden_size (%d)",
-                     hp.adaptor_llm_dim, hp.dec_hidden);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "funasr_nano: adaptor.llm_dim (%d) != decoder.hidden_size (%d)",
+                hp.adaptor_llm_dim, hp.dec_hidden);
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.fe_type != "kaldi_fbank_lfr") {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "funasr_nano: unsupported frontend type \"%s\"",
-                     hp.fe_type.c_str());
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "funasr_nano: unsupported frontend type \"%s\"", hp.fe_type.c_str());
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.fe_window != "hamming") {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "funasr_nano: unsupported frontend window \"%s\"",
-                     hp.fe_window.c_str());
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "funasr_nano: unsupported frontend window \"%s\"", hp.fe_window.c_str());
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.fe_normalize != "none") {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "funasr_nano: unsupported frontend normalize \"%s\" "
-                     "(only \"none\" is implemented; CMVN was dropped at convert)",
-                     hp.fe_normalize.c_str());
+                "funasr_nano: unsupported frontend normalize \"%s\" "
+                "(only \"none\" is implemented; CMVN was dropped at convert)",
+                hp.fe_normalize.c_str());
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.fe_fbank_style != "kaldi_htk") {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "funasr_nano: unsupported fbank_style \"%s\"",
-                     hp.fe_fbank_style.c_str());
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "funasr_nano: unsupported fbank_style \"%s\"", hp.fe_fbank_style.c_str());
         return TRANSCRIBE_ERR_GGUF;
     }
     return TRANSCRIBE_OK;
@@ -199,136 +325,131 @@ using transcribe::weights::lname;
 
 constexpr const char * kTag = kFamilyTag;
 
-#define GET_F32(slot, name, ...) \
-    do { \
-        ggml_tensor * _t = find_tensor( \
-            ctx_meta, (name), \
-            {GGML_TYPE_F32}, {__VA_ARGS__}, kTag); \
-        if (_t == nullptr) return TRANSCRIBE_ERR_GGUF; \
-        (slot) = _t; \
+#define GET_F32(slot, name, ...)                                                                    \
+    do {                                                                                            \
+        ggml_tensor * _t = find_tensor(ctx_meta, (name), { GGML_TYPE_F32 }, { __VA_ARGS__ }, kTag); \
+        if (_t == nullptr)                                                                          \
+            return TRANSCRIBE_ERR_GGUF;                                                             \
+        (slot) = _t;                                                                                \
     } while (0)
 
-#define GET_CONV(slot, name, ...) \
-    do { \
-        ggml_tensor * _t = find_tensor( \
-            ctx_meta, (name), \
-            {TRANSCRIBE_QUANT_CONV_TYPES}, \
-            {__VA_ARGS__}, kTag); \
-        if (_t == nullptr) return TRANSCRIBE_ERR_GGUF; \
-        (slot) = _t; \
+#define GET_CONV(slot, name, ...)                                                                                 \
+    do {                                                                                                          \
+        ggml_tensor * _t = find_tensor(ctx_meta, (name), { TRANSCRIBE_QUANT_CONV_TYPES }, { __VA_ARGS__ }, kTag); \
+        if (_t == nullptr)                                                                                        \
+            return TRANSCRIBE_ERR_GGUF;                                                                           \
+        (slot) = _t;                                                                                              \
     } while (0)
 
-#define GET_LIN(slot, name, ...) \
-    do { \
-        ggml_tensor * _t = find_tensor( \
-            ctx_meta, (name), \
-            {TRANSCRIBE_QUANT_LINEAR_TYPES}, \
-            {__VA_ARGS__}, kTag); \
-        if (_t == nullptr) return TRANSCRIBE_ERR_GGUF; \
-        (slot) = _t; \
+#define GET_LIN(slot, name, ...)                                                                                    \
+    do {                                                                                                            \
+        ggml_tensor * _t = find_tensor(ctx_meta, (name), { TRANSCRIBE_QUANT_LINEAR_TYPES }, { __VA_ARGS__ }, kTag); \
+        if (_t == nullptr)                                                                                          \
+            return TRANSCRIBE_ERR_GGUF;                                                                             \
+        (slot) = _t;                                                                                                \
     } while (0)
 
-transcribe_status load_enc_block(ggml_context *  ctx_meta,
-                                 const char *    prefix,
-                                 int64_t         d_in,
-                                 int64_t         d_model,
-                                 int64_t         d_ff,
-                                 int64_t         kernel,
-                                 EncBlock &      b)
-{
+transcribe_status load_enc_block(ggml_context * ctx_meta,
+                                 const char *   prefix,
+                                 int64_t        d_in,
+                                 int64_t        d_model,
+                                 int64_t        d_ff,
+                                 int64_t        kernel,
+                                 EncBlock &     b) {
     std::string p = prefix;
 
-    GET_F32(b.norm_attn_w,  (p + ".norm_attn.weight").c_str(), d_in);
-    GET_F32(b.norm_attn_b,  (p + ".norm_attn.bias").c_str(),   d_in);
-    GET_LIN(b.attn_qkv_w,   (p + ".attn.qkv.weight").c_str(),  d_in, 3 * d_model);
-    GET_F32(b.attn_qkv_b,   (p + ".attn.qkv.bias").c_str(),    3 * d_model);
-    GET_LIN(b.attn_out_w,   (p + ".attn.out.weight").c_str(),  d_model, d_model);
-    GET_F32(b.attn_out_b,   (p + ".attn.out.bias").c_str(),    d_model);
+    GET_F32(b.norm_attn_w, (p + ".norm_attn.weight").c_str(), d_in);
+    GET_F32(b.norm_attn_b, (p + ".norm_attn.bias").c_str(), d_in);
+    GET_LIN(b.attn_qkv_w, (p + ".attn.qkv.weight").c_str(), d_in, 3 * d_model);
+    GET_F32(b.attn_qkv_b, (p + ".attn.qkv.bias").c_str(), 3 * d_model);
+    GET_LIN(b.attn_out_w, (p + ".attn.out.weight").c_str(), d_model, d_model);
+    GET_F32(b.attn_out_b, (p + ".attn.out.bias").c_str(), d_model);
     GET_CONV(b.attn_fsmn_w, (p + ".attn.fsmn.weight").c_str(), kernel, 1, d_model);
-    GET_F32(b.norm_ffn_w,   (p + ".norm_ffn.weight").c_str(),  d_model);
-    GET_F32(b.norm_ffn_b,   (p + ".norm_ffn.bias").c_str(),    d_model);
-    GET_LIN(b.ffn_fc1_w,    (p + ".ffn.fc1.weight").c_str(),   d_model, d_ff);
-    GET_F32(b.ffn_fc1_b,    (p + ".ffn.fc1.bias").c_str(),     d_ff);
-    GET_LIN(b.ffn_fc2_w,    (p + ".ffn.fc2.weight").c_str(),   d_ff, d_model);
-    GET_F32(b.ffn_fc2_b,    (p + ".ffn.fc2.bias").c_str(),     d_model);
+    GET_F32(b.norm_ffn_w, (p + ".norm_ffn.weight").c_str(), d_model);
+    GET_F32(b.norm_ffn_b, (p + ".norm_ffn.bias").c_str(), d_model);
+    GET_LIN(b.ffn_fc1_w, (p + ".ffn.fc1.weight").c_str(), d_model, d_ff);
+    GET_F32(b.ffn_fc1_b, (p + ".ffn.fc1.bias").c_str(), d_ff);
+    GET_LIN(b.ffn_fc2_w, (p + ".ffn.fc2.weight").c_str(), d_ff, d_model);
+    GET_F32(b.ffn_fc2_b, (p + ".ffn.fc2.bias").c_str(), d_model);
     return TRANSCRIBE_OK;
 }
 
-transcribe_status load_adaptor_block(ggml_context *  ctx_meta,
-                                     const char *    prefix,
-                                     int64_t         llm_dim,
-                                     int64_t         block_ffn_dim,
-                                     AdaptorBlock &  b)
-{
+transcribe_status load_adaptor_block(ggml_context * ctx_meta,
+                                     const char *   prefix,
+                                     int64_t        llm_dim,
+                                     int64_t        block_ffn_dim,
+                                     AdaptorBlock & b) {
     std::string p = prefix;
 
     GET_F32(b.norm_attn_w, (p + ".norm_attn.weight").c_str(), llm_dim);
-    GET_F32(b.norm_attn_b, (p + ".norm_attn.bias").c_str(),   llm_dim);
-    GET_LIN(b.attn_q_w,    (p + ".attn.q.weight").c_str(),    llm_dim, llm_dim);
-    GET_F32(b.attn_q_b,    (p + ".attn.q.bias").c_str(),      llm_dim);
-    GET_LIN(b.attn_k_w,    (p + ".attn.k.weight").c_str(),    llm_dim, llm_dim);
-    GET_F32(b.attn_k_b,    (p + ".attn.k.bias").c_str(),      llm_dim);
-    GET_LIN(b.attn_v_w,    (p + ".attn.v.weight").c_str(),    llm_dim, llm_dim);
-    GET_F32(b.attn_v_b,    (p + ".attn.v.bias").c_str(),      llm_dim);
-    GET_LIN(b.attn_out_w,  (p + ".attn.out.weight").c_str(),  llm_dim, llm_dim);
-    GET_F32(b.attn_out_b,  (p + ".attn.out.bias").c_str(),    llm_dim);
-    GET_F32(b.norm_ffn_w,  (p + ".norm_ffn.weight").c_str(),  llm_dim);
-    GET_F32(b.norm_ffn_b,  (p + ".norm_ffn.bias").c_str(),    llm_dim);
-    GET_LIN(b.ffn_fc1_w,   (p + ".ffn.fc1.weight").c_str(),   llm_dim, block_ffn_dim);
-    GET_F32(b.ffn_fc1_b,   (p + ".ffn.fc1.bias").c_str(),     block_ffn_dim);
-    GET_LIN(b.ffn_fc2_w,   (p + ".ffn.fc2.weight").c_str(),   block_ffn_dim, llm_dim);
-    GET_F32(b.ffn_fc2_b,   (p + ".ffn.fc2.bias").c_str(),     llm_dim);
+    GET_F32(b.norm_attn_b, (p + ".norm_attn.bias").c_str(), llm_dim);
+    GET_LIN(b.attn_q_w, (p + ".attn.q.weight").c_str(), llm_dim, llm_dim);
+    GET_F32(b.attn_q_b, (p + ".attn.q.bias").c_str(), llm_dim);
+    GET_LIN(b.attn_k_w, (p + ".attn.k.weight").c_str(), llm_dim, llm_dim);
+    GET_F32(b.attn_k_b, (p + ".attn.k.bias").c_str(), llm_dim);
+    GET_LIN(b.attn_v_w, (p + ".attn.v.weight").c_str(), llm_dim, llm_dim);
+    GET_F32(b.attn_v_b, (p + ".attn.v.bias").c_str(), llm_dim);
+    GET_LIN(b.attn_out_w, (p + ".attn.out.weight").c_str(), llm_dim, llm_dim);
+    GET_F32(b.attn_out_b, (p + ".attn.out.bias").c_str(), llm_dim);
+    GET_F32(b.norm_ffn_w, (p + ".norm_ffn.weight").c_str(), llm_dim);
+    GET_F32(b.norm_ffn_b, (p + ".norm_ffn.bias").c_str(), llm_dim);
+    GET_LIN(b.ffn_fc1_w, (p + ".ffn.fc1.weight").c_str(), llm_dim, block_ffn_dim);
+    GET_F32(b.ffn_fc1_b, (p + ".ffn.fc1.bias").c_str(), block_ffn_dim);
+    GET_LIN(b.ffn_fc2_w, (p + ".ffn.fc2.weight").c_str(), block_ffn_dim, llm_dim);
+    GET_F32(b.ffn_fc2_b, (p + ".ffn.fc2.bias").c_str(), llm_dim);
     return TRANSCRIBE_OK;
 }
 
-} // namespace
+}  // namespace
 
-transcribe_status build_funasr_nano_weights(ggml_context *             ctx_meta,
-                                            const FunAsrNanoHParams &  hp,
-                                            FunAsrNanoWeights &        weights)
-{
+transcribe_status build_funasr_nano_weights(ggml_context *            ctx_meta,
+                                            const FunAsrNanoHParams & hp,
+                                            FunAsrNanoWeights &       weights) {
     if (ctx_meta == nullptr) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
 
-    const int64_t d_input  = hp.enc_d_input;
-    const int64_t d_model  = hp.enc_d_model;
-    const int64_t d_ff     = hp.enc_d_ff;
-    const int64_t kernel   = hp.enc_kernel;
+    const int64_t d_input = hp.enc_d_input;
+    const int64_t d_model = hp.enc_d_model;
+    const int64_t d_ff    = hp.enc_d_ff;
+    const int64_t kernel  = hp.enc_kernel;
 
     // ----- encoder: encoders0[0] (560 → 512 projection) -----
     if (auto st = load_enc_block(ctx_meta, "enc.encoders0.0",
-                                 /*d_in=*/d_input, d_model, d_ff, kernel,
-                                 weights.encoders0);
-        st != TRANSCRIBE_OK) return st;
+                                 /*d_in=*/d_input, d_model, d_ff, kernel, weights.encoders0);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // ----- encoder: encoders[0..n_blocks-2] -----
     weights.encoders.assign(hp.enc_n_blocks - 1, EncBlock{});
     for (int i = 0; i < hp.enc_n_blocks - 1; ++i) {
         char prefix[64];
         std::snprintf(prefix, sizeof(prefix), "enc.encoders.%d", i);
-        if (auto st = load_enc_block(ctx_meta, prefix, d_model, d_model,
-                                     d_ff, kernel, weights.encoders[i]);
-            st != TRANSCRIBE_OK) return st;
+        if (auto st = load_enc_block(ctx_meta, prefix, d_model, d_model, d_ff, kernel, weights.encoders[i]);
+            st != TRANSCRIBE_OK) {
+            return st;
+        }
     }
 
     // ----- encoder: after_norm -----
     GET_F32(weights.after_norm_w, "enc.after_norm.weight", d_model);
-    GET_F32(weights.after_norm_b, "enc.after_norm.bias",   d_model);
+    GET_F32(weights.after_norm_b, "enc.after_norm.bias", d_model);
 
     // ----- encoder: tp_encoders[0..tp_blocks-1] -----
     weights.tp_encoders.assign(hp.enc_tp_blocks, EncBlock{});
     for (int i = 0; i < hp.enc_tp_blocks; ++i) {
         char prefix[64];
         std::snprintf(prefix, sizeof(prefix), "enc.tp_encoders.%d", i);
-        if (auto st = load_enc_block(ctx_meta, prefix, d_model, d_model,
-                                     d_ff, kernel, weights.tp_encoders[i]);
-            st != TRANSCRIBE_OK) return st;
+        if (auto st = load_enc_block(ctx_meta, prefix, d_model, d_model, d_ff, kernel, weights.tp_encoders[i]);
+            st != TRANSCRIBE_OK) {
+            return st;
+        }
     }
 
     // ----- encoder: tp_norm -----
     GET_F32(weights.tp_norm_w, "enc.tp_norm.weight", d_model);
-    GET_F32(weights.tp_norm_b, "enc.tp_norm.bias",   d_model);
+    GET_F32(weights.tp_norm_b, "enc.tp_norm.bias", d_model);
 
     // ----- adaptor: linear1 / linear2 -----
     const int64_t encoder_dim   = hp.adaptor_encoder_dim;
@@ -336,73 +457,67 @@ transcribe_status build_funasr_nano_weights(ggml_context *             ctx_meta,
     const int64_t pre_ffn_dim   = hp.adaptor_pre_ffn_dim;
     const int64_t block_ffn_dim = hp.adaptor_block_ffn_dim;
     GET_LIN(weights.adaptor.linear1_w, "adaptor.linear1.weight", encoder_dim, pre_ffn_dim);
-    GET_F32(weights.adaptor.linear1_b, "adaptor.linear1.bias",   pre_ffn_dim);
+    GET_F32(weights.adaptor.linear1_b, "adaptor.linear1.bias", pre_ffn_dim);
     GET_LIN(weights.adaptor.linear2_w, "adaptor.linear2.weight", pre_ffn_dim, llm_dim);
-    GET_F32(weights.adaptor.linear2_b, "adaptor.linear2.bias",   llm_dim);
+    GET_F32(weights.adaptor.linear2_b, "adaptor.linear2.bias", llm_dim);
 
     // ----- adaptor blocks -----
     weights.adaptor.blocks.assign(hp.adaptor_n_blocks, AdaptorBlock{});
     for (int i = 0; i < hp.adaptor_n_blocks; ++i) {
         char prefix[64];
         std::snprintf(prefix, sizeof(prefix), "adaptor.blocks.%d", i);
-        if (auto st = load_adaptor_block(ctx_meta, prefix, llm_dim,
-                                         block_ffn_dim,
-                                         weights.adaptor.blocks[i]);
-            st != TRANSCRIBE_OK) return st;
+        if (auto st = load_adaptor_block(ctx_meta, prefix, llm_dim, block_ffn_dim, weights.adaptor.blocks[i]);
+            st != TRANSCRIBE_OK) {
+            return st;
+        }
     }
 
     // ----- decoder: token embed (tied to lm_head) -----
     {
         ggml_tensor * tw = ggml_get_tensor(ctx_meta, "dec.token_embd.weight");
         if (tw == nullptr) {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "funasr_nano: missing tensor \"dec.token_embd.weight\"");
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "funasr_nano: missing tensor \"dec.token_embd.weight\"");
             return TRANSCRIBE_ERR_GGUF;
         }
         if (tw->ne[0] != hp.dec_hidden) {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "funasr_nano: dec.token_embd.weight ne[0]=%lld, expected %lld",
-                         static_cast<long long>(tw->ne[0]),
-                         static_cast<long long>(hp.dec_hidden));
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "funasr_nano: dec.token_embd.weight ne[0]=%lld, expected %lld",
+                    static_cast<long long>(tw->ne[0]), static_cast<long long>(hp.dec_hidden));
             return TRANSCRIBE_ERR_GGUF;
         }
         if (tw->ne[1] != hp.dec_vocab_size) {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "funasr_nano: dec.token_embd.weight ne[1]=%lld, expected %lld",
-                         static_cast<long long>(tw->ne[1]),
-                         static_cast<long long>(hp.dec_vocab_size));
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "funasr_nano: dec.token_embd.weight ne[1]=%lld, expected %lld",
+                    static_cast<long long>(tw->ne[1]), static_cast<long long>(hp.dec_vocab_size));
             return TRANSCRIBE_ERR_GGUF;
         }
         weights.dec_embed.token_w = tw;
     }
 
     // ----- decoder: layers -----
-    const int64_t dec_h  = hp.dec_hidden;
-    const int64_t dec_nh = hp.dec_n_heads;
+    const int64_t dec_h   = hp.dec_hidden;
+    const int64_t dec_nh  = hp.dec_n_heads;
     const int64_t dec_nkv = hp.dec_n_kv_heads;
-    const int64_t dec_hd = hp.dec_head_dim;
-    const int64_t dec_im = hp.dec_intermediate;
-    const int64_t q_out  = dec_nh  * dec_hd;
-    const int64_t kv_out = dec_nkv * dec_hd;
+    const int64_t dec_hd  = hp.dec_head_dim;
+    const int64_t dec_im  = hp.dec_intermediate;
+    const int64_t q_out   = dec_nh * dec_hd;
+    const int64_t kv_out  = dec_nkv * dec_hd;
 
     weights.dec_blocks.assign(hp.dec_n_layers, DecBlock{});
     for (int i = 0; i < hp.dec_n_layers; ++i) {
         auto & b = weights.dec_blocks[i];
         GET_F32(b.norm_attn_w, lname("dec.layers.%d.norm_attn.weight", i), dec_h);
-        GET_F32(b.norm_ffn_w,  lname("dec.layers.%d.norm_ffn.weight",  i), dec_h);
-        GET_LIN(b.attn_q_w,    lname("dec.layers.%d.attn.q.weight",    i), dec_h, q_out);
-        GET_LIN(b.attn_k_w,    lname("dec.layers.%d.attn.k.weight",    i), dec_h, kv_out);
-        GET_LIN(b.attn_v_w,    lname("dec.layers.%d.attn.v.weight",    i), dec_h, kv_out);
-        GET_LIN(b.attn_o_w,    lname("dec.layers.%d.attn.o.weight",    i), q_out, dec_h);
+        GET_F32(b.norm_ffn_w, lname("dec.layers.%d.norm_ffn.weight", i), dec_h);
+        GET_LIN(b.attn_q_w, lname("dec.layers.%d.attn.q.weight", i), dec_h, q_out);
+        GET_LIN(b.attn_k_w, lname("dec.layers.%d.attn.k.weight", i), dec_h, kv_out);
+        GET_LIN(b.attn_v_w, lname("dec.layers.%d.attn.v.weight", i), dec_h, kv_out);
+        GET_LIN(b.attn_o_w, lname("dec.layers.%d.attn.o.weight", i), q_out, dec_h);
         GET_F32(b.attn_q_norm, lname("dec.layers.%d.attn.q_norm.weight", i), dec_hd);
         GET_F32(b.attn_k_norm, lname("dec.layers.%d.attn.k_norm.weight", i), dec_hd);
-        GET_LIN(b.ffn_gate_w,  lname("dec.layers.%d.ffn.gate.weight",  i), dec_h, dec_im);
-        GET_LIN(b.ffn_up_w,    lname("dec.layers.%d.ffn.up.weight",    i), dec_h, dec_im);
-        GET_LIN(b.ffn_down_w,  lname("dec.layers.%d.ffn.down.weight",  i), dec_im, dec_h);
+        GET_LIN(b.ffn_gate_w, lname("dec.layers.%d.ffn.gate.weight", i), dec_h, dec_im);
+        GET_LIN(b.ffn_up_w, lname("dec.layers.%d.ffn.up.weight", i), dec_h, dec_im);
+        GET_LIN(b.ffn_down_w, lname("dec.layers.%d.ffn.down.weight", i), dec_im, dec_h);
 
         if (b.ffn_gate_w->type != b.ffn_up_w->type) {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "funasr_nano: ffn gate/up dtype mismatch at layer %d", i);
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "funasr_nano: ffn gate/up dtype mismatch at layer %d", i);
             return TRANSCRIBE_ERR_GGUF;
         }
     }
@@ -417,4 +532,4 @@ transcribe_status build_funasr_nano_weights(ggml_context *             ctx_meta,
 #undef GET_CONV
 #undef GET_LIN
 
-} // namespace transcribe::funasr_nano
+}  // namespace transcribe::funasr_nano
diff --git a/src/arch/funasr_nano/weights.h b/src/arch/funasr_nano/weights.h
index feb7c48e..16e496da 100644
--- a/src/arch/funasr_nano/weights.h
+++ b/src/arch/funasr_nano/weights.h
@@ -45,43 +45,43 @@ namespace transcribe::funasr_nano {
 
 struct FunAsrNanoHParams {
     // Encoder (SenseVoiceEncoderSmall, frozen).
-    int32_t enc_n_blocks       = 0;   // 50; includes the encoders0[0] projection block
-    int32_t enc_tp_blocks      = 0;   // 20
-    int32_t enc_d_model        = 0;   // 512
-    int32_t enc_d_input        = 0;   // 560 = n_mels (80) × lfr_m (7)
-    int32_t enc_n_heads        = 0;   // 4
-    int32_t enc_d_ff           = 0;   // 2048
-    int32_t enc_kernel         = 0;   // 11 (FSMN depthwise conv)
-    int32_t enc_sanm_shift     = 0;   // 0 (left-pad shift for non-causal SAN-M)
-    std::string enc_attn_type;        // "sanm"
+    int32_t     enc_n_blocks   = 0;  // 50; includes the encoders0[0] projection block
+    int32_t     enc_tp_blocks  = 0;  // 20
+    int32_t     enc_d_model    = 0;  // 512
+    int32_t     enc_d_input    = 0;  // 560 = n_mels (80) × lfr_m (7)
+    int32_t     enc_n_heads    = 0;  // 4
+    int32_t     enc_d_ff       = 0;  // 2048
+    int32_t     enc_kernel     = 0;  // 11 (FSMN depthwise conv)
+    int32_t     enc_sanm_shift = 0;  // 0 (left-pad shift for non-causal SAN-M)
+    std::string enc_attn_type;       // "sanm"
     bool        enc_normalize_before = true;
 
     // Audio adaptor (2-layer transformer, frozen).
-    int32_t adaptor_n_blocks      = 0;   // 2
-    int32_t adaptor_encoder_dim   = 0;   // 512
-    int32_t adaptor_llm_dim       = 0;   // 1024
-    int32_t adaptor_pre_ffn_dim   = 0;   // 2048 (linear1 hidden, between encoder→llm projection)
-    int32_t adaptor_block_ffn_dim = 0;   // 256  (per-block PositionwiseFeedForward hidden)
-    int32_t adaptor_n_heads       = 0;   // 8
-    int32_t adaptor_d_head        = 0;   // 128
-    float   adaptor_layer_norm_eps = 1e-12f;
-    std::string adaptor_activation;   // "relu"
-    int32_t adaptor_downsample_rate = 0;   // 1
-    bool    adaptor_use_low_frame_rate = true;
+    int32_t     adaptor_n_blocks       = 0;      // 2
+    int32_t     adaptor_encoder_dim    = 0;      // 512
+    int32_t     adaptor_llm_dim        = 0;      // 1024
+    int32_t     adaptor_pre_ffn_dim    = 0;      // 2048 (linear1 hidden, between encoder→llm projection)
+    int32_t     adaptor_block_ffn_dim  = 0;      // 256  (per-block PositionwiseFeedForward hidden)
+    int32_t     adaptor_n_heads        = 0;      // 8
+    int32_t     adaptor_d_head         = 0;      // 128
+    float       adaptor_layer_norm_eps = 1e-12f;
+    std::string adaptor_activation;              // "relu"
+    int32_t     adaptor_downsample_rate    = 0;  // 1
+    bool        adaptor_use_low_frame_rate = true;
 
     // LLM decoder (Qwen3-0.6B, frozen).
-    int32_t dec_n_layers       = 0;   // 28
-    int32_t dec_hidden         = 0;   // 1024
-    int32_t dec_intermediate   = 0;   // 3072
-    int32_t dec_n_heads        = 0;   // 16
-    int32_t dec_n_kv_heads     = 0;   // 8
-    int32_t dec_head_dim       = 0;   // 128
-    int32_t dec_vocab_size     = 0;   // 151936
-    int32_t dec_max_position_embeddings = 0;   // 40960
-    float   dec_rms_norm_eps   = 0.0f;     // ~1e-6
-    float   dec_rope_theta     = 0.0f;     // 1e6
-    bool    dec_tie_word_embeddings = true;
-    std::string dec_activation; // "silu"
+    int32_t     dec_n_layers                = 0;     // 28
+    int32_t     dec_hidden                  = 0;     // 1024
+    int32_t     dec_intermediate            = 0;     // 3072
+    int32_t     dec_n_heads                 = 0;     // 16
+    int32_t     dec_n_kv_heads              = 0;     // 8
+    int32_t     dec_head_dim                = 0;     // 128
+    int32_t     dec_vocab_size              = 0;     // 151936
+    int32_t     dec_max_position_embeddings = 0;     // 40960
+    float       dec_rms_norm_eps            = 0.0f;  // ~1e-6
+    float       dec_rope_theta              = 0.0f;  // 1e6
+    bool        dec_tie_word_embeddings     = true;
+    std::string dec_activation;                      // "silu"
 
     // Token IDs (resolved via tokenizer).
     int32_t bos_token_id = -1;
@@ -90,25 +90,24 @@ struct FunAsrNanoHParams {
     int32_t vocab_size   = 0;
 
     // Frontend (WavFrontend; kaldi HTK fbank + LFR; no CMVN).
-    std::string fe_type;            // "kaldi_fbank_lfr"
-    int32_t     fe_num_mels    = 0; // 80
-    int32_t     fe_sample_rate = 0; // 16000
-    int32_t     fe_n_fft       = 0; // 400
-    int32_t     fe_win_length  = 0; // 400
-    int32_t     fe_hop_length  = 0; // 160
-    std::string fe_window;          // "hamming"
-    std::string fe_normalize;       // "none"
-    std::string fe_fbank_style;     // "kaldi_htk"
-    float       fe_dither       = 0.0f;
+    std::string fe_type;             // "kaldi_fbank_lfr"
+    int32_t     fe_num_mels    = 0;  // 80
+    int32_t     fe_sample_rate = 0;  // 16000
+    int32_t     fe_n_fft       = 0;  // 400
+    int32_t     fe_win_length  = 0;  // 400
+    int32_t     fe_hop_length  = 0;  // 160
+    std::string fe_window;           // "hamming"
+    std::string fe_normalize;        // "none"
+    std::string fe_fbank_style;      // "kaldi_htk"
+    float       fe_dither          = 0.0f;
     bool        fe_upscale_samples = true;
     bool        fe_snip_edges      = true;
-    int32_t     fe_lfr_m        = 0; // 7
-    int32_t     fe_lfr_n        = 0; // 6
+    int32_t     fe_lfr_m           = 0;  // 7
+    int32_t     fe_lfr_n           = 0;  // 6
     bool        fe_apply_cmvn      = false;
 };
 
-transcribe_status read_funasr_nano_hparams(const gguf_context *  gguf,
-                                           FunAsrNanoHParams &   hp);
+transcribe_status read_funasr_nano_hparams(const gguf_context * gguf, FunAsrNanoHParams & hp);
 
 // ---------------------------------------------------------------------------
 // Weight slots — encoder (SAN-M)
@@ -118,19 +117,19 @@ transcribe_status read_funasr_nano_hparams(const gguf_context *  gguf,
 // encoders, tp_encoders) — only encoders0[0] differs in that its
 // norm_attn and qkv input dim is d_input rather than d_model.
 struct EncBlock {
-    ggml_tensor * norm_attn_w  = nullptr; // [d_in]
-    ggml_tensor * norm_attn_b  = nullptr; // [d_in]
-    ggml_tensor * attn_qkv_w   = nullptr; // [d_in, 3·d_model]   fused QKV
-    ggml_tensor * attn_qkv_b   = nullptr; // [3·d_model]
-    ggml_tensor * attn_out_w   = nullptr; // [d_model, d_model]
-    ggml_tensor * attn_out_b   = nullptr; // [d_model]
-    ggml_tensor * attn_fsmn_w  = nullptr; // [kernel, 1, d_model] depthwise conv1d
-    ggml_tensor * norm_ffn_w   = nullptr; // [d_model]
-    ggml_tensor * norm_ffn_b   = nullptr; // [d_model]
-    ggml_tensor * ffn_fc1_w    = nullptr; // [d_model, d_ff]
-    ggml_tensor * ffn_fc1_b    = nullptr; // [d_ff]
-    ggml_tensor * ffn_fc2_w    = nullptr; // [d_ff, d_model]
-    ggml_tensor * ffn_fc2_b    = nullptr; // [d_model]
+    ggml_tensor * norm_attn_w = nullptr;  // [d_in]
+    ggml_tensor * norm_attn_b = nullptr;  // [d_in]
+    ggml_tensor * attn_qkv_w  = nullptr;  // [d_in, 3·d_model]   fused QKV
+    ggml_tensor * attn_qkv_b  = nullptr;  // [3·d_model]
+    ggml_tensor * attn_out_w  = nullptr;  // [d_model, d_model]
+    ggml_tensor * attn_out_b  = nullptr;  // [d_model]
+    ggml_tensor * attn_fsmn_w = nullptr;  // [kernel, 1, d_model] depthwise conv1d
+    ggml_tensor * norm_ffn_w  = nullptr;  // [d_model]
+    ggml_tensor * norm_ffn_b  = nullptr;  // [d_model]
+    ggml_tensor * ffn_fc1_w   = nullptr;  // [d_model, d_ff]
+    ggml_tensor * ffn_fc1_b   = nullptr;  // [d_ff]
+    ggml_tensor * ffn_fc2_w   = nullptr;  // [d_ff, d_model]
+    ggml_tensor * ffn_fc2_b   = nullptr;  // [d_model]
 };
 
 // ---------------------------------------------------------------------------
@@ -141,25 +140,25 @@ struct EncBlock {
 // LayerNorm eps = 1e-12 (matches adaptor.layer_norm_eps KV).
 struct AdaptorBlock {
     // norm1
-    ggml_tensor * norm_attn_w  = nullptr; // [llm_dim]
-    ggml_tensor * norm_attn_b  = nullptr; // [llm_dim]
+    ggml_tensor * norm_attn_w = nullptr;  // [llm_dim]
+    ggml_tensor * norm_attn_b = nullptr;  // [llm_dim]
     // self-attention (separate q/k/v with biases — plain MultiHeadedAttention)
-    ggml_tensor * attn_q_w     = nullptr; // [llm_dim, llm_dim]
-    ggml_tensor * attn_q_b     = nullptr; // [llm_dim]
-    ggml_tensor * attn_k_w     = nullptr; // [llm_dim, llm_dim]
-    ggml_tensor * attn_k_b     = nullptr; // [llm_dim]
-    ggml_tensor * attn_v_w     = nullptr; // [llm_dim, llm_dim]
-    ggml_tensor * attn_v_b     = nullptr; // [llm_dim]
-    ggml_tensor * attn_out_w   = nullptr; // [llm_dim, llm_dim]
-    ggml_tensor * attn_out_b   = nullptr; // [llm_dim]
+    ggml_tensor * attn_q_w    = nullptr;  // [llm_dim, llm_dim]
+    ggml_tensor * attn_q_b    = nullptr;  // [llm_dim]
+    ggml_tensor * attn_k_w    = nullptr;  // [llm_dim, llm_dim]
+    ggml_tensor * attn_k_b    = nullptr;  // [llm_dim]
+    ggml_tensor * attn_v_w    = nullptr;  // [llm_dim, llm_dim]
+    ggml_tensor * attn_v_b    = nullptr;  // [llm_dim]
+    ggml_tensor * attn_out_w  = nullptr;  // [llm_dim, llm_dim]
+    ggml_tensor * attn_out_b  = nullptr;  // [llm_dim]
     // norm2
-    ggml_tensor * norm_ffn_w   = nullptr; // [llm_dim]
-    ggml_tensor * norm_ffn_b   = nullptr; // [llm_dim]
+    ggml_tensor * norm_ffn_w  = nullptr;  // [llm_dim]
+    ggml_tensor * norm_ffn_b  = nullptr;  // [llm_dim]
     // PositionwiseFeedForward: w_1 → ReLU → w_2 (with biases)
-    ggml_tensor * ffn_fc1_w    = nullptr; // [llm_dim, block_ffn_dim]
-    ggml_tensor * ffn_fc1_b    = nullptr; // [block_ffn_dim]
-    ggml_tensor * ffn_fc2_w    = nullptr; // [block_ffn_dim, llm_dim]
-    ggml_tensor * ffn_fc2_b    = nullptr; // [llm_dim]
+    ggml_tensor * ffn_fc1_w   = nullptr;  // [llm_dim, block_ffn_dim]
+    ggml_tensor * ffn_fc1_b   = nullptr;  // [block_ffn_dim]
+    ggml_tensor * ffn_fc2_w   = nullptr;  // [block_ffn_dim, llm_dim]
+    ggml_tensor * ffn_fc2_b   = nullptr;  // [llm_dim]
 };
 
 struct AdaptorWeights {
@@ -182,17 +181,17 @@ struct DecEmbed {
 };
 
 struct DecBlock {
-    ggml_tensor * norm_attn_w = nullptr;  // input_layernorm (RMSNorm, no bias)
-    ggml_tensor * norm_ffn_w  = nullptr;  // post_attention_layernorm
-    ggml_tensor * attn_q_w    = nullptr;  // [hidden, n_heads * head_dim]
-    ggml_tensor * attn_k_w    = nullptr;  // [hidden, n_kv_heads * head_dim]
-    ggml_tensor * attn_v_w    = nullptr;  // [hidden, n_kv_heads * head_dim]
-    ggml_tensor * attn_o_w    = nullptr;  // [n_heads * head_dim, hidden]
-    ggml_tensor * attn_q_norm = nullptr;  // [head_dim]
-    ggml_tensor * attn_k_norm = nullptr;  // [head_dim]
-    ggml_tensor * ffn_gate_w  = nullptr;  // [hidden, intermediate]
-    ggml_tensor * ffn_up_w    = nullptr;  // [hidden, intermediate]
-    ggml_tensor * ffn_down_w  = nullptr;  // [intermediate, hidden]
+    ggml_tensor * norm_attn_w   = nullptr;  // input_layernorm (RMSNorm, no bias)
+    ggml_tensor * norm_ffn_w    = nullptr;  // post_attention_layernorm
+    ggml_tensor * attn_q_w      = nullptr;  // [hidden, n_heads * head_dim]
+    ggml_tensor * attn_k_w      = nullptr;  // [hidden, n_kv_heads * head_dim]
+    ggml_tensor * attn_v_w      = nullptr;  // [hidden, n_kv_heads * head_dim]
+    ggml_tensor * attn_o_w      = nullptr;  // [n_heads * head_dim, hidden]
+    ggml_tensor * attn_q_norm   = nullptr;  // [head_dim]
+    ggml_tensor * attn_k_norm   = nullptr;  // [head_dim]
+    ggml_tensor * ffn_gate_w    = nullptr;  // [hidden, intermediate]
+    ggml_tensor * ffn_up_w      = nullptr;  // [hidden, intermediate]
+    ggml_tensor * ffn_down_w    = nullptr;  // [intermediate, hidden]
     // Packed gate+up [hidden, 2*intermediate], filled at load time.
     ggml_tensor * ffn_gate_up_w = nullptr;
 };
@@ -203,8 +202,8 @@ struct DecFinal {
 
 struct FunAsrNanoWeights {
     // Encoder.
-    EncBlock              encoders0;       // single 560 → 512 projection block
-    std::vector<EncBlock> encoders;        // n_blocks - 1 blocks at d_model
+    EncBlock              encoders0;  // single 560 → 512 projection block
+    std::vector<EncBlock> encoders;   // n_blocks - 1 blocks at d_model
     ggml_tensor *         after_norm_w = nullptr;
     ggml_tensor *         after_norm_b = nullptr;
     std::vector<EncBlock> tp_encoders;
@@ -220,8 +219,8 @@ struct FunAsrNanoWeights {
     DecFinal              dec_final;
 };
 
-transcribe_status build_funasr_nano_weights(ggml_context *             ctx_meta,
-                                            const FunAsrNanoHParams &  hp,
-                                            FunAsrNanoWeights &        weights);
+transcribe_status build_funasr_nano_weights(ggml_context *            ctx_meta,
+                                            const FunAsrNanoHParams & hp,
+                                            FunAsrNanoWeights &       weights);
 
-} // namespace transcribe::funasr_nano
+}  // namespace transcribe::funasr_nano
diff --git a/src/arch/gigaam/capabilities.cpp b/src/arch/gigaam/capabilities.cpp
index f4aa0db4..d178074e 100644
--- a/src/arch/gigaam/capabilities.cpp
+++ b/src/arch/gigaam/capabilities.cpp
@@ -30,4 +30,4 @@ void apply_family_invariants(transcribe_model & model) {
     transcribe::set_feature(&model, TRANSCRIBE_FEATURE_CANCELLATION, true);
 }
 
-} // namespace transcribe::gigaam
+}  // namespace transcribe::gigaam
diff --git a/src/arch/gigaam/decoder.cpp b/src/arch/gigaam/decoder.cpp
index 6412a062..5db58d87 100644
--- a/src/arch/gigaam/decoder.cpp
+++ b/src/arch/gigaam/decoder.cpp
@@ -9,20 +9,19 @@
 
 #include "decoder.h"
 
+#include "ggml-backend.h"
+#include "ggml.h"
 #include "gigaam.h"
 #include "transcribe-debug.h"
 #include "transcribe-log.h"
 #include "weights.h"
 
-#include "ggml.h"
-#include "ggml-backend.h"
-
 #if TRANSCRIBE_HAS_BLAS
-#  ifdef __APPLE__
-#    include <Accelerate/Accelerate.h>
-#  else
-#    include <cblas.h>
-#  endif
+#    ifdef __APPLE__
+#        include <Accelerate/Accelerate.h>
+#    else
+#        include <cblas.h>
+#    endif
 #endif
 
 #include <algorithm>
@@ -46,7 +45,9 @@ void readback_f32(const ggml_tensor * t, std::vector<float> & out) {
     }
     const size_t n = static_cast<size_t>(ggml_nelements(t));
     out.assign(n, 0.0f);
-    if (n == 0) return;
+    if (n == 0) {
+        return;
+    }
 
     if (t->type == GGML_TYPE_F32) {
         ggml_backend_tensor_get(t, out.data(), 0, n * sizeof(float));
@@ -55,13 +56,12 @@ void readback_f32(const ggml_tensor * t, std::vector<float> & out) {
 
     const auto * tt = ggml_get_type_traits(t->type);
     if (tt == nullptr || tt->to_float == nullptr) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "gigaam decoder: tensor \"%s\" type %s has no to_float",
-                     t->name, ggml_type_name(t->type));
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "gigaam decoder: tensor \"%s\" type %s has no to_float", t->name,
+                ggml_type_name(t->type));
         out.clear();
         return;
     }
-    const size_t nbytes = ggml_nbytes(t);
+    const size_t         nbytes = ggml_nbytes(t);
     std::vector<uint8_t> raw(nbytes);
     ggml_backend_tensor_get(t, raw.data(), 0, nbytes);
     tt->to_float(raw.data(), out.data(), static_cast<int64_t>(n));
@@ -73,15 +73,9 @@ inline float sigmoidf(float x) {
 
 // y = W @ x + b, where W is [out, in] row-major (numpy shape), x is
 // [in], b is [out]. b may be nullptr to skip the add.
-void matvec_add(const float * W,
-                const float * b,
-                const float * x,
-                int           out,
-                int           in_dim,
-                float *       y)
-{
+void matvec_add(const float * W, const float * b, const float * x, int out, int in_dim, float * y) {
     for (int i = 0; i < out; ++i) {
-        float acc = (b != nullptr) ? b[i] : 0.0f;
+        float         acc = (b != nullptr) ? b[i] : 0.0f;
         const float * row = W + static_cast<size_t>(i) * in_dim;
         for (int j = 0; j < in_dim; ++j) {
             acc += row[j] * x[j];
@@ -90,18 +84,17 @@ void matvec_add(const float * W,
     }
 }
 
-} // namespace
+}  // namespace
 
 // Build host buffers for the predictor + joint weights. Reads back from
 // the backend exactly once at load time; the decode loop then iterates
 // the host floats.
 transcribe_status build_host_decoder_weights(const GigaamWeights & w,
                                              const GigaamHParams & hp,
-                                             HostDecoderWeights &  out)
-{
+                                             HostDecoderWeights &  out) {
     if (hp.head_kind == HeadKind::CTC) {
         readback_f32(w.ctc_head.weight, out.ctc_w);
-        readback_f32(w.ctc_head.bias,   out.ctc_b);
+        readback_f32(w.ctc_head.bias, out.ctc_b);
         return TRANSCRIBE_OK;
     }
     // RNN-T.
@@ -112,14 +105,14 @@ transcribe_status build_host_decoder_weights(const GigaamWeights & w,
     for (int i = 0; i < hp.pred_n_layers; ++i) {
         readback_f32(w.predictor.lstm[i].Wx, out.lstm_Wx[i]);
         readback_f32(w.predictor.lstm[i].Wh, out.lstm_Wh[i]);
-        readback_f32(w.predictor.lstm[i].b,  out.lstm_b[i]);
+        readback_f32(w.predictor.lstm[i].b, out.lstm_b[i]);
     }
-    readback_f32(w.joint.enc_w,  out.joint_enc_w);
-    readback_f32(w.joint.enc_b,  out.joint_enc_b);
+    readback_f32(w.joint.enc_w, out.joint_enc_w);
+    readback_f32(w.joint.enc_b, out.joint_enc_b);
     readback_f32(w.joint.pred_w, out.joint_pred_w);
     readback_f32(w.joint.pred_b, out.joint_pred_b);
-    readback_f32(w.joint.out_w,  out.joint_out_w);
-    readback_f32(w.joint.out_b,  out.joint_out_b);
+    readback_f32(w.joint.out_w, out.joint_out_w);
+    readback_f32(w.joint.out_b, out.joint_out_b);
     return TRANSCRIBE_OK;
 }
 
@@ -141,11 +134,10 @@ static void lstm_step(const float * x,
                       int           H,
                       float *       h_out,
                       float *       c_out,
-                      float *       scratch_gates)
-{
+                      float *       scratch_gates) {
     // scratch_gates: [4*H]. Compute Wx @ x + Wh @ h_prev + b in place.
     for (int i = 0; i < 4 * H; ++i) {
-        float acc = b[i];
+        float         acc    = b[i];
         const float * wx_row = Wx + static_cast<size_t>(i) * H;
         const float * wh_row = Wh + static_cast<size_t>(i) * H;
         for (int j = 0; j < H; ++j) {
@@ -160,13 +152,13 @@ static void lstm_step(const float * x,
     const float * go = scratch_gates + 3 * H;
 
     for (int j = 0; j < H; ++j) {
-        const float i_t = sigmoidf(gi[j]);
-        const float f_t = sigmoidf(gf[j]);
-        const float g_t = std::tanh(gg[j]);
-        const float o_t = sigmoidf(go[j]);
+        const float i_t   = sigmoidf(gi[j]);
+        const float f_t   = sigmoidf(gf[j]);
+        const float g_t   = std::tanh(gg[j]);
+        const float o_t   = sigmoidf(go[j]);
         const float c_new = f_t * c_prev[j] + i_t * g_t;
-        c_out[j] = c_new;
-        h_out[j] = o_t * std::tanh(c_new);
+        c_out[j]          = c_new;
+        h_out[j]          = o_t * std::tanh(c_new);
     }
 }
 
@@ -178,31 +170,25 @@ static void lstm_step(const float * x,
 //
 // Returns the argmax token id.
 static int joint_argmax(const HostDecoderWeights & h,
-                        const float *              enc_proj, // [joint_h]
-                        const float *              g_t,      // [pred_hidden]
+                        const float *              enc_proj,  // [joint_h]
+                        const float *              g_t,       // [pred_hidden]
                         int                        pred_d,
                         int                        joint_h,
                         int                        n_classes,
-                        std::vector<float> &       scratch_join, // size joint_h
-                        std::vector<float> &       scratch_logits)
-{
+                        std::vector<float> &       scratch_join,  // size joint_h
+                        std::vector<float> &       scratch_logits) {
     scratch_join.assign(joint_h, 0.0f);
     scratch_logits.assign(n_classes, 0.0f);
 
     // pred_proj into scratch_join, then fuse `+ enc_proj` and ReLU.
-    matvec_add(h.joint_pred_w.data(),
-               h.joint_pred_b.data(),
-               g_t, joint_h, pred_d,
-               scratch_join.data());
+    matvec_add(h.joint_pred_w.data(), h.joint_pred_b.data(), g_t, joint_h, pred_d, scratch_join.data());
     for (int i = 0; i < joint_h; ++i) {
-        float v = scratch_join[i] + enc_proj[i];
+        float v         = scratch_join[i] + enc_proj[i];
         scratch_join[i] = v > 0.0f ? v : 0.0f;
     }
     // logits = out_w @ relu + out_b. The reference applies log_softmax
     // but argmax is invariant under it, so we skip.
-    matvec_add(h.joint_out_w.data(),
-               h.joint_out_b.data(),
-               scratch_join.data(), n_classes, joint_h,
+    matvec_add(h.joint_out_w.data(), h.joint_out_b.data(), scratch_join.data(), n_classes, joint_h,
                scratch_logits.data());
 
     int   best_idx = 0;
@@ -229,8 +215,7 @@ transcribe_status decode_rnnt_greedy(const HostDecoderWeights & host,
                                      int                        T_enc,
                                      int                        max_symbols_per_step,
                                      std::vector<int> &         out_tokens,
-                                     std::vector<int> &         out_frames)
-{
+                                     std::vector<int> &         out_frames) {
     out_tokens.clear();
     out_frames.clear();
 
@@ -244,24 +229,22 @@ transcribe_status decode_rnnt_greedy(const HostDecoderWeights & host,
     // (or a fallback loop). The joint's enc_w @ f_t + enc_b is independent
     // of decode state, so hoisting it out of the inner loop eliminates
     // O(iters) redundant matvecs and gives BLAS a single large matrix.
-    std::vector<float> enc_proj_all(
-        static_cast<size_t>(T_enc) * static_cast<size_t>(joint_h));
+    std::vector<float> enc_proj_all(static_cast<size_t>(T_enc) * static_cast<size_t>(joint_h));
 #if TRANSCRIBE_HAS_BLAS
-    cblas_sgemm(CblasRowMajor, CblasNoTrans, CblasTrans,
-                T_enc, joint_h, enc_d,
-                1.0f, encoded, enc_d,
-                host.joint_enc_w.data(), enc_d,
-                0.0f, enc_proj_all.data(), joint_h);
+    cblas_sgemm(CblasRowMajor, CblasNoTrans, CblasTrans, T_enc, joint_h, enc_d, 1.0f, encoded, enc_d,
+                host.joint_enc_w.data(), enc_d, 0.0f, enc_proj_all.data(), joint_h);
 #else
     for (int t = 0; t < T_enc; ++t) {
         const float * frame = encoded + static_cast<size_t>(t) * enc_d;
-        float * proj = enc_proj_all.data() + static_cast<size_t>(t) * joint_h;
+        float *       proj  = enc_proj_all.data() + static_cast<size_t>(t) * joint_h;
         matvec_add(host.joint_enc_w.data(), nullptr, frame, joint_h, enc_d, proj);
     }
 #endif
     for (int t = 0; t < T_enc; ++t) {
         float * proj = enc_proj_all.data() + static_cast<size_t>(t) * joint_h;
-        for (int j = 0; j < joint_h; ++j) proj[j] += host.joint_enc_b[j];
+        for (int j = 0; j < joint_h; ++j) {
+            proj[j] += host.joint_enc_b[j];
+        }
     }
 
     std::vector<float> h_cur(H, 0.0f);
@@ -269,11 +252,11 @@ transcribe_status decode_rnnt_greedy(const HostDecoderWeights & host,
     std::vector<float> h_next(H, 0.0f);
     std::vector<float> c_next(H, 0.0f);
     std::vector<float> gates(4 * H, 0.0f);
-    std::vector<float> pred_in(H, 0.0f);   // embed lookup output
+    std::vector<float> pred_in(H, 0.0f);  // embed lookup output
     std::vector<float> jh(joint_h, 0.0f);
     std::vector<float> logits(n_class, 0.0f);
 
-    bool fresh = true; // first step uses zero input + zero state (reference predict(None, None))
+    bool fresh = true;  // first step uses zero input + zero state (reference predict(None, None))
 
     // Predictor-dirty cache: on a blank emission `(prev_token, h_cur, c_cur)`
     // are unchanged, so the next LSTM step would deterministically produce
@@ -283,8 +266,7 @@ transcribe_status decode_rnnt_greedy(const HostDecoderWeights & host,
     bool predictor_dirty = true;
 
     for (int t = 0; t < T_enc; ++t) {
-        const float * enc_proj = enc_proj_all.data() +
-                                 static_cast<size_t>(t) * joint_h;
+        const float * enc_proj = enc_proj_all.data() + static_cast<size_t>(t) * joint_h;
 
         int sym_count = 0;
         for (;;) {
@@ -293,25 +275,15 @@ transcribe_status decode_rnnt_greedy(const HostDecoderWeights & host,
                     std::fill(pred_in.begin(), pred_in.end(), 0.0f);
                 } else {
                     const int prev = out_tokens.back();
-                    std::memcpy(pred_in.data(),
-                                host.pred_embed.data() +
-                                    static_cast<size_t>(prev) * H,
+                    std::memcpy(pred_in.data(), host.pred_embed.data() + static_cast<size_t>(prev) * H,
                                 H * sizeof(float));
                 }
-                lstm_step(pred_in.data(),
-                          h_cur.data(), c_cur.data(),
-                          host.lstm_Wx[0].data(),
-                          host.lstm_Wh[0].data(),
-                          host.lstm_b[0].data(),
-                          H,
-                          h_next.data(), c_next.data(),
-                          gates.data());
+                lstm_step(pred_in.data(), h_cur.data(), c_cur.data(), host.lstm_Wx[0].data(), host.lstm_Wh[0].data(),
+                          host.lstm_b[0].data(), H, h_next.data(), c_next.data(), gates.data());
                 predictor_dirty = false;
             }
 
-            const int tok = joint_argmax(host, enc_proj, h_next.data(),
-                                          H, joint_h, n_class,
-                                          jh, logits);
+            const int tok = joint_argmax(host, enc_proj, h_next.data(), H, joint_h, n_class, jh, logits);
 
             if (tok == blank_id) {
                 // Advance time. Do NOT commit state. Predictor stays clean.
@@ -320,9 +292,9 @@ transcribe_status decode_rnnt_greedy(const HostDecoderWeights & host,
             // Emit token; commit state.
             out_tokens.push_back(tok);
             out_frames.push_back(t);
-            h_cur = h_next;
-            c_cur = c_next;
-            fresh = false;
+            h_cur           = h_next;
+            c_cur           = c_next;
+            fresh           = false;
             predictor_dirty = true;
             ++sym_count;
             if (max_symbols_per_step > 0 && sym_count >= max_symbols_per_step) {
@@ -344,8 +316,7 @@ transcribe_status decode_ctc_greedy(const HostDecoderWeights & host,
                                     const float *              encoded,
                                     int                        T_enc,
                                     std::vector<int> &         out_tokens,
-                                    std::vector<int> &         out_frames)
-{
+                                    std::vector<int> &         out_frames) {
     out_tokens.clear();
     out_frames.clear();
 
@@ -357,41 +328,37 @@ transcribe_status decode_ctc_greedy(const HostDecoderWeights & host,
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
     if (static_cast<int>(host.ctc_w.size()) != n_classes * d_model ||
-        static_cast<int>(host.ctc_b.size()) != n_classes)
-    {
+        static_cast<int>(host.ctc_b.size()) != n_classes) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "gigaam decoder (ctc): host head shape mismatch "
-                     "(ctc_w=%zu expected=%d, ctc_b=%zu expected=%d)",
-                     host.ctc_w.size(), n_classes * d_model,
-                     host.ctc_b.size(), n_classes);
+                "gigaam decoder (ctc): host head shape mismatch "
+                "(ctc_w=%zu expected=%d, ctc_b=%zu expected=%d)",
+                host.ctc_w.size(), n_classes * d_model, host.ctc_b.size(), n_classes);
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
 
     // logits[T_enc, n_classes] row-major.
-    std::vector<float> logits(
-        static_cast<size_t>(T_enc) * static_cast<size_t>(n_classes), 0.0f);
+    std::vector<float> logits(static_cast<size_t>(T_enc) * static_cast<size_t>(n_classes), 0.0f);
     for (int t = 0; t < T_enc; ++t) {
         const float * frame = encoded + static_cast<size_t>(t) * d_model;
-        float * row = logits.data() + static_cast<size_t>(t) * n_classes;
-        matvec_add(host.ctc_w.data(), host.ctc_b.data(),
-                   frame, n_classes, d_model, row);
+        float *       row   = logits.data() + static_cast<size_t>(t) * n_classes;
+        matvec_add(host.ctc_w.data(), host.ctc_b.data(), frame, n_classes, d_model, row);
     }
 
     // Raw logits before log_softmax, [T_enc, n_classes] row-major.
     if (transcribe::debug::enabled()) {
         const long long shape[2] = { T_enc, n_classes };
-        transcribe::debug::dump_host_f32(
-            "ctc.logits.raw", logits.data(),
-            static_cast<long long>(logits.size()),
-            shape, 2, "decoder.ctc.logits_raw");
+        transcribe::debug::dump_host_f32("ctc.logits.raw", logits.data(), static_cast<long long>(logits.size()), shape,
+                                         2, "decoder.ctc.logits_raw");
     }
 
     // Per-frame log_softmax in place.
     for (int t = 0; t < T_enc; ++t) {
-        float * row = logits.data() + static_cast<size_t>(t) * n_classes;
-        float max_v = row[0];
+        float * row   = logits.data() + static_cast<size_t>(t) * n_classes;
+        float   max_v = row[0];
         for (int c = 1; c < n_classes; ++c) {
-            if (row[c] > max_v) max_v = row[c];
+            if (row[c] > max_v) {
+                max_v = row[c];
+            }
         }
         double sum = 0.0;
         for (int c = 0; c < n_classes; ++c) {
@@ -405,24 +372,29 @@ transcribe_status decode_ctc_greedy(const HostDecoderWeights & host,
 
     if (transcribe::debug::enabled()) {
         const long long shape[2] = { T_enc, n_classes };
-        transcribe::debug::dump_host_f32(
-            "ctc.log_probs", logits.data(),
-            static_cast<long long>(logits.size()),
-            shape, 2, "decoder.ctc.log_probs");
+        transcribe::debug::dump_host_f32("ctc.log_probs", logits.data(), static_cast<long long>(logits.size()), shape,
+                                         2, "decoder.ctc.log_probs");
     }
 
     // Greedy collapse: drop runs of the same label, then drop blanks.
     int prev_label = -1;
     for (int t = 0; t < T_enc; ++t) {
-        const float * row = logits.data() + static_cast<size_t>(t) * n_classes;
-        int   best = 0;
-        float best_v = row[0];
+        const float * row    = logits.data() + static_cast<size_t>(t) * n_classes;
+        int           best   = 0;
+        float         best_v = row[0];
         for (int c = 1; c < n_classes; ++c) {
-            if (row[c] > best_v) { best_v = row[c]; best = c; }
+            if (row[c] > best_v) {
+                best_v = row[c];
+                best   = c;
+            }
+        }
+        if (best == prev_label) {
+            continue;  // run-length collapse
         }
-        if (best == prev_label) continue; // run-length collapse
         prev_label = best;
-        if (best == blank_id) continue;
+        if (best == blank_id) {
+            continue;
+        }
         out_tokens.push_back(best);
         out_frames.push_back(t);
     }
@@ -430,4 +402,4 @@ transcribe_status decode_ctc_greedy(const HostDecoderWeights & host,
     return TRANSCRIBE_OK;
 }
 
-} // namespace transcribe::gigaam
+}  // namespace transcribe::gigaam
diff --git a/src/arch/gigaam/decoder.h b/src/arch/gigaam/decoder.h
index 29b7d0e2..dd980c46 100644
--- a/src/arch/gigaam/decoder.h
+++ b/src/arch/gigaam/decoder.h
@@ -21,19 +21,19 @@ struct GigaamHParams;
 // that.
 struct HostDecoderWeights {
     // RNN-T fields.
-    std::vector<float> pred_embed;         // [pred_vocab, pred_hidden]
-    std::vector<std::vector<float>> lstm_Wx; // per layer
+    std::vector<float>              pred_embed;  // [pred_vocab, pred_hidden]
+    std::vector<std::vector<float>> lstm_Wx;     // per layer
     std::vector<std::vector<float>> lstm_Wh;
     std::vector<std::vector<float>> lstm_b;
-    std::vector<float> joint_enc_w;
-    std::vector<float> joint_enc_b;
-    std::vector<float> joint_pred_w;
-    std::vector<float> joint_pred_b;
-    std::vector<float> joint_out_w;
-    std::vector<float> joint_out_b;
+    std::vector<float>              joint_enc_w;
+    std::vector<float>              joint_enc_b;
+    std::vector<float>              joint_pred_w;
+    std::vector<float>              joint_pred_b;
+    std::vector<float>              joint_out_w;
+    std::vector<float>              joint_out_b;
     // CTC fields.
-    std::vector<float> ctc_w;              // [n_classes, d_model]
-    std::vector<float> ctc_b;
+    std::vector<float>              ctc_w;  // [n_classes, d_model]
+    std::vector<float>              ctc_b;
 };
 
 // Read the predictor + joint (or CTC head) tensors from backend memory
@@ -67,4 +67,4 @@ transcribe_status decode_ctc_greedy(const HostDecoderWeights & host,
                                     std::vector<int> &         out_tokens,
                                     std::vector<int> &         out_frames);
 
-} // namespace transcribe::gigaam
+}  // namespace transcribe::gigaam
diff --git a/src/arch/gigaam/encoder.cpp b/src/arch/gigaam/encoder.cpp
index 529d6b05..53378026 100644
--- a/src/arch/gigaam/encoder.cpp
+++ b/src/arch/gigaam/encoder.cpp
@@ -7,17 +7,15 @@
 
 #include "encoder.h"
 
-#include "weights.h"
-
 #include "conformer/conformer.h"
+#include "ggml.h"
 #include "transcribe-debug.h"
 #include "transcribe-log.h"
+#include "weights.h"
 
-#include "ggml.h"
-
+#include <cmath>
 #include <cstdio>
 #include <cstdlib>
-#include <cmath>
 #include <vector>
 
 namespace transcribe::gigaam {
@@ -32,14 +30,14 @@ namespace conf = transcribe::conformer;
 // `conf::conv_module` reads.
 conf::BlockView to_conv_view(const GigaamBlock & b) {
     conf::BlockView v;
-    v.conv_pw1_w  = b.conv_pw1_w;
-    v.conv_pw1_b  = b.conv_pw1_b;
-    v.conv_dw_w   = b.conv_dw_w;
-    v.conv_dw_b   = b.conv_dw_b;
-    v.conv_pw2_w  = b.conv_pw2_w;
-    v.conv_pw2_b  = b.conv_pw2_b;
-    v.conv_ln_w   = b.conv_ln_w;
-    v.conv_ln_b   = b.conv_ln_b;
+    v.conv_pw1_w = b.conv_pw1_w;
+    v.conv_pw1_b = b.conv_pw1_b;
+    v.conv_dw_w  = b.conv_dw_w;
+    v.conv_dw_b  = b.conv_dw_b;
+    v.conv_pw2_w = b.conv_pw2_w;
+    v.conv_pw2_b = b.conv_pw2_b;
+    v.conv_ln_w  = b.conv_ln_w;
+    v.conv_ln_b  = b.conv_ln_b;
     return v;
 }
 
@@ -69,9 +67,8 @@ ggml_tensor * build_pre_encode(ggml_context *          ctx,
                                ggml_tensor *           mel_in,
                                int                     subs_kernel_size,
                                const char *            name_prefix,
-                               const PreEncodeMasks *  masks = nullptr)
-{
-    const int padding = (subs_kernel_size - 1) / 2; // sym pad, e.g. k=5 -> 2
+                               const PreEncodeMasks *  masks = nullptr) {
+    const int padding = (subs_kernel_size - 1) / 2;  // sym pad, e.g. k=5 -> 2
 
     // Conv 0: in=feat_in, out=d_model. Output ne=[T_out, d_model, B].
     ggml_tensor * x = conf::conv_1d_f32(ctx, pe.conv0_w, mel_in,
@@ -79,7 +76,7 @@ ggml_tensor * build_pre_encode(ggml_context *          ctx,
     {
         // Bias on the OC axis (ne[1]); broadcasts over time + batch.
         ggml_tensor * bias_r = ggml_reshape_3d(ctx, pe.conv0_b, 1, x->ne[1], 1);
-        x = ggml_add(ctx, x, bias_r);
+        x                    = ggml_add(ctx, x, bias_r);
     }
     x = ggml_relu(ctx, x);
     if (masks != nullptr && masks->mask_s1 != nullptr) {
@@ -92,7 +89,7 @@ ggml_tensor * build_pre_encode(ggml_context *          ctx,
                           /*stride=*/2, padding, /*dilation=*/1);
     {
         ggml_tensor * bias_r = ggml_reshape_3d(ctx, pe.conv2_b, 1, x->ne[1], 1);
-        x = ggml_add(ctx, x, bias_r);
+        x                    = ggml_add(ctx, x, bias_r);
     }
     x = ggml_relu(ctx, x);
     if (masks != nullptr && masks->mask_s2 != nullptr) {
@@ -127,8 +124,7 @@ ggml_tensor * build_rotary_attn(ggml_context *      ctx,
                                 int                 d_model,
                                 int                 n_head,
                                 bool                use_flash,
-                                ggml_tensor *       attn_pad_mask = nullptr)
-{
+                                ggml_tensor *       attn_pad_mask = nullptr) {
     const int     head_dim = d_model / n_head;
     const float   scale    = 1.0f / std::sqrt(static_cast<float>(head_dim));
     const int64_t T        = x->ne[1];
@@ -149,27 +145,32 @@ ggml_tensor * build_rotary_attn(ggml_context *      ctx,
     // GigaAM passes pos_emb_max_len (default 5000) as the rotary `base`
     // (theta), NOT the standard 10000: the dumped enc.pos_emb tensor matches
     // base=5000 to ~1e-6 and base=10000 is off by ~0.1.
-    x_rot = ggml_rope_ext(ctx, x_rot, positions, /*c=*/nullptr,
-                          /*n_dims=*/head_dim,
-                          GGML_ROPE_TYPE_NEOX,
-                          /*n_ctx_orig=*/0,
-                          /*theta=*/5000.0f,
-                          /*freq_scale=*/1.0f,
-                          /*ext_factor=*/0.0f,
-                          /*attn_factor=*/1.0f,
-                          /*beta_fast=*/32.0f,
-                          /*beta_slow=*/1.0f);
+    x_rot               = ggml_rope_ext(ctx, x_rot, positions, /*c=*/nullptr,
+                                        /*n_dims=*/head_dim, GGML_ROPE_TYPE_NEOX,
+                                        /*n_ctx_orig=*/0,
+                                        /*theta=*/5000.0f,
+                                        /*freq_scale=*/1.0f,
+                                        /*ext_factor=*/0.0f,
+                                        /*attn_factor=*/1.0f,
+                                        /*beta_fast=*/32.0f,
+                                        /*beta_slow=*/1.0f);
     // Fold heads back to [d_model, T, B] for the Wq/Wk projection.
-    x_rot = ggml_cont(ctx, ggml_reshape_3d(ctx, x_rot, d_model, T, Bb));
+    x_rot               = ggml_cont(ctx, ggml_reshape_3d(ctx, x_rot, d_model, T, Bb));
 
     // Wq, Wk on the rotated input; Wv on the original x. mul_mat broadcasts
     // the weight across the batch axis (ne[2]); outputs stay [d_model, T, B].
     ggml_tensor * q = ggml_mul_mat(ctx, b.attn_q_w, x_rot);
-    if (b.attn_q_b != nullptr) q = ggml_add(ctx, q, b.attn_q_b);
+    if (b.attn_q_b != nullptr) {
+        q = ggml_add(ctx, q, b.attn_q_b);
+    }
     ggml_tensor * k = ggml_mul_mat(ctx, b.attn_k_w, x_rot);
-    if (b.attn_k_b != nullptr) k = ggml_add(ctx, k, b.attn_k_b);
+    if (b.attn_k_b != nullptr) {
+        k = ggml_add(ctx, k, b.attn_k_b);
+    }
     ggml_tensor * v = ggml_mul_mat(ctx, b.attn_v_w, x);
-    if (b.attn_v_b != nullptr) v = ggml_add(ctx, v, b.attn_v_b);
+    if (b.attn_v_b != nullptr) {
+        v = ggml_add(ctx, v, b.attn_v_b);
+    }
 
     // Reshape for SDPA. Target layout: [head_dim, T, n_head, B]. The head
     // split lands n_head at ne[1] and the utterance batch at ne[3], so the
@@ -186,8 +187,7 @@ ggml_tensor * build_rotary_attn(ggml_context *      ctx,
 
     ggml_tensor * o;
     if (flash) {
-        o = ggml_flash_attn_ext(ctx, q, k, v, /*mask=*/nullptr,
-                                scale, 0.0f, 0.0f);
+        o = ggml_flash_attn_ext(ctx, q, k, v, /*mask=*/nullptr, scale, 0.0f, 0.0f);
         // ggml_flash_attn_ext returns [head_dim, n_head, T, B].
         o = ggml_permute(ctx, o, 0, 2, 1, 3);
         o = ggml_cont(ctx, o);
@@ -199,10 +199,9 @@ ggml_tensor * build_rotary_attn(ggml_context *      ctx,
         if (attn_pad_mask != nullptr) {
             kq = ggml_add(ctx, kq, attn_pad_mask);
         }
-        ggml_tensor * kq_soft = ggml_soft_max_ext(ctx, kq, /*mask=*/nullptr,
-                                                  scale, 0.0f);
-        ggml_tensor * v_t = ggml_cont(ctx, ggml_permute(ctx, v, 1, 0, 2, 3));
-        o = ggml_mul_mat(ctx, v_t, kq_soft);
+        ggml_tensor * kq_soft = ggml_soft_max_ext(ctx, kq, /*mask=*/nullptr, scale, 0.0f);
+        ggml_tensor * v_t     = ggml_cont(ctx, ggml_permute(ctx, v, 1, 0, 2, 3));
+        o                     = ggml_mul_mat(ctx, v_t, kq_soft);
     }
     // o: [head_dim, T, n_head, B] -> [head_dim, n_head, T, B] -> [d_model, T, B]
     o = ggml_permute(ctx, o, 0, 2, 1, 3);
@@ -211,46 +210,46 @@ ggml_tensor * build_rotary_attn(ggml_context *      ctx,
 
     // Output projection.
     o = ggml_mul_mat(ctx, b.attn_out_w, o);
-    if (b.attn_out_b != nullptr) o = ggml_add(ctx, o, b.attn_out_b);
+    if (b.attn_out_b != nullptr) {
+        o = ggml_add(ctx, o, b.attn_out_b);
+    }
     return o;
 }
 
 // Build one Conformer block with rotary attention. Returns the
 // post-norm-out tensor (= the block output).
-ggml_tensor * build_block(ggml_context *      ctx,
-                          ggml_tensor *       x,
-                          ggml_tensor *       positions,
-                          const GigaamBlock & b,
-                          int                 d_model,
-                          int                 n_head,
-                          int                 conv_kernel,
-                          bool                use_flash,
+ggml_tensor * build_block(ggml_context *           ctx,
+                          ggml_tensor *            x,
+                          ggml_tensor *            positions,
+                          const GigaamBlock &      b,
+                          int                      d_model,
+                          int                      n_head,
+                          int                      conv_kernel,
+                          bool                     use_flash,
                           const conf::ConvPolicy & policy,
-                          ggml_tensor *       attn_pad_mask = nullptr,
-                          ggml_tensor *       conv_pad_mask = nullptr,
-                          ggml_tensor **      out_after_attn = nullptr,
-                          ggml_tensor **      out_after_conv = nullptr)
-{
+                          ggml_tensor *            attn_pad_mask  = nullptr,
+                          ggml_tensor *            conv_pad_mask  = nullptr,
+                          ggml_tensor **           out_after_attn = nullptr,
+                          ggml_tensor **           out_after_conv = nullptr) {
     // Macaron FF1: x + 0.5 * FF(LN(x)).
-    x = conf::macaron_ff_residual(ctx, x,
-                                   b.norm_ff1_w, b.norm_ff1_b,
-                                   b.ff1_lin1_w, b.ff1_lin1_b,
-                                   b.ff1_lin2_w, b.ff1_lin2_b);
+    x = conf::macaron_ff_residual(ctx, x, b.norm_ff1_w, b.norm_ff1_b, b.ff1_lin1_w, b.ff1_lin1_b, b.ff1_lin2_w,
+                                  b.ff1_lin2_b);
 
     // Self-attention residual: x + attn(LN(x)).
     {
         ggml_tensor * y = conf::layer_norm(ctx, x, b.norm_attn_w, b.norm_attn_b);
-        y = build_rotary_attn(ctx, y, positions, b, d_model, n_head, use_flash,
-                              attn_pad_mask);
-        x = ggml_add(ctx, x, y);
+        y               = build_rotary_attn(ctx, y, positions, b, d_model, n_head, use_flash, attn_pad_mask);
+        x               = ggml_add(ctx, x, y);
+    }
+    if (out_after_attn != nullptr) {
+        *out_after_attn = x;
     }
-    if (out_after_attn != nullptr) *out_after_attn = x;
 
     // Conv module residual: x + conv(LN(x)).
     {
-        ggml_tensor * y = conf::layer_norm(ctx, x, b.norm_conv_w, b.norm_conv_b);
-        conf::BlockView cv = to_conv_view(b);
-        conf::BlockParams cp {};
+        ggml_tensor *     y  = conf::layer_norm(ctx, x, b.norm_conv_w, b.norm_conv_b);
+        conf::BlockView   cv = to_conv_view(b);
+        conf::BlockParams cp{};
         cp.d_model        = d_model;
         cp.n_head         = n_head;
         cp.conv_kernel    = conv_kernel;
@@ -259,16 +258,16 @@ ggml_tensor * build_block(ggml_context *      ctx,
         cp.policy         = policy;
         cp.conv_norm_type = conf::BlockParams::ConvNormType::LayerNorm;
         cp.conv_pad_mask  = conv_pad_mask;
-        y = conf::conv_module(ctx, y, cv, cp);
-        x = ggml_add(ctx, x, y);
+        y                 = conf::conv_module(ctx, y, cv, cp);
+        x                 = ggml_add(ctx, x, y);
+    }
+    if (out_after_conv != nullptr) {
+        *out_after_conv = x;
     }
-    if (out_after_conv != nullptr) *out_after_conv = x;
 
     // Macaron FF2.
-    x = conf::macaron_ff_residual(ctx, x,
-                                   b.norm_ff2_w, b.norm_ff2_b,
-                                   b.ff2_lin1_w, b.ff2_lin1_b,
-                                   b.ff2_lin2_w, b.ff2_lin2_b);
+    x = conf::macaron_ff_residual(ctx, x, b.norm_ff2_w, b.norm_ff2_b, b.ff2_lin1_w, b.ff2_lin1_b, b.ff2_lin2_w,
+                                  b.ff2_lin2_b);
 
     // Final per-block LayerNorm. NOTE: the reference returns norm_out(x)
     // (not the residual stream); the block output IS the post-LN value.
@@ -276,53 +275,52 @@ ggml_tensor * build_block(ggml_context *      ctx,
     return x;
 }
 
-} // namespace
+}  // namespace
 
 // One stride-2 conv with symmetric (k-1)/2 padding: floor((in-1)/2)+1.
 // GigaAM's k=5/pad=2 and parakeet's k=3/pad=1 both reduce to this.
-static int pre_encode_t_out(int in) { return (in - 1) / 2 + 1; }
+static int pre_encode_t_out(int in) {
+    return (in - 1) / 2 + 1;
+}
 
 EncoderBuild build_encoder_graph(ggml_context *        ctx,
                                  const GigaamWeights & w,
                                  const GigaamHParams & hp,
                                  int                   n_mel_frames,
-                                 ggml_type             /*kv_type*/,
-                                 const char *          backend_name,
-                                 int                   n_batch,
-                                 bool                  batch_var_len)
-{
-    EncoderBuild eb {};
+                                 ggml_type /*kv_type*/,
+                                 const char * backend_name,
+                                 int          n_batch,
+                                 bool         batch_var_len) {
+    EncoderBuild eb{};
     if (ctx == nullptr || n_mel_frames <= 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "gigaam encoder: invalid arg "
-                     "(ctx=%p, n_mel_frames=%d)",
-                     static_cast<void *>(ctx), n_mel_frames);
+                "gigaam encoder: invalid arg "
+                "(ctx=%p, n_mel_frames=%d)",
+                static_cast<void *>(ctx), n_mel_frames);
         return eb;
     }
-    if (n_batch < 1) n_batch = 1;
+    if (n_batch < 1) {
+        n_batch = 1;
+    }
     const bool var_len_masks = batch_var_len && n_batch > 1;
 
     // Mel input handle. ne=[T_mel, n_mels, n_batch] (n_batch == 1 keeps the
     // pre-batch 2-D layout — ggml treats a trailing ne==1 axis identically).
-    eb.mel_in = ggml_new_tensor_3d(ctx, GGML_TYPE_F32,
-                                   n_mel_frames, hp.fe_num_mels, n_batch);
+    eb.mel_in = ggml_new_tensor_3d(ctx, GGML_TYPE_F32, n_mel_frames, hp.fe_num_mels, n_batch);
     if (eb.mel_in == nullptr) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "gigaam encoder: failed to allocate mel_in tensor");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "gigaam encoder: failed to allocate mel_in tensor");
         return eb;
     }
     ggml_set_name(eb.mel_in, "mel.in");
     ggml_set_input(eb.mel_in);
 
     // Variable-length masked-subsampling inputs (one per conv-relu stage).
-    PreEncodeMasks pe_masks {};
+    PreEncodeMasks pe_masks{};
     if (var_len_masks) {
-        const int T_s1 = pre_encode_t_out(n_mel_frames);
-        const int T_s2 = pre_encode_t_out(T_s1);
-        eb.pre_encode_mask_s1_in =
-            ggml_new_tensor_3d(ctx, GGML_TYPE_F32, T_s1, 1, n_batch);
-        eb.pre_encode_mask_s2_in =
-            ggml_new_tensor_3d(ctx, GGML_TYPE_F32, T_s2, 1, n_batch);
+        const int T_s1           = pre_encode_t_out(n_mel_frames);
+        const int T_s2           = pre_encode_t_out(T_s1);
+        eb.pre_encode_mask_s1_in = ggml_new_tensor_3d(ctx, GGML_TYPE_F32, T_s1, 1, n_batch);
+        eb.pre_encode_mask_s2_in = ggml_new_tensor_3d(ctx, GGML_TYPE_F32, T_s2, 1, n_batch);
         ggml_set_name(eb.pre_encode_mask_s1_in, "enc.pre_encode.mask_s1");
         ggml_set_name(eb.pre_encode_mask_s2_in, "enc.pre_encode.mask_s2");
         ggml_set_input(eb.pre_encode_mask_s1_in);
@@ -332,19 +330,19 @@ EncoderBuild build_encoder_graph(ggml_context *        ctx,
     }
 
     // Pre-encode: 2 stride-2 conv1d.
-    ggml_tensor * x = build_pre_encode(ctx, w.pre_encode, eb.mel_in,
-                                       hp.enc_subs_kernel_size,
-                                       "enc.pre_encode",
+    ggml_tensor * x = build_pre_encode(ctx, w.pre_encode, eb.mel_in, hp.enc_subs_kernel_size, "enc.pre_encode",
                                        var_len_masks ? &pe_masks : nullptr);
-    if (x == nullptr) return eb;
+    if (x == nullptr) {
+        return eb;
+    }
     ggml_set_name(x, "enc.subsample.out");
     eb.dumps.pre_encode_out = x;
     transcribe::debug::mark_tensor_for_dump(x);
 
     if (w.blocks.empty()) {
-        eb.out = x;
+        eb.out             = x;
         eb.dumps.final_out = x;
-        eb.graph = ggml_new_graph(ctx);
+        eb.graph           = ggml_new_graph(ctx);
         ggml_build_forward_expand(eb.graph, x);
         return eb;
     }
@@ -355,10 +353,8 @@ EncoderBuild build_encoder_graph(ggml_context *        ctx,
     // driver). attn_pad_mask zeros softmax over padded keys; conv_pad_mask
     // zeros padded frames before each depthwise conv.
     if (var_len_masks) {
-        eb.attn_pad_mask_in =
-            ggml_new_tensor_4d(ctx, GGML_TYPE_F32, T_enc, 1, 1, n_batch);
-        eb.conv_pad_mask_in =
-            ggml_new_tensor_4d(ctx, GGML_TYPE_F32, T_enc, 1, n_batch, 1);
+        eb.attn_pad_mask_in = ggml_new_tensor_4d(ctx, GGML_TYPE_F32, T_enc, 1, 1, n_batch);
+        eb.conv_pad_mask_in = ggml_new_tensor_4d(ctx, GGML_TYPE_F32, T_enc, 1, n_batch, 1);
         ggml_set_name(eb.attn_pad_mask_in, "enc.attn_pad_mask");
         ggml_set_name(eb.conv_pad_mask_in, "enc.conv_pad_mask");
         ggml_set_input(eb.attn_pad_mask_in);
@@ -373,15 +369,14 @@ EncoderBuild build_encoder_graph(ggml_context *        ctx,
     eb.dumps.pos_emb = positions;
 
     // Conv policy. GigaAM's depthwise k=5 — Metal direct path works.
-    conf::ConvPolicy policy {};
+    conf::ConvPolicy policy{};
     policy.direct_pw               = conf::detect_direct_pw(backend_name);
     policy.direct_dw_in_block      = true;
     policy.direct_dw_in_pre_encode = false;
     policy.causal_pre_encode       = false;
 
     // Use flash attention on GPU backends; manual path on CPU.
-    const bool use_flash = (backend_name != nullptr &&
-                            std::string(backend_name).find("CPU") == std::string::npos);
+    const bool use_flash = (backend_name != nullptr && std::string(backend_name).find("CPU") == std::string::npos);
 
     const int n_layers = hp.enc_n_layers;
     eb.dumps.all_block_outs.reserve(n_layers);
@@ -389,12 +384,9 @@ EncoderBuild build_encoder_graph(ggml_context *        ctx,
     eb.dumps.last_block_idx = n_layers - 1;
 
     for (int i = 0; i < n_layers; ++i) {
-        x = build_block(ctx, x, positions, w.blocks[i],
-                        hp.enc_d_model, hp.enc_n_heads,
-                        hp.enc_conv_kernel, use_flash, policy,
-                        eb.attn_pad_mask_in, eb.conv_pad_mask_in,
-                        i == 0 ? &eb.dumps.block0_after_attn : nullptr,
-                        i == 0 ? &eb.dumps.block0_after_conv : nullptr);
+        x = build_block(ctx, x, positions, w.blocks[i], hp.enc_d_model, hp.enc_n_heads, hp.enc_conv_kernel, use_flash,
+                        policy, eb.attn_pad_mask_in, eb.conv_pad_mask_in,
+                        i == 0 ? &eb.dumps.block0_after_attn : nullptr, i == 0 ? &eb.dumps.block0_after_conv : nullptr);
 
         eb.dumps.all_block_outs.push_back(x);
 
@@ -434,7 +426,7 @@ EncoderBuild build_encoder_graph(ggml_context *        ctx,
     // on a view doesn't preserve the materialized cont buffer.
     ggml_tensor * enc_out_t = ggml_cont(ctx, ggml_permute(ctx, x, 1, 0, 2, 3));
     ggml_set_name(enc_out_t, "enc.out");
-    eb.out = enc_out_t;
+    eb.out             = enc_out_t;
     eb.dumps.final_out = enc_out_t;
     transcribe::debug::mark_tensor_for_dump(enc_out_t);
 
@@ -443,4 +435,4 @@ EncoderBuild build_encoder_graph(ggml_context *        ctx,
     return eb;
 }
 
-} // namespace transcribe::gigaam
+}  // namespace transcribe::gigaam
diff --git a/src/arch/gigaam/encoder.h b/src/arch/gigaam/encoder.h
index 06c3e6a2..5b193b27 100644
--- a/src/arch/gigaam/encoder.h
+++ b/src/arch/gigaam/encoder.h
@@ -18,29 +18,29 @@ struct GigaamHParams;
 struct GigaamWeights;
 
 struct EncoderDumps {
-    ggml_tensor * pre_encode_out = nullptr;
-    ggml_tensor * pos_emb        = nullptr;
-    ggml_tensor * block0_out     = nullptr;
-    ggml_tensor * mid_block_out  = nullptr;
-    ggml_tensor * last_block_out = nullptr;
-    ggml_tensor * final_out      = nullptr;
+    ggml_tensor *              pre_encode_out = nullptr;
+    ggml_tensor *              pos_emb        = nullptr;
+    ggml_tensor *              block0_out     = nullptr;
+    ggml_tensor *              mid_block_out  = nullptr;
+    ggml_tensor *              last_block_out = nullptr;
+    ggml_tensor *              final_out      = nullptr;
     // Pre-final-transpose tensor, ne=[d_model, T_enc, 1]. PyTorch
     // equivalent shape (1, T_enc, d_model). This is what the RNN-T /
     // CTC head consumes for decode and what the reference dumps as
     // `rnnt.encoded`. final_out (post-transpose) is what gets compared
     // against the reference `enc.out` dump.
-    ggml_tensor * rnnt_encoded   = nullptr;
-    int           mid_block_idx  = -1;
-    int           last_block_idx = -1;
+    ggml_tensor *              rnnt_encoded   = nullptr;
+    int                        mid_block_idx  = -1;
+    int                        last_block_idx = -1;
     std::vector<ggml_tensor *> all_block_outs;
     // Block-0 sub-step taps (batch-drift localization).
-    ggml_tensor * block0_after_attn = nullptr;
-    ggml_tensor * block0_after_conv = nullptr;
+    ggml_tensor *              block0_after_attn = nullptr;
+    ggml_tensor *              block0_after_conv = nullptr;
 };
 
 struct EncoderBuild {
-    ggml_tensor * mel_in     = nullptr;
-    ggml_tensor * out        = nullptr;
+    ggml_tensor * mel_in = nullptr;
+    ggml_tensor * out    = nullptr;
 
     // Variable-length offline batch masks. All null for single-shot and
     // same-length batches; allocated only when build_encoder_graph is
@@ -63,8 +63,8 @@ struct EncoderBuild {
     ggml_tensor * pre_encode_mask_s1_in = nullptr;  // after conv0 relu
     ggml_tensor * pre_encode_mask_s2_in = nullptr;  // after conv2 relu
 
-    EncoderDumps  dumps      {};
-    ggml_cgraph * graph      = nullptr;
+    EncoderDumps  dumps{};
+    ggml_cgraph * graph = nullptr;
 };
 
 // Build a fresh encoder forward graph.
@@ -81,9 +81,9 @@ EncoderBuild build_encoder_graph(ggml_context *        compute_ctx,
                                  const GigaamWeights & weights,
                                  const GigaamHParams & hp,
                                  int                   n_mel_frames,
-                                 ggml_type             kv_type = GGML_TYPE_COUNT,
-                                 const char *          backend_name = "",
-                                 int                   n_batch = 1,
+                                 ggml_type             kv_type       = GGML_TYPE_COUNT,
+                                 const char *          backend_name  = "",
+                                 int                   n_batch       = 1,
                                  bool                  batch_var_len = false);
 
-} // namespace transcribe::gigaam
+}  // namespace transcribe::gigaam
diff --git a/src/arch/gigaam/gigaam.h b/src/arch/gigaam/gigaam.h
index 15793d32..3824f33c 100644
--- a/src/arch/gigaam/gigaam.h
+++ b/src/arch/gigaam/gigaam.h
@@ -12,8 +12,8 @@
 #include "decoder.h"
 #include "mel.h"
 #include "transcribe-backend.h"
-#include "transcribe-session.h"
 #include "transcribe-model.h"
+#include "transcribe-session.h"
 #include "transcribe-tokenizer.h"
 #include "weights.h"
 
@@ -40,10 +40,10 @@ void apply_family_invariants(transcribe_model & model);
 // Concrete model. Owns the ggml_context that holds every weight tensor's
 // data buffer plus the host decoder mirror for the RNN-T/CTC greedy loop.
 struct GigaamModel final : public transcribe_model {
-    Tokenizer       tok;
-    GigaamHParams   hparams;
-    GigaamWeights   weights;
-    ggml_context *  ctx_meta = nullptr;
+    Tokenizer      tok;
+    GigaamHParams  hparams;
+    GigaamWeights  weights;
+    ggml_context * ctx_meta = nullptr;
 
     transcribe::BackendPlan plan;
     ggml_backend_buffer_t   backend_buffer = nullptr;
@@ -65,17 +65,17 @@ struct GigaamModel final : public transcribe_model {
 // Concrete context. One scheduler + compute_ctx lifecycle per context,
 // mirroring parakeet.
 struct GigaamSession final : public transcribe_session {
-    ggml_context *        compute_ctx = nullptr;
-    ggml_backend_sched_t  sched       = nullptr;
+    ggml_context *       compute_ctx = nullptr;
+    ggml_backend_sched_t sched       = nullptr;
 
     ggml_tensor * encoder_out = nullptr;
 
-    std::vector<float>   mel_buf;
-    std::vector<float>   pos_buf;          // cos/sin rotary PE bank, host scratch
-    std::vector<float>   enc_host;
+    std::vector<float> mel_buf;
+    std::vector<float> pos_buf;  // cos/sin rotary PE bank, host scratch
+    std::vector<float> enc_host;
 
     GigaamSession() = default;
     ~GigaamSession() override;
 };
 
-} // namespace transcribe::gigaam
+}  // namespace transcribe::gigaam
diff --git a/src/arch/gigaam/mel.cpp b/src/arch/gigaam/mel.cpp
index d70a0670..348bcdc1 100644
--- a/src/arch/gigaam/mel.cpp
+++ b/src/arch/gigaam/mel.cpp
@@ -7,10 +7,9 @@
 
 #include "mel.h"
 
-#include "weights.h"
-
-#include "ggml.h"
 #include "ggml-backend.h"
+#include "ggml.h"
+#include "weights.h"
 
 #include <algorithm>
 #include <cmath>
@@ -31,7 +30,7 @@ void dft_naive(const float * in, int N, float * out) {
             re += in[n] * std::cos(theta);
             im += in[n] * std::sin(theta);
         }
-        out[2 * k    ] = static_cast<float>(re);
+        out[2 * k]     = static_cast<float>(re);
         out[2 * k + 1] = static_cast<float>(im);
     }
 }
@@ -53,33 +52,36 @@ void mixed_radix_fft(float * in, int N, float * out) {
         return;
     }
     const int half_N = N / 2;
-    float * even = in + N;
-    for (int i = 0; i < half_N; ++i) even[i] = in[2 * i];
+    float *   even   = in + N;
+    for (int i = 0; i < half_N; ++i) {
+        even[i] = in[2 * i];
+    }
     float * even_fft = out + 2 * N;
     mixed_radix_fft(even, half_N, even_fft);
 
     float * odd = even;
-    for (int i = 0; i < half_N; ++i) odd[i] = in[2 * i + 1];
+    for (int i = 0; i < half_N; ++i) {
+        odd[i] = in[2 * i + 1];
+    }
     float * odd_fft = even_fft + N;
     mixed_radix_fft(odd, half_N, odd_fft);
 
     for (int k = 0; k < half_N; ++k) {
-        const double theta = -2.0 * M_PI * k / N;
-        const float w_re = static_cast<float>(std::cos(theta));
-        const float w_im = static_cast<float>(std::sin(theta));
-        const float re_odd = odd_fft[2 * k    ];
-        const float im_odd = odd_fft[2 * k + 1];
-        out[2 * k    ]            = even_fft[2 * k    ] + w_re * re_odd - w_im * im_odd;
+        const double theta        = -2.0 * M_PI * k / N;
+        const float  w_re         = static_cast<float>(std::cos(theta));
+        const float  w_im         = static_cast<float>(std::sin(theta));
+        const float  re_odd       = odd_fft[2 * k];
+        const float  im_odd       = odd_fft[2 * k + 1];
+        out[2 * k]                = even_fft[2 * k] + w_re * re_odd - w_im * im_odd;
         out[2 * k + 1]            = even_fft[2 * k + 1] + w_re * im_odd + w_im * re_odd;
-        out[2 * (k + half_N)    ] = even_fft[2 * k    ] - w_re * re_odd + w_im * im_odd;
+        out[2 * (k + half_N)]     = even_fft[2 * k] - w_re * re_odd + w_im * im_odd;
         out[2 * (k + half_N) + 1] = even_fft[2 * k + 1] - w_re * im_odd - w_im * re_odd;
     }
 }
 
-} // namespace
+}  // namespace
 
-void GigaamMelFrontend::init(const GigaamHParams & hp,
-                             const GigaamWeights & w) {
+void GigaamMelFrontend::init(const GigaamHParams & hp, const GigaamWeights & w) {
     n_mels     = hp.fe_num_mels;
     n_fft      = hp.fe_n_fft;
     win_length = hp.fe_win_length;
@@ -93,30 +95,33 @@ void GigaamMelFrontend::init(const GigaamHParams & hp,
     // readback matches numpy row-major directly.
     hann.assign(win_length, 0.0f);
     if (w.frontend_window != nullptr) {
-        ggml_backend_tensor_get(w.frontend_window, hann.data(), 0,
-                                hann.size() * sizeof(float));
+        ggml_backend_tensor_get(w.frontend_window, hann.data(), 0, hann.size() * sizeof(float));
     }
     mel_fb.assign(static_cast<size_t>(n_mels) * n_freq, 0.0f);
     if (w.frontend_mel_filterbank != nullptr) {
-        ggml_backend_tensor_get(w.frontend_mel_filterbank, mel_fb.data(), 0,
-                                mel_fb.size() * sizeof(float));
+        ggml_backend_tensor_get(w.frontend_mel_filterbank, mel_fb.data(), 0, mel_fb.size() * sizeof(float));
     }
 }
 
 int GigaamMelFrontend::n_frames_for(size_t n_samples) const {
-    if (static_cast<int>(n_samples) < win_length) return 0;
+    if (static_cast<int>(n_samples) < win_length) {
+        return 0;
+    }
     return static_cast<int>((n_samples - win_length) / hop_length) + 1;
 }
 
 transcribe_status GigaamMelFrontend::compute(const float *        pcm,
                                              size_t               n_samples,
                                              std::vector<float> & out_mel,
-                                             int &                out_n_frames) const
-{
-    if (pcm == nullptr) return TRANSCRIBE_ERR_INVALID_ARG;
+                                             int &                out_n_frames) const {
+    if (pcm == nullptr) {
+        return TRANSCRIBE_ERR_INVALID_ARG;
+    }
 
     const int n_frames = n_frames_for(n_samples);
-    if (n_frames <= 0) return TRANSCRIBE_ERR_INVALID_ARG;
+    if (n_frames <= 0) {
+        return TRANSCRIBE_ERR_INVALID_ARG;
+    }
     out_n_frames = n_frames;
 
     out_mel.assign(static_cast<size_t>(n_mels) * n_frames, 0.0f);
@@ -141,28 +146,31 @@ transcribe_status GigaamMelFrontend::compute(const float *        pcm,
 
         // power_spec[k] = |X[k]|^2 (power=2).
         for (int k = 0; k < n_freq; ++k) {
-            const float re = fft_out[2 * k    ];
+            const float re = fft_out[2 * k];
             const float im = fft_out[2 * k + 1];
-            power_spec[k] = re * re + im * im;
+            power_spec[k]  = re * re + im * im;
         }
 
         // mel[m] = sum_k filterbank[m, k] * power_spec[k]; then
         // log(clamp(x, 1e-9, 1e9)).
         for (int m = 0; m < n_mels; ++m) {
-            const float * row = mel_fb.data() +
-                                static_cast<size_t>(m) * n_freq;
-            float acc = 0.0f;
+            const float * row = mel_fb.data() + static_cast<size_t>(m) * n_freq;
+            float         acc = 0.0f;
             for (int k = 0; k < n_freq; ++k) {
                 acc += row[k] * power_spec[k];
             }
-            if (acc < 1.0e-9f) acc = 1.0e-9f;
+            if (acc < 1.0e-9f) {
+                acc = 1.0e-9f;
+            }
             // The upper clamp at 1e9 in the reference is unreachable for
             // realistic 16-bit PCM, but mirror it for byte-equivalence.
-            if (acc > 1.0e9f)  acc = 1.0e9f;
+            if (acc > 1.0e9f) {
+                acc = 1.0e9f;
+            }
             out_mel[static_cast<size_t>(m) * n_frames + t] = std::log(acc);
         }
     }
     return TRANSCRIBE_OK;
 }
 
-} // namespace transcribe::gigaam
+}  // namespace transcribe::gigaam
diff --git a/src/arch/gigaam/mel.h b/src/arch/gigaam/mel.h
index 40d3d457..86d7c387 100644
--- a/src/arch/gigaam/mel.h
+++ b/src/arch/gigaam/mel.h
@@ -22,13 +22,13 @@ struct GigaamWeights;
 // recomputing from htk_hz_to_mel / Hann: torchaudio uses Float32 throughout, so
 // an fp64 C++ recomputation drifts at high-freq bin boundaries.
 struct GigaamMelFrontend {
-    int n_freq;                       // n_fft/2 + 1
-    int n_mels;
-    int n_fft;
-    int win_length;
-    int hop_length;
-    std::vector<float> hann;          // [win_length] periodic
-    std::vector<float> mel_fb;        // [n_mels, n_freq] row-major HTK
+    int                n_freq;  // n_fft/2 + 1
+    int                n_mels;
+    int                n_fft;
+    int                win_length;
+    int                hop_length;
+    std::vector<float> hann;    // [win_length] periodic
+    std::vector<float> mel_fb;  // [n_mels, n_freq] row-major HTK
 
     void init(const GigaamHParams & hp, const GigaamWeights & w);
 
@@ -43,4 +43,4 @@ struct GigaamMelFrontend {
                               int &                out_n_frames) const;
 };
 
-} // namespace transcribe::gigaam
+}  // namespace transcribe::gigaam
diff --git a/src/arch/gigaam/model.cpp b/src/arch/gigaam/model.cpp
index 7b8a441c..3675a36a 100644
--- a/src/arch/gigaam/model.cpp
+++ b/src/arch/gigaam/model.cpp
@@ -4,12 +4,13 @@
 // backend buffer, and builds the mel frontend + host decoder mirror. run()
 // drives the mel -> encoder graph -> host RNN-T/CTC greedy decode pipeline.
 
-#include "gigaam.h"
-
 #include "decoder.h"
 #include "encoder.h"
-#include "weights.h"
-
+#include "ggml-alloc.h"
+#include "ggml-backend.h"
+#include "ggml.h"
+#include "gguf.h"
+#include "gigaam.h"
 #include "transcribe-arch.h"
 #include "transcribe-batch-util.h"
 #include "transcribe-debug.h"
@@ -18,11 +19,7 @@
 #include "transcribe-loader.h"
 #include "transcribe-log.h"
 #include "transcribe-meta.h"
-
-#include "ggml.h"
-#include "ggml-alloc.h"
-#include "ggml-backend.h"
-#include "gguf.h"
+#include "weights.h"
 
 #include <algorithm>
 #include <cstdint>
@@ -41,7 +38,7 @@ namespace transcribe::gigaam {
 
 extern const Arch arch;
 
-static_assert(std::is_base_of_v<transcribe_model,   GigaamModel>);
+static_assert(std::is_base_of_v<transcribe_model, GigaamModel>);
 static_assert(std::is_base_of_v<transcribe_session, GigaamSession>);
 
 GigaamSession::~GigaamSession() {
@@ -65,9 +62,7 @@ GigaamModel::~GigaamModel() {
         ggml_backend_buffer_free(backend_buffer);
         backend_buffer = nullptr;
     }
-    for (auto it = plan.scheduler_list.rbegin();
-         it != plan.scheduler_list.rend(); ++it)
-    {
+    for (auto it = plan.scheduler_list.rbegin(); it != plan.scheduler_list.rend(); ++it) {
         ggml_backend_free(*it);
     }
     plan.scheduler_list.clear();
@@ -92,13 +87,10 @@ constexpr const char k_default_variant[] = "gigaam-v3-e2e-rnnt";
 constexpr int     k_safe_s        = 25;
 constexpr int64_t k_safe_audio_ms = 25000;
 
-transcribe_status load(Loader &                         loader,
-                       const transcribe_model_load_params *  params,
-                       transcribe_model **              out_model)
-{
+transcribe_status load(Loader & loader, const transcribe_model_load_params * params, transcribe_model ** out_model) {
     const int64_t t_load_start = ggml_time_us();
 
-    auto m = std::make_unique<GigaamModel>();
+    auto m       = std::make_unique<GigaamModel>();
     m->arch      = &arch;
     m->t_load_us = 0;
 
@@ -109,14 +101,18 @@ transcribe_status load(Loader &                         loader,
     m->caps.n_languages = 0;
     m->caps.languages   = nullptr;
 
-    if (auto st = read_capability_kv(loader.gguf(), m->caps); st != TRANSCRIBE_OK)
+    if (auto st = read_capability_kv(loader.gguf(), m->caps); st != TRANSCRIBE_OK) {
         return st;
-    if (auto st = read_languages_kv(loader.gguf(), *m); st != TRANSCRIBE_OK)
+    }
+    if (auto st = read_languages_kv(loader.gguf(), *m); st != TRANSCRIBE_OK) {
         return st;
-    if (auto st = m->tok.load(loader.gguf()); st != TRANSCRIBE_OK)
+    }
+    if (auto st = m->tok.load(loader.gguf()); st != TRANSCRIBE_OK) {
         return st;
-    if (auto st = read_gigaam_hparams(loader.gguf(), m->hparams); st != TRANSCRIBE_OK)
+    }
+    if (auto st = read_gigaam_hparams(loader.gguf(), m->hparams); st != TRANSCRIBE_OK) {
         return st;
+    }
 
     // Publish the advisory soft-window now that the frontend hparams are
     // known (apply_family_invariants ran before the hparams were read, so it
@@ -125,57 +121,49 @@ transcribe_status load(Loader &                         loader,
     m->caps.max_audio_ms = k_safe_audio_ms;
 
     // Reopen for tensor metadata.
-    gguf_init_params init_params {};
-    init_params.no_alloc = true;
-    init_params.ctx      = &m->ctx_meta;
-    gguf_context * gguf_data = gguf_init_from_file(loader.path().c_str(),
-                                                   init_params);
-    if (gguf_data == nullptr) return TRANSCRIBE_ERR_GGUF;
-
-    if (auto st = build_gigaam_weights(m->ctx_meta, m->hparams, m->weights);
-        st != TRANSCRIBE_OK)
-    {
+    gguf_init_params init_params{};
+    init_params.no_alloc     = true;
+    init_params.ctx          = &m->ctx_meta;
+    gguf_context * gguf_data = gguf_init_from_file(loader.path().c_str(), init_params);
+    if (gguf_data == nullptr) {
+        return TRANSCRIBE_ERR_GGUF;
+    }
+
+    if (auto st = build_gigaam_weights(m->ctx_meta, m->hparams, m->weights); st != TRANSCRIBE_OK) {
         gguf_free(gguf_data);
         return st;
     }
 
-    const transcribe_backend_request backend_req =
-        (params != nullptr) ? params->backend : TRANSCRIBE_BACKEND_AUTO;
-    if (auto st = transcribe::load_common::init_backends(
-            backend_req, (params != nullptr) ? params->gpu_device : 0, "gigaam", m->plan);
-        st != TRANSCRIBE_OK)
-    {
+    const transcribe_backend_request backend_req = (params != nullptr) ? params->backend : TRANSCRIBE_BACKEND_AUTO;
+    if (auto st = transcribe::load_common::init_backends(backend_req, (params != nullptr) ? params->gpu_device : 0,
+                                                         "gigaam", m->plan);
+        st != TRANSCRIBE_OK) {
         gguf_free(gguf_data);
         return st;
     }
-    m->backend = ggml_backend_name(m->plan.primary);
+    m->backend         = ggml_backend_name(m->plan.primary);
     m->primary_backend = m->plan.primary;
 
-    ggml_backend_buffer_t weights_buffer =
-        ggml_backend_alloc_ctx_tensors(m->ctx_meta, m->plan.primary);
+    ggml_backend_buffer_t weights_buffer = ggml_backend_alloc_ctx_tensors(m->ctx_meta, m->plan.primary);
     if (weights_buffer == nullptr) {
         gguf_free(gguf_data);
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "gigaam: ggml_backend_alloc_ctx_tensors failed");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "gigaam: ggml_backend_alloc_ctx_tensors failed");
         return TRANSCRIBE_ERR_GGUF;
     }
     m->backend_buffer = weights_buffer;
-    ggml_backend_buffer_set_usage(weights_buffer,
-                                  GGML_BACKEND_BUFFER_USAGE_WEIGHTS);
+    ggml_backend_buffer_set_usage(weights_buffer, GGML_BACKEND_BUFFER_USAGE_WEIGHTS);
 
-    if (auto st = transcribe::load_common::stream_tensor_data(
-            loader.path(), gguf_data, m->ctx_meta, "gigaam");
-        st != TRANSCRIBE_OK)
-    {
+    if (auto st = transcribe::load_common::stream_tensor_data(loader.path(), gguf_data, m->ctx_meta, "gigaam");
+        st != TRANSCRIBE_OK) {
         gguf_free(gguf_data);
         return st;
     }
     gguf_free(gguf_data);
 
     // Build host mirror of the predictor + joint (RNN-T) or CTC head (CTC).
-    if (auto st = build_host_decoder_weights(m->weights, m->hparams,
-                                             m->host_decoder);
-        st != TRANSCRIBE_OK) return st;
+    if (auto st = build_host_decoder_weights(m->weights, m->hparams, m->host_decoder); st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Initialize the family mel frontend. The Hann window and HTK
     // filterbank are baked into the GGUF by the converter; mel.init
@@ -183,17 +171,18 @@ transcribe_status load(Loader &                         loader,
     m->mel.init(m->hparams, m->weights);
 
     m->t_load_us = ggml_time_us() - t_load_start;
-    *out_model = m.release();
+    *out_model   = m.release();
     return TRANSCRIBE_OK;
 }
 
 transcribe_status init_context(transcribe_model *                model,
                                const transcribe_session_params * params,
-                               transcribe_session **             out_ctx)
-{
-    if (model->arch != &arch) return TRANSCRIBE_ERR_INVALID_ARG;
+                               transcribe_session **             out_ctx) {
+    if (model->arch != &arch) {
+        return TRANSCRIBE_ERR_INVALID_ARG;
+    }
 
-    auto gc = std::make_unique<GigaamSession>();
+    auto gc       = std::make_unique<GigaamSession>();
     gc->model     = model;
     gc->n_threads = params->n_threads;
     gc->kv_type   = params->kv_type;
@@ -211,45 +200,39 @@ namespace {
 // fast-to-slow layout maps byte i to ne_index (t=i%T_mel, m=i/T_mel).
 // Both byte orders are identical — just a memcpy is needed.
 #ifdef TRANSCRIBE_ENABLE_VALIDATION_HOOKS
-transcribe_status load_ref_mel(const std::string & dir,
-                               int                 n_mels,
-                               int &               n_mel_frames,
-                               std::vector<float> & out)
-{
+transcribe_status load_ref_mel(const std::string & dir, int n_mels, int & n_mel_frames, std::vector<float> & out) {
     std::string path = dir;
-    if (!path.empty() && path.back() != '/') path += '/';
+    if (!path.empty() && path.back() != '/') {
+        path += '/';
+    }
     path += "frontend.mel.out.f32";
 
     std::ifstream f(path, std::ios::binary | std::ios::ate);
     if (!f) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "gigaam: cannot open mel ref '%s'", path.c_str());
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "gigaam: cannot open mel ref '%s'", path.c_str());
         return TRANSCRIBE_ERR_FILE_NOT_FOUND;
     }
     const std::streamsize total_bytes = f.tellg();
     f.seekg(0, std::ios::beg);
-    if (total_bytes <= 0 ||
-        (static_cast<size_t>(total_bytes) % (sizeof(float) * n_mels)) != 0)
-    {
+    if (total_bytes <= 0 || (static_cast<size_t>(total_bytes) % (sizeof(float) * n_mels)) != 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "gigaam: mel ref '%s' size %lld not divisible by "
-                     "n_mels=%d * 4",
-                     path.c_str(), static_cast<long long>(total_bytes), n_mels);
+                "gigaam: mel ref '%s' size %lld not divisible by "
+                "n_mels=%d * 4",
+                path.c_str(), static_cast<long long>(total_bytes), n_mels);
         return TRANSCRIBE_ERR_GGUF;
     }
 
     const size_t n_elems = static_cast<size_t>(total_bytes) / sizeof(float);
-    n_mel_frames = static_cast<int>(n_elems / n_mels);
+    n_mel_frames         = static_cast<int>(n_elems / n_mels);
     out.assign(n_elems, 0.0f);
-    f.read(reinterpret_cast<char *>(out.data()),
-           static_cast<std::streamsize>(total_bytes));
+    f.read(reinterpret_cast<char *>(out.data()), static_cast<std::streamsize>(total_bytes));
     if (static_cast<std::streamsize>(f.gcount()) != total_bytes) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "gigaam: short read on mel ref");
         return TRANSCRIBE_ERR_GGUF;
     }
     return TRANSCRIBE_OK;
 }
-#endif // TRANSCRIBE_ENABLE_VALIDATION_HOOKS
+#endif  // TRANSCRIBE_ENABLE_VALIDATION_HOOKS
 
 // Host-side RNN-T / CTC greedy decode of one utterance's encoder slice,
 // publishing the transcript into the session scratch slot (full_text /
@@ -266,41 +249,39 @@ transcribe_status decode_and_populate(GigaamSession * gc,
                                       const float *   encoded,
                                       int             T_enc,
                                       int             d_enc,
-                                      int             utt_index)
-{
+                                      int             utt_index) {
     const int64_t t_dec_start = ggml_time_us();
 
     // Per-utterance encoder-output dump (single-shot == reference; batched ==
     // batched-equals-single-shot gate). Matches parakeet's `dec.enc_out`.
     if (transcribe::debug::enabled()) {
         std::string dump_name = "dec.enc_out";
-        if (utt_index >= 0) dump_name += ".b" + std::to_string(utt_index);
-        const long long enc_shape[2] = {T_enc, d_enc};
-        transcribe::debug::dump_host_f32(
-            dump_name.c_str(), encoded,
-            static_cast<long long>(T_enc) * d_enc,
-            enc_shape, 2, "decoder.enc_out");
+        if (utt_index >= 0) {
+            dump_name += ".b" + std::to_string(utt_index);
+        }
+        const long long enc_shape[2] = { T_enc, d_enc };
+        transcribe::debug::dump_host_f32(dump_name.c_str(), encoded, static_cast<long long>(T_enc) * d_enc, enc_shape,
+                                         2, "decoder.enc_out");
     }
 
     std::vector<int> tokens;
     std::vector<int> frames;
 
     if (gm->hparams.head_kind == HeadKind::RNNT) {
-        if (auto st = decode_rnnt_greedy(gm->host_decoder, gm->hparams,
-                                          encoded, T_enc,
-                                          /*max_symbols=*/10,
-                                          tokens, frames);
-            st != TRANSCRIBE_OK) return st;
-    } else { // CTC
-        if (auto st = decode_ctc_greedy(gm->host_decoder, gm->hparams,
-                                         encoded, T_enc,
-                                         tokens, frames);
-            st != TRANSCRIBE_OK) return st;
+        if (auto st = decode_rnnt_greedy(gm->host_decoder, gm->hparams, encoded, T_enc,
+                                         /*max_symbols=*/10, tokens, frames);
+            st != TRANSCRIBE_OK) {
+            return st;
+        }
+    } else {  // CTC
+        if (auto st = decode_ctc_greedy(gm->host_decoder, gm->hparams, encoded, T_enc, tokens, frames);
+            st != TRANSCRIBE_OK) {
+            return st;
+        }
     }
     gc->t_decode_us = ggml_time_us() - t_dec_start;
 
-    std::string text = gm->tok.decode(tokens.data(),
-                                      static_cast<int>(tokens.size()));
+    std::string text = gm->tok.decode(tokens.data(), static_cast<int>(tokens.size()));
     // SentencePiece convention: the first token's leading ▁ is stripped on
     // decode. Our shared SP detokenizer maps every ▁ to a space, so trim a
     // single leading space here. Mirrors parakeet's post-decode.
@@ -327,13 +308,9 @@ transcribe_status decode_and_populate(GigaamSession * gc,
     return TRANSCRIBE_OK;
 }
 
-} // namespace
+}  // namespace
 
-transcribe_status run(transcribe_session *      session,
-                      const float *             pcm,
-                      int                       n_samples,
-                      const transcribe_run_params *)
-{
+transcribe_status run(transcribe_session * session, const float * pcm, int n_samples, const transcribe_run_params *) {
     if (session == nullptr || pcm == nullptr || n_samples <= 0) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
@@ -344,7 +321,9 @@ transcribe_status run(transcribe_session *      session,
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
 
-    if (gc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
+    if (gc->poll_abort()) {
+        return TRANSCRIBE_ERR_ABORTED;
+    }
 
     transcribe::debug::init();
 
@@ -354,17 +333,15 @@ transcribe_status run(transcribe_session *      session,
     {
         const int sr = gm->hparams.fe_sample_rate;
         if (sr > 0) {
-            const int64_t audio_ms =
-                static_cast<int64_t>(n_samples) * 1000 / sr;
+            const int64_t audio_ms = static_cast<int64_t>(n_samples) * 1000 / sr;
             if (audio_ms > k_safe_audio_ms) {
                 const double seconds = static_cast<double>(audio_ms) / 1000.0;
-                transcribe::log_msg(
-                    TRANSCRIBE_LOG_LEVEL_WARN,
-                    "gigaam run: audio is %.1f s, beyond the ~%d s window this "
-                    "model was trained on; transcription may be degraded. "
-                    "Split long audio into <=%d s segments. See "
-                    "transcribe_capabilities.max_audio_ms.",
-                    seconds, k_safe_s, k_safe_s);
+                transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_WARN,
+                                    "gigaam run: audio is %.1f s, beyond the ~%d s window this "
+                                    "model was trained on; transcription may be degraded. "
+                                    "Split long audio into <=%d s segments. See "
+                                    "transcribe_capabilities.max_audio_ms.",
+                                    seconds, k_safe_s, k_safe_s);
             }
         }
     }
@@ -372,34 +349,34 @@ transcribe_status run(transcribe_session *      session,
     // Mel acquisition: the family mel (HTK + power=2 + log-clamp +
     // center=False + periodic Hann). The env-var injection is a debug knob
     // for tensor-parity isolation.
-    int mel_n_frames = 0;
-    bool mel_from_ref = false;
-    const int64_t t_mel_start = ggml_time_us();
+    int           mel_n_frames = 0;
+    bool          mel_from_ref = false;
+    const int64_t t_mel_start  = ggml_time_us();
 #ifdef TRANSCRIBE_ENABLE_VALIDATION_HOOKS
     if (const char * ref_dir = transcribe::env::str("TRANSCRIBE_MEL_FROM_REF")) {
-        if (auto st = load_ref_mel(ref_dir, gm->hparams.fe_num_mels,
-                                   mel_n_frames, gc->mel_buf);
-            st != TRANSCRIBE_OK) return st;
+        if (auto st = load_ref_mel(ref_dir, gm->hparams.fe_num_mels, mel_n_frames, gc->mel_buf); st != TRANSCRIBE_OK) {
+            return st;
+        }
         mel_from_ref = true;
     }
 #endif
     if (!mel_from_ref) {
-        if (auto st = gm->mel.compute(pcm, static_cast<size_t>(n_samples),
-                                       gc->mel_buf, mel_n_frames);
-            st != TRANSCRIBE_OK) return st;
+        if (auto st = gm->mel.compute(pcm, static_cast<size_t>(n_samples), gc->mel_buf, mel_n_frames);
+            st != TRANSCRIBE_OK) {
+            return st;
+        }
     }
     gc->t_mel_us = ggml_time_us() - t_mel_start;
 
     {
-        const long long mel_shape[2] = {gm->hparams.fe_num_mels, mel_n_frames};
-        transcribe::debug::dump_host_f32(
-            "frontend.mel.out",
-            gc->mel_buf.data(),
-            static_cast<long long>(gc->mel_buf.size()),
-            mel_shape, 2, "frontend.mel");
+        const long long mel_shape[2] = { gm->hparams.fe_num_mels, mel_n_frames };
+        transcribe::debug::dump_host_f32("frontend.mel.out", gc->mel_buf.data(),
+                                         static_cast<long long>(gc->mel_buf.size()), mel_shape, 2, "frontend.mel");
     }
 
-    if (mel_n_frames <= 0) return TRANSCRIBE_ERR_GGUF;
+    if (mel_n_frames <= 0) {
+        return TRANSCRIBE_ERR_GGUF;
+    }
 
     // Reset per-call compute state.
     if (gc->compute_ctx != nullptr) {
@@ -409,64 +386,60 @@ transcribe_status run(transcribe_session *      session,
     gc->encoder_out = nullptr;
 
     {
-        ggml_init_params ip {};
-        ip.mem_size = 4 * 1024 * 1024;
-        ip.mem_buffer = nullptr;
-        ip.no_alloc = true;
+        ggml_init_params ip{};
+        ip.mem_size     = 4 * 1024 * 1024;
+        ip.mem_buffer   = nullptr;
+        ip.no_alloc     = true;
         gc->compute_ctx = ggml_init(ip);
         if (gc->compute_ctx == nullptr) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "gigaam run: compute context allocation failed — out of memory. "
-                "Split long audio into shorter segments (see "
-                "transcribe_capabilities.max_audio_ms).");
+                                "gigaam run: compute context allocation failed — out of memory. "
+                                "Split long audio into shorter segments (see "
+                                "transcribe_capabilities.max_audio_ms).");
             return TRANSCRIBE_ERR_OOM;
         }
     }
 
     // Build encoder graph.
-    EncoderBuild eb = build_encoder_graph(gc->compute_ctx,
-                                          gm->weights, gm->hparams,
-                                          mel_n_frames,
-                                          /*kv_type=*/GGML_TYPE_F32,
-                                          gm->backend.c_str());
+    EncoderBuild eb = build_encoder_graph(gc->compute_ctx, gm->weights, gm->hparams, mel_n_frames,
+                                          /*kv_type=*/GGML_TYPE_F32, gm->backend.c_str());
     if (eb.mel_in == nullptr || eb.out == nullptr || eb.graph == nullptr) {
         return TRANSCRIBE_ERR_GGUF;
     }
 
     // Scheduler.
     if (gc->sched == nullptr) {
-        gc->sched = ggml_backend_sched_new(
-            gm->plan.scheduler_list.data(), nullptr,
-            static_cast<int>(gm->plan.scheduler_list.size()),
-            /*graph_size=*/8192, /*parallel=*/false, /*op_offload=*/true);
+        gc->sched = ggml_backend_sched_new(gm->plan.scheduler_list.data(), nullptr,
+                                           static_cast<int>(gm->plan.scheduler_list.size()),
+                                           /*graph_size=*/8192, /*parallel=*/false, /*op_offload=*/true);
         if (gc->sched == nullptr) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "gigaam run: scheduler allocation failed — out of memory. "
-                "Split long audio into shorter segments (see "
-                "transcribe_capabilities.max_audio_ms).");
+                                "gigaam run: scheduler allocation failed — out of memory. "
+                                "Split long audio into shorter segments (see "
+                                "transcribe_capabilities.max_audio_ms).");
             return TRANSCRIBE_ERR_OOM;
         }
     }
     ggml_backend_sched_reset(gc->sched);
     if (!ggml_backend_sched_alloc_graph(gc->sched, eb.graph)) {
         transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "gigaam run: encoder graph allocation failed — out of memory. "
-            "Split long audio into shorter segments (see "
-            "transcribe_capabilities.max_audio_ms).");
+                            "gigaam run: encoder graph allocation failed — out of memory. "
+                            "Split long audio into shorter segments (see "
+                            "transcribe_capabilities.max_audio_ms).");
         return TRANSCRIBE_ERR_OOM;
     }
 
-    ggml_backend_tensor_set(eb.mel_in, gc->mel_buf.data(),
-                            0, gc->mel_buf.size() * sizeof(float));
+    ggml_backend_tensor_set(eb.mel_in, gc->mel_buf.data(), 0, gc->mel_buf.size() * sizeof(float));
     transcribe::debug::dump_tensor("enc.mel.in", eb.mel_in, "encoder.mel");
 
     // Upload positions [0, 1, ..., T_enc-1] as int32.
     if (eb.dumps.pos_emb != nullptr) {
-        const int64_t T_enc = eb.dumps.pos_emb->ne[0];
+        const int64_t        T_enc = eb.dumps.pos_emb->ne[0];
         std::vector<int32_t> pos(T_enc);
-        for (int64_t i = 0; i < T_enc; ++i) pos[i] = static_cast<int32_t>(i);
-        ggml_backend_tensor_set(eb.dumps.pos_emb, pos.data(), 0,
-                                pos.size() * sizeof(int32_t));
+        for (int64_t i = 0; i < T_enc; ++i) {
+            pos[i] = static_cast<int32_t>(i);
+        }
+        ggml_backend_tensor_set(eb.dumps.pos_emb, pos.data(), 0, pos.size() * sizeof(int32_t));
     }
 
     // Compute.
@@ -478,33 +451,31 @@ transcribe_status run(transcribe_session *      session,
     gc->t_encode_us = ggml_time_us() - t_enc_start;
 
     // Dump intermediates.
-    if (eb.dumps.pre_encode_out)
-        transcribe::debug::dump_tensor("enc.subsample.out",
-                                       eb.dumps.pre_encode_out, "encoder.subsample");
-    if (eb.dumps.block0_after_attn)
-        transcribe::debug::dump_tensor("enc.block.0.after_attn",
-                                       eb.dumps.block0_after_attn, "encoder.block.0");
-    if (eb.dumps.block0_after_conv)
-        transcribe::debug::dump_tensor("enc.block.0.after_conv",
-                                       eb.dumps.block0_after_conv, "encoder.block.0");
-    if (eb.dumps.block0_out)
-        transcribe::debug::dump_tensor("enc.block.0.out",
-                                       eb.dumps.block0_out, "encoder.block.0");
+    if (eb.dumps.pre_encode_out) {
+        transcribe::debug::dump_tensor("enc.subsample.out", eb.dumps.pre_encode_out, "encoder.subsample");
+    }
+    if (eb.dumps.block0_after_attn) {
+        transcribe::debug::dump_tensor("enc.block.0.after_attn", eb.dumps.block0_after_attn, "encoder.block.0");
+    }
+    if (eb.dumps.block0_after_conv) {
+        transcribe::debug::dump_tensor("enc.block.0.after_conv", eb.dumps.block0_after_conv, "encoder.block.0");
+    }
+    if (eb.dumps.block0_out) {
+        transcribe::debug::dump_tensor("enc.block.0.out", eb.dumps.block0_out, "encoder.block.0");
+    }
     if (eb.dumps.mid_block_out && eb.dumps.mid_block_idx >= 0) {
         char nm[32];
         std::snprintf(nm, sizeof(nm), "enc.block.%d.out", eb.dumps.mid_block_idx);
-        transcribe::debug::dump_tensor(nm, eb.dumps.mid_block_out,
-                                       "encoder.block.mid");
+        transcribe::debug::dump_tensor(nm, eb.dumps.mid_block_out, "encoder.block.mid");
     }
     if (eb.dumps.last_block_out && eb.dumps.last_block_idx >= 0) {
         char nm[32];
         std::snprintf(nm, sizeof(nm), "enc.block.%d.out", eb.dumps.last_block_idx);
-        transcribe::debug::dump_tensor(nm, eb.dumps.last_block_out,
-                                       "encoder.block.last");
+        transcribe::debug::dump_tensor(nm, eb.dumps.last_block_out, "encoder.block.last");
+    }
+    if (eb.dumps.final_out) {
+        transcribe::debug::dump_tensor("enc.out", eb.dumps.final_out, "encoder.out");
     }
-    if (eb.dumps.final_out)
-        transcribe::debug::dump_tensor("enc.out", eb.dumps.final_out,
-                                       "encoder.out");
 
     gc->encoder_out = eb.out;
 
@@ -521,20 +492,19 @@ transcribe_status run(transcribe_session *      session,
         const int T_enc = static_cast<int>(enc_t->ne[1]);
         const int D     = static_cast<int>(enc_t->ne[0]);
         gc->enc_host.assign(static_cast<size_t>(T_enc) * D, 0.0f);
-        ggml_backend_tensor_get(enc_t, gc->enc_host.data(), 0,
-                                gc->enc_host.size() * sizeof(float));
+        ggml_backend_tensor_get(enc_t, gc->enc_host.data(), 0, gc->enc_host.size() * sizeof(float));
 
         if (gm->hparams.head_kind == HeadKind::RNNT) {
-            const long long enc_shape[2] = {T_enc, D};
-            transcribe::debug::dump_host_f32(
-                "rnnt.encoded", gc->enc_host.data(),
-                static_cast<long long>(gc->enc_host.size()),
-                enc_shape, 2, "decoder.rnnt.encoded");
+            const long long enc_shape[2] = { T_enc, D };
+            transcribe::debug::dump_host_f32("rnnt.encoded", gc->enc_host.data(),
+                                             static_cast<long long>(gc->enc_host.size()), enc_shape, 2,
+                                             "decoder.rnnt.encoded");
         }
 
-        if (auto st = decode_and_populate(gc, gm, gc->enc_host.data(),
-                                          T_enc, D, /*utt_index=*/-1);
-            st != TRANSCRIBE_OK) return st;
+        if (auto st = decode_and_populate(gc, gm, gc->enc_host.data(), T_enc, D, /*utt_index=*/-1);
+            st != TRANSCRIBE_OK) {
+            return st;
+        }
     }
 
     return TRANSCRIBE_OK;
@@ -548,7 +518,9 @@ transcribe_status run(transcribe_session *      session,
 // host-slice (NOT per-utt offset reads, which are unreliable across backends).
 
 // One stride-2 conv with symmetric (k-1)/2 padding (matches encoder.cpp).
-static int batch_pre_encode_t_out(int in) { return (in - 1) / 2 + 1; }
+static int batch_pre_encode_t_out(int in) {
+    return (in - 1) / 2 + 1;
+}
 
 transcribe_status run_batch_encode(GigaamSession *                         gc,
                                    GigaamModel *                           gm,
@@ -556,12 +528,14 @@ transcribe_status run_batch_encode(GigaamSession *                         gc,
                                    const std::vector<int> &                nf,
                                    int                                     n_mels,
                                    int                                     T_max,
-                                   int64_t                                 total_mel_us)
-{
-    const int n = static_cast<int>(mels.size());
-    bool var_len = false;
+                                   int64_t                                 total_mel_us) {
+    const int n       = static_cast<int>(mels.size());
+    bool      var_len = false;
     for (int b = 0; b < n; ++b) {
-        if (nf[b] != T_max) { var_len = true; break; }
+        if (nf[b] != T_max) {
+            var_len = true;
+            break;
+        }
     }
 
     // Pack mels into [T_max, n_mels, n], zero-padding each along time
@@ -574,65 +548,66 @@ transcribe_status run_batch_encode(GigaamSession *                         gc,
     }
     gc->encoder_out = nullptr;
     {
-        ggml_init_params ip {};
-        ip.mem_size   = 4 * 1024 * 1024;
-        ip.mem_buffer = nullptr;
-        ip.no_alloc   = true;
+        ggml_init_params ip{};
+        ip.mem_size     = 4 * 1024 * 1024;
+        ip.mem_buffer   = nullptr;
+        ip.no_alloc     = true;
         gc->compute_ctx = ggml_init(ip);
         if (gc->compute_ctx == nullptr) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "gigaam run: compute context allocation failed — out of memory. "
-                "Split long audio into shorter segments (see "
-                "transcribe_capabilities.max_audio_ms).");
+                                "gigaam run: compute context allocation failed — out of memory. "
+                                "Split long audio into shorter segments (see "
+                                "transcribe_capabilities.max_audio_ms).");
             return TRANSCRIBE_ERR_OOM;
         }
     }
 
-    EncoderBuild eb = build_encoder_graph(
-        gc->compute_ctx, gm->weights, gm->hparams, T_max,
-        /*kv_type=*/GGML_TYPE_F32, gm->backend.c_str(),
-        /*n_batch=*/n, /*batch_var_len=*/var_len);
+    EncoderBuild eb = build_encoder_graph(gc->compute_ctx, gm->weights, gm->hparams, T_max,
+                                          /*kv_type=*/GGML_TYPE_F32, gm->backend.c_str(),
+                                          /*n_batch=*/n, /*batch_var_len=*/var_len);
     if (eb.mel_in == nullptr || eb.out == nullptr || eb.graph == nullptr) {
         return TRANSCRIBE_ERR_GGUF;
     }
 
     if (gc->sched == nullptr) {
-        gc->sched = ggml_backend_sched_new(
-            gm->plan.scheduler_list.data(), nullptr,
-            static_cast<int>(gm->plan.scheduler_list.size()),
-            /*graph_size=*/8192, /*parallel=*/false, /*op_offload=*/true);
+        gc->sched = ggml_backend_sched_new(gm->plan.scheduler_list.data(), nullptr,
+                                           static_cast<int>(gm->plan.scheduler_list.size()),
+                                           /*graph_size=*/8192, /*parallel=*/false, /*op_offload=*/true);
         if (gc->sched == nullptr) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "gigaam run: scheduler allocation failed — out of memory. "
-                "Split long audio into shorter segments (see "
-                "transcribe_capabilities.max_audio_ms).");
+                                "gigaam run: scheduler allocation failed — out of memory. "
+                                "Split long audio into shorter segments (see "
+                                "transcribe_capabilities.max_audio_ms).");
             return TRANSCRIBE_ERR_OOM;
         }
     }
     ggml_backend_sched_reset(gc->sched);
     if (!ggml_backend_sched_alloc_graph(gc->sched, eb.graph)) {
         transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "gigaam run: encoder graph allocation failed — out of memory. "
-            "Split long audio into shorter segments (see "
-            "transcribe_capabilities.max_audio_ms).");
+                            "gigaam run: encoder graph allocation failed — out of memory. "
+                            "Split long audio into shorter segments (see "
+                            "transcribe_capabilities.max_audio_ms).");
         return TRANSCRIBE_ERR_OOM;
     }
 
-    ggml_backend_tensor_set(eb.mel_in, gc->mel_buf.data(),
-                            0, gc->mel_buf.size() * sizeof(float));
+    ggml_backend_tensor_set(eb.mel_in, gc->mel_buf.data(), 0, gc->mel_buf.size() * sizeof(float));
 
     ggml_tensor * enc_t = eb.dumps.rnnt_encoded;  // [d_enc, T_enc, n]
-    if (enc_t == nullptr) return TRANSCRIBE_ERR_GGUF;
+    if (enc_t == nullptr) {
+        return TRANSCRIBE_ERR_GGUF;
+    }
     const int d_enc = static_cast<int>(enc_t->ne[0]);
     const int T_enc = static_cast<int>(enc_t->ne[1]);
-    if (d_enc <= 0 || T_enc <= 0) return TRANSCRIBE_ERR_GGUF;
+    if (d_enc <= 0 || T_enc <= 0) {
+        return TRANSCRIBE_ERR_GGUF;
+    }
 
     // Per-utterance valid encoder-frame count (two stride-2 pre-encode convs).
     std::vector<int> real_tenc(static_cast<size_t>(n), T_enc);
     if (var_len) {
         for (int b = 0; b < n; ++b) {
-            int t = batch_pre_encode_t_out(nf[b]);
-            t = batch_pre_encode_t_out(t);
+            int t        = batch_pre_encode_t_out(nf[b]);
+            t            = batch_pre_encode_t_out(t);
             real_tenc[b] = std::min(t, T_enc);
         }
         // Attention key-padding mask [T_enc, 1, 1, n] (0 real / -INF padded)
@@ -642,13 +617,19 @@ transcribe_status run_batch_encode(GigaamSession *                         gc,
         // Pre-encode masked-subsampling masks [T_stage, 1, n]: one per
         // conv-relu stage, valid time = mel length downsampled k times.
         auto fill_pe_mask = [&](ggml_tensor * mask, int n_down) {
-            if (mask == nullptr) return;
-            const int H = static_cast<int>(mask->ne[0]);
+            if (mask == nullptr) {
+                return;
+            }
+            const int          H = static_cast<int>(mask->ne[0]);
             std::vector<float> mb(static_cast<size_t>(H) * n, 0.0f);
             for (int b = 0; b < n; ++b) {
                 int v = nf[b];
-                for (int d = 0; d < n_down; ++d) v = batch_pre_encode_t_out(v);
-                if (v > H) v = H;
+                for (int d = 0; d < n_down; ++d) {
+                    v = batch_pre_encode_t_out(v);
+                }
+                if (v > H) {
+                    v = H;
+                }
                 for (int t = 0; t < v; ++t) {
                     mb[static_cast<size_t>(b) * H + t] = 1.0f;
                 }
@@ -662,9 +643,10 @@ transcribe_status run_batch_encode(GigaamSession *                         gc,
     // Rotary positions [0, 1, ..., T_enc-1] (batch-independent).
     if (eb.dumps.pos_emb != nullptr) {
         std::vector<int32_t> pos(static_cast<size_t>(T_enc));
-        for (int i = 0; i < T_enc; ++i) pos[i] = i;
-        ggml_backend_tensor_set(eb.dumps.pos_emb, pos.data(), 0,
-                                pos.size() * sizeof(int32_t));
+        for (int i = 0; i < T_enc; ++i) {
+            pos[i] = i;
+        }
+        ggml_backend_tensor_set(eb.dumps.pos_emb, pos.data(), 0, pos.size() * sizeof(int32_t));
     }
 
     // Set the per-backend thread count (mirrors single-shot through the
@@ -679,23 +661,21 @@ transcribe_status run_batch_encode(GigaamSession *                         gc,
     gc->t_encode_us = ggml_time_us() - t_enc_start;
 
     // Debug-only full [d, T, n] intermediates, gated on the env var.
-    if (transcribe::debug::enabled() &&
-        transcribe::debug::dump_all_blocks_requested())
-    {
+    if (transcribe::debug::enabled() && transcribe::debug::dump_all_blocks_requested()) {
         if (eb.dumps.pre_encode_out != nullptr) {
-            transcribe::debug::dump_tensor("enc.subsample.out",
-                                           eb.dumps.pre_encode_out,
-                                           "encoder.subsample");
+            transcribe::debug::dump_tensor("enc.subsample.out", eb.dumps.pre_encode_out, "encoder.subsample");
+        }
+        if (eb.dumps.block0_after_attn != nullptr) {
+            transcribe::debug::dump_tensor("enc.block.0.after_attn", eb.dumps.block0_after_attn, "encoder.block.0");
+        }
+        if (eb.dumps.block0_after_conv != nullptr) {
+            transcribe::debug::dump_tensor("enc.block.0.after_conv", eb.dumps.block0_after_conv, "encoder.block.0");
         }
-        if (eb.dumps.block0_after_attn != nullptr)
-            transcribe::debug::dump_tensor("enc.block.0.after_attn",
-                                           eb.dumps.block0_after_attn, "encoder.block.0");
-        if (eb.dumps.block0_after_conv != nullptr)
-            transcribe::debug::dump_tensor("enc.block.0.after_conv",
-                                           eb.dumps.block0_after_conv, "encoder.block.0");
         for (size_t i = 0; i < eb.dumps.all_block_outs.size(); ++i) {
             ggml_tensor * t = eb.dumps.all_block_outs[i];
-            if (t == nullptr) continue;
+            if (t == nullptr) {
+                continue;
+            }
             char nm[64];
             std::snprintf(nm, sizeof(nm), "enc.block.%zu.out", i);
             transcribe::debug::dump_tensor(nm, t, "encoder.block.bisect");
@@ -706,25 +686,22 @@ transcribe_status run_batch_encode(GigaamSession *                         gc,
     // offset reads are unreliable across backends).
     const size_t utt_elems = static_cast<size_t>(d_enc) * static_cast<size_t>(T_enc);
     gc->enc_host.assign(utt_elems * static_cast<size_t>(n), 0.0f);
-    ggml_backend_tensor_get(enc_t, gc->enc_host.data(), 0,
-                            gc->enc_host.size() * sizeof(float));
+    ggml_backend_tensor_get(enc_t, gc->enc_host.data(), 0, gc->enc_host.size() * sizeof(float));
 
     // Host-slice the shared encoder output and decode each utterance, with the
     // single shared encode + total mel cost amortized across the batch.
-    return transcribe::decode_batch_slices(
-        gc, n, gc->enc_host.data(), utt_elems, gc->t_encode_us, total_mel_us,
-        [&](int b, const float * enc_b) {
-            return decode_and_populate(gc, gm, enc_b, real_tenc[b], d_enc,
-                                       /*utt_index=*/b);
-        });
+    return transcribe::decode_batch_slices(gc, n, gc->enc_host.data(), utt_elems, gc->t_encode_us, total_mel_us,
+                                           [&](int b, const float * enc_b) {
+                                               return decode_and_populate(gc, gm, enc_b, real_tenc[b], d_enc,
+                                                                          /*utt_index=*/b);
+                                           });
 }
 
 transcribe_status run_batch(transcribe_session *          session,
                             const float * const *         pcm,
                             const int *                   n_samples,
                             int                           n,
-                            const transcribe_run_params * params)
-{
+                            const transcribe_run_params * params) {
     if (session == nullptr || pcm == nullptr || n_samples == nullptr || n <= 0) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
@@ -739,22 +716,23 @@ transcribe_status run_batch(transcribe_session *          session,
     // cross-utterance state). A malformed/failed utterance drops the whole
     // call to the per-utterance fallback so the batch tensor stays
     // rectangular and the masks stay well-defined.
-    const int n_mels = gm->hparams.fe_num_mels;
+    const int                       n_mels = gm->hparams.fe_num_mels;
     std::vector<std::vector<float>> mels(static_cast<size_t>(n));
     std::vector<int>                nf(static_cast<size_t>(n), 0);
-    const int64_t t_mel_start = ggml_time_us();
-    const bool all_ok = transcribe::parallel_for_all(
-        n, gc->n_threads, [&](int i) -> bool {
-            if (pcm[i] == nullptr || n_samples[i] <= 0) return false;
-            int this_frames = 0;
-            const transcribe_status st = gm->mel.compute(
-                pcm[i], static_cast<size_t>(n_samples[i]),
-                mels[i], this_frames);
-            if (st != TRANSCRIBE_OK || this_frames <= 0) return false;
-            nf[i] = this_frames;
-            return true;
-        });
-    const int64_t total_mel_us = ggml_time_us() - t_mel_start;
+    const int64_t                   t_mel_start  = ggml_time_us();
+    const bool                      all_ok       = transcribe::parallel_for_all(n, gc->n_threads, [&](int i) -> bool {
+        if (pcm[i] == nullptr || n_samples[i] <= 0) {
+            return false;
+        }
+        int                     this_frames = 0;
+        const transcribe_status st = gm->mel.compute(pcm[i], static_cast<size_t>(n_samples[i]), mels[i], this_frames);
+        if (st != TRANSCRIBE_OK || this_frames <= 0) {
+            return false;
+        }
+        nf[i] = this_frames;
+        return true;
+    });
+    const int64_t                   total_mel_us = ggml_time_us() - t_mel_start;
 
     if (all_ok) {
         // Per-utterance soft-window advisory before the shared encode; the
@@ -763,30 +741,31 @@ transcribe_status run_batch(transcribe_session *          session,
         const int sr = gm->hparams.fe_sample_rate;
         if (sr > 0) {
             for (int i = 0; i < n; ++i) {
-                const int64_t audio_ms =
-                    static_cast<int64_t>(n_samples[i]) * 1000 / sr;
+                const int64_t audio_ms = static_cast<int64_t>(n_samples[i]) * 1000 / sr;
                 if (audio_ms > k_safe_audio_ms) {
-                    const double seconds =
-                        static_cast<double>(audio_ms) / 1000.0;
-                    transcribe::log_msg(
-                        TRANSCRIBE_LOG_LEVEL_WARN,
-                        "gigaam run: audio is %.1f s, beyond the ~%d s window "
-                        "this model was trained on; transcription may be "
-                        "degraded. Split long audio into <=%d s segments. See "
-                        "transcribe_capabilities.max_audio_ms.",
-                        seconds, k_safe_s, k_safe_s);
+                    const double seconds = static_cast<double>(audio_ms) / 1000.0;
+                    transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_WARN,
+                                        "gigaam run: audio is %.1f s, beyond the ~%d s window "
+                                        "this model was trained on; transcription may be "
+                                        "degraded. Split long audio into <=%d s segments. See "
+                                        "transcribe_capabilities.max_audio_ms.",
+                                        seconds, k_safe_s, k_safe_s);
                 }
             }
         }
 
         int T_max = 0;
-        for (int i = 0; i < n; ++i) T_max = std::max(T_max, nf[i]);
+        for (int i = 0; i < n; ++i) {
+            T_max = std::max(T_max, nf[i]);
+        }
         return run_batch_encode(gc, gm, mels, nf, n_mels, T_max, total_mel_us);
     }
 
     // Per-utterance fallback (also the malformed-input path).
     for (int i = 0; i < n; ++i) {
-        if (gc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
+        if (gc->poll_abort()) {
+            return TRANSCRIBE_ERR_ABORTED;
+        }
         if (pcm[i] == nullptr || n_samples[i] <= 0) {
             transcribe_session::ResultSet rs;
             rs.status = TRANSCRIBE_ERR_INVALID_ARG;
@@ -800,20 +779,20 @@ transcribe_status run_batch(transcribe_session *          session,
     return TRANSCRIBE_OK;
 }
 
-} // namespace
+}  // namespace
 
 const Arch arch = {
-    /*.name             =*/ "gigaam",
-    /*.load             =*/ load,
-    /*.init_context     =*/ init_context,
-    /*.run              =*/ run,
-    /*.run_batch        =*/ run_batch,
-    /*.stream_validate  =*/ nullptr,
-    /*.stream_begin     =*/ nullptr,
-    /*.stream_feed      =*/ nullptr,
-    /*.stream_finalize  =*/ nullptr,
-    /*.stream_reset     =*/ nullptr,
-    /*.accepts_ext_kind =*/ nullptr,
+    /*.name             =*/"gigaam",
+    /*.load             =*/load,
+    /*.init_context     =*/init_context,
+    /*.run              =*/run,
+    /*.run_batch        =*/run_batch,
+    /*.stream_validate  =*/nullptr,
+    /*.stream_begin     =*/nullptr,
+    /*.stream_feed      =*/nullptr,
+    /*.stream_finalize  =*/nullptr,
+    /*.stream_reset     =*/nullptr,
+    /*.accepts_ext_kind =*/nullptr,
 };
 
-} // namespace transcribe::gigaam
+}  // namespace transcribe::gigaam
diff --git a/src/arch/gigaam/weights.cpp b/src/arch/gigaam/weights.cpp
index a9633991..14dc7e90 100644
--- a/src/arch/gigaam/weights.cpp
+++ b/src/arch/gigaam/weights.cpp
@@ -6,12 +6,11 @@
 
 #include "weights.h"
 
-#include "transcribe-meta.h"
-#include "transcribe-weights-util.h"
-#include "transcribe-log.h"
-
 #include "ggml.h"
 #include "gguf.h"
+#include "transcribe-log.h"
+#include "transcribe-meta.h"
+#include "transcribe-weights-util.h"
 
 #include <cstdio>
 #include <cstring>
@@ -22,105 +21,201 @@ namespace {
 
 constexpr const char * kFamilyTag = "gigaam";
 
-} // namespace
+}  // namespace
 
-transcribe_status read_gigaam_hparams(const gguf_context * gguf,
-                                      GigaamHParams &      hp)
-{
-    if (gguf == nullptr) return TRANSCRIBE_ERR_INVALID_ARG;
+transcribe_status read_gigaam_hparams(const gguf_context * gguf, GigaamHParams & hp) {
+    if (gguf == nullptr) {
+        return TRANSCRIBE_ERR_INVALID_ARG;
+    }
 
     // Head discriminator (drives RNN-T vs CTC reads below).
     {
         std::string head_kind_str;
-        if (auto st = read_required_string_kv(gguf, "stt.gigaam.head_kind",
-                                              kFamilyTag, head_kind_str);
-            st != TRANSCRIBE_OK) return st;
+        if (auto st = read_required_string_kv(gguf, "stt.gigaam.head_kind", kFamilyTag, head_kind_str);
+            st != TRANSCRIBE_OK) {
+            return st;
+        }
         if (head_kind_str == "rnnt") {
             hp.head_kind = HeadKind::RNNT;
         } else if (head_kind_str == "ctc") {
             hp.head_kind = HeadKind::CTC;
         } else {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "gigaam: unsupported stt.gigaam.head_kind=%s",
-                         head_kind_str.c_str());
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "gigaam: unsupported stt.gigaam.head_kind=%s", head_kind_str.c_str());
             return TRANSCRIBE_ERR_GGUF;
         }
     }
 
     // Encoder.
-    if (auto st = read_required_u32_kv(gguf, "stt.gigaam.encoder.n_layers",           kFamilyTag, hp.enc_n_layers);           st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.gigaam.encoder.d_model",            kFamilyTag, hp.enc_d_model);            st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.gigaam.encoder.n_heads",            kFamilyTag, hp.enc_n_heads);            st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.gigaam.encoder.d_ff",               kFamilyTag, hp.enc_d_ff);               st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.gigaam.encoder.conv_kernel",        kFamilyTag, hp.enc_conv_kernel);        st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.gigaam.encoder.subsampling_factor", kFamilyTag, hp.enc_subsampling_factor); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.gigaam.encoder.subs_kernel_size",   kFamilyTag, hp.enc_subs_kernel_size);   st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.gigaam.encoder.pos_emb_max_len",    kFamilyTag, hp.enc_pos_emb_max_len);    st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.gigaam.encoder.feat_in",            kFamilyTag, hp.enc_feat_in);            st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.gigaam.encoder.self_attention_model", kFamilyTag, hp.enc_self_attention_model); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.gigaam.encoder.conv_norm_type",  kFamilyTag, hp.enc_conv_norm_type);  st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_u32_kv(gguf, "stt.gigaam.encoder.n_layers", kFamilyTag, hp.enc_n_layers);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.gigaam.encoder.d_model", kFamilyTag, hp.enc_d_model);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.gigaam.encoder.n_heads", kFamilyTag, hp.enc_n_heads);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.gigaam.encoder.d_ff", kFamilyTag, hp.enc_d_ff); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.gigaam.encoder.conv_kernel", kFamilyTag, hp.enc_conv_kernel);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st =
+            read_required_u32_kv(gguf, "stt.gigaam.encoder.subsampling_factor", kFamilyTag, hp.enc_subsampling_factor);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st =
+            read_required_u32_kv(gguf, "stt.gigaam.encoder.subs_kernel_size", kFamilyTag, hp.enc_subs_kernel_size);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.gigaam.encoder.pos_emb_max_len", kFamilyTag, hp.enc_pos_emb_max_len);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.gigaam.encoder.feat_in", kFamilyTag, hp.enc_feat_in);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_string_kv(gguf, "stt.gigaam.encoder.self_attention_model", kFamilyTag,
+                                          hp.enc_self_attention_model);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_string_kv(gguf, "stt.gigaam.encoder.conv_norm_type", kFamilyTag, hp.enc_conv_norm_type);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     if (hp.enc_n_heads <= 0 || hp.enc_d_model % hp.enc_n_heads != 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "gigaam: invariant d_model %% n_heads != 0 "
-                     "(d_model=%d, n_heads=%d)",
-                     hp.enc_d_model, hp.enc_n_heads);
+                "gigaam: invariant d_model %% n_heads != 0 "
+                "(d_model=%d, n_heads=%d)",
+                hp.enc_d_model, hp.enc_n_heads);
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.enc_self_attention_model != "rotary") {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "gigaam: unsupported self_attention_model=%s (expected rotary)",
-                     hp.enc_self_attention_model.c_str());
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "gigaam: unsupported self_attention_model=%s (expected rotary)",
+                hp.enc_self_attention_model.c_str());
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.enc_conv_norm_type != "layer_norm") {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "gigaam: unsupported conv_norm_type=%s (expected layer_norm)",
-                     hp.enc_conv_norm_type.c_str());
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "gigaam: unsupported conv_norm_type=%s (expected layer_norm)",
+                hp.enc_conv_norm_type.c_str());
         return TRANSCRIBE_ERR_GGUF;
     }
 
     if (hp.head_kind == HeadKind::RNNT) {
-        if (auto st = read_required_u32_kv(gguf, "stt.gigaam.predictor.hidden",   kFamilyTag, hp.pred_hidden);   st != TRANSCRIBE_OK) return st;
-        if (auto st = read_required_u32_kv(gguf, "stt.gigaam.predictor.n_layers", kFamilyTag, hp.pred_n_layers); st != TRANSCRIBE_OK) return st;
-        if (auto st = read_required_u32_kv(gguf, "stt.gigaam.predictor.vocab",    kFamilyTag, hp.pred_vocab);    st != TRANSCRIBE_OK) return st;
-        if (auto st = read_required_u32_kv(gguf, "stt.gigaam.joint.hidden",       kFamilyTag, hp.joint_hidden);  st != TRANSCRIBE_OK) return st;
-        if (auto st = read_required_u32_kv(gguf, "stt.gigaam.joint.num_classes",  kFamilyTag, hp.joint_n_classes); st != TRANSCRIBE_OK) return st;
-        if (auto st = read_required_string_kv(gguf, "stt.gigaam.joint.activation", kFamilyTag, hp.joint_activation); st != TRANSCRIBE_OK) return st;
+        if (auto st = read_required_u32_kv(gguf, "stt.gigaam.predictor.hidden", kFamilyTag, hp.pred_hidden);
+            st != TRANSCRIBE_OK) {
+            return st;
+        }
+        if (auto st = read_required_u32_kv(gguf, "stt.gigaam.predictor.n_layers", kFamilyTag, hp.pred_n_layers);
+            st != TRANSCRIBE_OK) {
+            return st;
+        }
+        if (auto st = read_required_u32_kv(gguf, "stt.gigaam.predictor.vocab", kFamilyTag, hp.pred_vocab);
+            st != TRANSCRIBE_OK) {
+            return st;
+        }
+        if (auto st = read_required_u32_kv(gguf, "stt.gigaam.joint.hidden", kFamilyTag, hp.joint_hidden);
+            st != TRANSCRIBE_OK) {
+            return st;
+        }
+        if (auto st = read_required_u32_kv(gguf, "stt.gigaam.joint.num_classes", kFamilyTag, hp.joint_n_classes);
+            st != TRANSCRIBE_OK) {
+            return st;
+        }
+        if (auto st = read_required_string_kv(gguf, "stt.gigaam.joint.activation", kFamilyTag, hp.joint_activation);
+            st != TRANSCRIBE_OK) {
+            return st;
+        }
         if (hp.pred_vocab != hp.joint_n_classes) {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "gigaam: pred_vocab (%d) != joint_n_classes (%d)",
-                         hp.pred_vocab, hp.joint_n_classes);
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "gigaam: pred_vocab (%d) != joint_n_classes (%d)", hp.pred_vocab,
+                    hp.joint_n_classes);
             return TRANSCRIBE_ERR_GGUF;
         }
-    } else { // CTC
-        if (auto st = read_required_u32_kv(gguf, "stt.gigaam.head.feat_in",     kFamilyTag, hp.head_feat_in);   st != TRANSCRIBE_OK) return st;
-        if (auto st = read_required_u32_kv(gguf, "stt.gigaam.head.num_classes", kFamilyTag, hp.head_n_classes); st != TRANSCRIBE_OK) return st;
+    } else {  // CTC
+        if (auto st = read_required_u32_kv(gguf, "stt.gigaam.head.feat_in", kFamilyTag, hp.head_feat_in);
+            st != TRANSCRIBE_OK) {
+            return st;
+        }
+        if (auto st = read_required_u32_kv(gguf, "stt.gigaam.head.num_classes", kFamilyTag, hp.head_n_classes);
+            st != TRANSCRIBE_OK) {
+            return st;
+        }
         if (hp.head_feat_in != hp.enc_d_model) {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "gigaam: ctc head.feat_in (%d) != encoder.d_model (%d)",
-                         hp.head_feat_in, hp.enc_d_model);
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "gigaam: ctc head.feat_in (%d) != encoder.d_model (%d)",
+                    hp.head_feat_in, hp.enc_d_model);
             return TRANSCRIBE_ERR_GGUF;
         }
     }
 
     // Frontend.
-    if (auto st = read_required_string_kv(gguf, "stt.frontend.type",        kFamilyTag, hp.fe_type);        st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv   (gguf, "stt.frontend.num_mels",    kFamilyTag, hp.fe_num_mels);    st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv   (gguf, "stt.frontend.sample_rate", kFamilyTag, hp.fe_sample_rate); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv   (gguf, "stt.frontend.n_fft",       kFamilyTag, hp.fe_n_fft);       st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv   (gguf, "stt.frontend.win_length",  kFamilyTag, hp.fe_win_length);  st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv   (gguf, "stt.frontend.hop_length",  kFamilyTag, hp.fe_hop_length);  st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.frontend.window",      kFamilyTag, hp.fe_window);      st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.frontend.normalize",   kFamilyTag, hp.fe_normalize);   st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv   (gguf, "stt.frontend.dither",      kFamilyTag, hp.fe_dither);      st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv   (gguf, "stt.frontend.pre_emphasis",kFamilyTag, hp.fe_pre_emphasis);st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv   (gguf, "stt.frontend.f_min",       kFamilyTag, hp.fe_f_min);       st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv   (gguf, "stt.frontend.f_max",       kFamilyTag, hp.fe_f_max);       st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_bool_kv  (gguf, "stt.frontend.center",      kFamilyTag, false, hp.fe_center); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.frontend.mel_norm",    kFamilyTag, hp.fe_mel_norm);    st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv   (gguf, "stt.frontend.log_clamp_min", kFamilyTag, hp.fe_log_clamp_min); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv   (gguf, "stt.frontend.log_clamp_max", kFamilyTag, hp.fe_log_clamp_max); st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_string_kv(gguf, "stt.frontend.type", kFamilyTag, hp.fe_type); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.num_mels", kFamilyTag, hp.fe_num_mels);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.sample_rate", kFamilyTag, hp.fe_sample_rate);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.n_fft", kFamilyTag, hp.fe_n_fft); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.win_length", kFamilyTag, hp.fe_win_length);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.hop_length", kFamilyTag, hp.fe_hop_length);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_string_kv(gguf, "stt.frontend.window", kFamilyTag, hp.fe_window); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_string_kv(gguf, "stt.frontend.normalize", kFamilyTag, hp.fe_normalize);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.frontend.dither", kFamilyTag, hp.fe_dither); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.frontend.pre_emphasis", kFamilyTag, hp.fe_pre_emphasis);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.frontend.f_min", kFamilyTag, hp.fe_f_min); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.frontend.f_max", kFamilyTag, hp.fe_f_max); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_bool_kv(gguf, "stt.frontend.center", kFamilyTag, false, hp.fe_center);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_string_kv(gguf, "stt.frontend.mel_norm", kFamilyTag, hp.fe_mel_norm);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.frontend.log_clamp_min", kFamilyTag, hp.fe_log_clamp_min);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.frontend.log_clamp_max", kFamilyTag, hp.fe_log_clamp_max);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     return TRANSCRIBE_OK;
 }
@@ -129,141 +224,139 @@ transcribe_status read_gigaam_hparams(const gguf_context * gguf,
 // Weights catalog
 // ---------------------------------------------------------------------------
 
-#define GET_LN(slot, name) do { \
-    ggml_tensor * _t = transcribe::weights::find_tensor( \
-        ctx_meta, (name), {GGML_TYPE_F32}, \
-        {hp.enc_d_model}, kFamilyTag); \
-    if (_t == nullptr) return TRANSCRIBE_ERR_GGUF; \
-    (slot) = _t; \
-} while (0)
-
-#define GET_LIN_W(slot, name, in_dim, out_dim) do { \
-    ggml_tensor * _t = transcribe::weights::find_tensor( \
-        ctx_meta, (name), {TRANSCRIBE_QUANT_LINEAR_TYPES}, \
-        {(in_dim), (out_dim)}, kFamilyTag); \
-    if (_t == nullptr) return TRANSCRIBE_ERR_GGUF; \
-    (slot) = _t; \
-} while (0)
-
-#define GET_LIN_B(slot, name, out_dim) do { \
-    ggml_tensor * _t = transcribe::weights::find_tensor( \
-        ctx_meta, (name), {GGML_TYPE_F32}, \
-        {(out_dim)}, kFamilyTag); \
-    if (_t == nullptr) return TRANSCRIBE_ERR_GGUF; \
-    (slot) = _t; \
-} while (0)
-
-#define GET_CONV_W(slot, name, k, in_dim, out_dim) do { \
-    ggml_tensor * _t = transcribe::weights::find_tensor( \
-        ctx_meta, (name), {TRANSCRIBE_QUANT_CONV_TYPES}, \
-        {(k), (in_dim), (out_dim)}, kFamilyTag); \
-    if (_t == nullptr) return TRANSCRIBE_ERR_GGUF; \
-    (slot) = _t; \
-} while (0)
-
-#define GET_F32_1D(slot, name, n) do { \
-    ggml_tensor * _t = transcribe::weights::find_tensor( \
-        ctx_meta, (name), {GGML_TYPE_F32}, \
-        {(n)}, kFamilyTag); \
-    if (_t == nullptr) return TRANSCRIBE_ERR_GGUF; \
-    (slot) = _t; \
-} while (0)
-
-#define GET_F32_2D(slot, name, n0, n1) do { \
-    ggml_tensor * _t = transcribe::weights::find_tensor( \
-        ctx_meta, (name), {GGML_TYPE_F32}, \
-        {(n0), (n1)}, kFamilyTag); \
-    if (_t == nullptr) return TRANSCRIBE_ERR_GGUF; \
-    (slot) = _t; \
-} while (0)
+#define GET_LN(slot, name)                                                                                         \
+    do {                                                                                                           \
+        ggml_tensor * _t =                                                                                         \
+            transcribe::weights::find_tensor(ctx_meta, (name), { GGML_TYPE_F32 }, { hp.enc_d_model }, kFamilyTag); \
+        if (_t == nullptr)                                                                                         \
+            return TRANSCRIBE_ERR_GGUF;                                                                            \
+        (slot) = _t;                                                                                               \
+    } while (0)
+
+#define GET_LIN_W(slot, name, in_dim, out_dim)                                                                   \
+    do {                                                                                                         \
+        ggml_tensor * _t = transcribe::weights::find_tensor(ctx_meta, (name), { TRANSCRIBE_QUANT_LINEAR_TYPES }, \
+                                                            { (in_dim), (out_dim) }, kFamilyTag);                \
+        if (_t == nullptr)                                                                                       \
+            return TRANSCRIBE_ERR_GGUF;                                                                          \
+        (slot) = _t;                                                                                             \
+    } while (0)
+
+#define GET_LIN_B(slot, name, out_dim)                                                                        \
+    do {                                                                                                      \
+        ggml_tensor * _t =                                                                                    \
+            transcribe::weights::find_tensor(ctx_meta, (name), { GGML_TYPE_F32 }, { (out_dim) }, kFamilyTag); \
+        if (_t == nullptr)                                                                                    \
+            return TRANSCRIBE_ERR_GGUF;                                                                       \
+        (slot) = _t;                                                                                          \
+    } while (0)
+
+#define GET_CONV_W(slot, name, k, in_dim, out_dim)                                                             \
+    do {                                                                                                       \
+        ggml_tensor * _t = transcribe::weights::find_tensor(ctx_meta, (name), { TRANSCRIBE_QUANT_CONV_TYPES }, \
+                                                            { (k), (in_dim), (out_dim) }, kFamilyTag);         \
+        if (_t == nullptr)                                                                                     \
+            return TRANSCRIBE_ERR_GGUF;                                                                        \
+        (slot) = _t;                                                                                           \
+    } while (0)
+
+#define GET_F32_1D(slot, name, n)                                                                                      \
+    do {                                                                                                               \
+        ggml_tensor * _t = transcribe::weights::find_tensor(ctx_meta, (name), { GGML_TYPE_F32 }, { (n) }, kFamilyTag); \
+        if (_t == nullptr)                                                                                             \
+            return TRANSCRIBE_ERR_GGUF;                                                                                \
+        (slot) = _t;                                                                                                   \
+    } while (0)
+
+#define GET_F32_2D(slot, name, n0, n1)                                                                         \
+    do {                                                                                                       \
+        ggml_tensor * _t =                                                                                     \
+            transcribe::weights::find_tensor(ctx_meta, (name), { GGML_TYPE_F32 }, { (n0), (n1) }, kFamilyTag); \
+        if (_t == nullptr)                                                                                     \
+            return TRANSCRIBE_ERR_GGUF;                                                                        \
+        (slot) = _t;                                                                                           \
+    } while (0)
 
 using transcribe::weights::lname;
 
 namespace {
 
-transcribe_status build_block(ggml_context *        ctx_meta,
-                              const GigaamHParams & hp,
-                              int                   i,
-                              GigaamBlock &         b)
-{
-    const int d = hp.enc_d_model;
-    const int dff = hp.enc_d_ff;
+transcribe_status build_block(ggml_context * ctx_meta, const GigaamHParams & hp, int i, GigaamBlock & b) {
+    const int d    = hp.enc_d_model;
+    const int dff  = hp.enc_d_ff;
     const int dw_k = hp.enc_conv_kernel;
 
-    GET_LN  (b.norm_ff1_w, lname("enc.blocks.%d.norm_ff1.weight", i));
-    GET_LN  (b.norm_ff1_b, lname("enc.blocks.%d.norm_ff1.bias",   i));
-    GET_LIN_W(b.ff1_lin1_w, lname("enc.blocks.%d.ff1.linear1.weight", i), d,   dff);
-    GET_LIN_B(b.ff1_lin1_b, lname("enc.blocks.%d.ff1.linear1.bias",   i), dff);
+    GET_LN(b.norm_ff1_w, lname("enc.blocks.%d.norm_ff1.weight", i));
+    GET_LN(b.norm_ff1_b, lname("enc.blocks.%d.norm_ff1.bias", i));
+    GET_LIN_W(b.ff1_lin1_w, lname("enc.blocks.%d.ff1.linear1.weight", i), d, dff);
+    GET_LIN_B(b.ff1_lin1_b, lname("enc.blocks.%d.ff1.linear1.bias", i), dff);
     GET_LIN_W(b.ff1_lin2_w, lname("enc.blocks.%d.ff1.linear2.weight", i), dff, d);
-    GET_LIN_B(b.ff1_lin2_b, lname("enc.blocks.%d.ff1.linear2.bias",   i), d);
+    GET_LIN_B(b.ff1_lin2_b, lname("enc.blocks.%d.ff1.linear2.bias", i), d);
 
-    GET_LN  (b.norm_conv_w, lname("enc.blocks.%d.norm_conv.weight", i));
-    GET_LN  (b.norm_conv_b, lname("enc.blocks.%d.norm_conv.bias",   i));
+    GET_LN(b.norm_conv_w, lname("enc.blocks.%d.norm_conv.weight", i));
+    GET_LN(b.norm_conv_b, lname("enc.blocks.%d.norm_conv.bias", i));
     GET_CONV_W(b.conv_pw1_w, lname("enc.blocks.%d.conv.pointwise1.weight", i), 1, d, 2 * d);
-    GET_LIN_B (b.conv_pw1_b, lname("enc.blocks.%d.conv.pointwise1.bias",   i), 2 * d);
-    GET_CONV_W(b.conv_dw_w,  lname("enc.blocks.%d.conv.depthwise.weight", i), dw_k, 1, d);
-    GET_LIN_B (b.conv_dw_b,  lname("enc.blocks.%d.conv.depthwise.bias",   i), d);
-    GET_LN  (b.conv_ln_w,    lname("enc.blocks.%d.conv.ln.weight", i));
-    GET_LN  (b.conv_ln_b,    lname("enc.blocks.%d.conv.ln.bias",   i));
+    GET_LIN_B(b.conv_pw1_b, lname("enc.blocks.%d.conv.pointwise1.bias", i), 2 * d);
+    GET_CONV_W(b.conv_dw_w, lname("enc.blocks.%d.conv.depthwise.weight", i), dw_k, 1, d);
+    GET_LIN_B(b.conv_dw_b, lname("enc.blocks.%d.conv.depthwise.bias", i), d);
+    GET_LN(b.conv_ln_w, lname("enc.blocks.%d.conv.ln.weight", i));
+    GET_LN(b.conv_ln_b, lname("enc.blocks.%d.conv.ln.bias", i));
     GET_CONV_W(b.conv_pw2_w, lname("enc.blocks.%d.conv.pointwise2.weight", i), 1, d, d);
-    GET_LIN_B (b.conv_pw2_b, lname("enc.blocks.%d.conv.pointwise2.bias",   i), d);
+    GET_LIN_B(b.conv_pw2_b, lname("enc.blocks.%d.conv.pointwise2.bias", i), d);
 
     // Self-attention (rotary, no linear_pos / pos_bias_*).
-    GET_LN  (b.norm_attn_w, lname("enc.blocks.%d.norm_attn.weight", i));
-    GET_LN  (b.norm_attn_b, lname("enc.blocks.%d.norm_attn.bias",   i));
-    GET_LIN_W(b.attn_q_w,   lname("enc.blocks.%d.attn.linear_q.weight",   i), d, d);
-    GET_LIN_B(b.attn_q_b,   lname("enc.blocks.%d.attn.linear_q.bias",     i), d);
-    GET_LIN_W(b.attn_k_w,   lname("enc.blocks.%d.attn.linear_k.weight",   i), d, d);
-    GET_LIN_B(b.attn_k_b,   lname("enc.blocks.%d.attn.linear_k.bias",     i), d);
-    GET_LIN_W(b.attn_v_w,   lname("enc.blocks.%d.attn.linear_v.weight",   i), d, d);
-    GET_LIN_B(b.attn_v_b,   lname("enc.blocks.%d.attn.linear_v.bias",     i), d);
+    GET_LN(b.norm_attn_w, lname("enc.blocks.%d.norm_attn.weight", i));
+    GET_LN(b.norm_attn_b, lname("enc.blocks.%d.norm_attn.bias", i));
+    GET_LIN_W(b.attn_q_w, lname("enc.blocks.%d.attn.linear_q.weight", i), d, d);
+    GET_LIN_B(b.attn_q_b, lname("enc.blocks.%d.attn.linear_q.bias", i), d);
+    GET_LIN_W(b.attn_k_w, lname("enc.blocks.%d.attn.linear_k.weight", i), d, d);
+    GET_LIN_B(b.attn_k_b, lname("enc.blocks.%d.attn.linear_k.bias", i), d);
+    GET_LIN_W(b.attn_v_w, lname("enc.blocks.%d.attn.linear_v.weight", i), d, d);
+    GET_LIN_B(b.attn_v_b, lname("enc.blocks.%d.attn.linear_v.bias", i), d);
     GET_LIN_W(b.attn_out_w, lname("enc.blocks.%d.attn.linear_out.weight", i), d, d);
-    GET_LIN_B(b.attn_out_b, lname("enc.blocks.%d.attn.linear_out.bias",   i), d);
+    GET_LIN_B(b.attn_out_b, lname("enc.blocks.%d.attn.linear_out.bias", i), d);
 
-    GET_LN  (b.norm_ff2_w, lname("enc.blocks.%d.norm_ff2.weight", i));
-    GET_LN  (b.norm_ff2_b, lname("enc.blocks.%d.norm_ff2.bias",   i));
-    GET_LIN_W(b.ff2_lin1_w, lname("enc.blocks.%d.ff2.linear1.weight", i), d,   dff);
-    GET_LIN_B(b.ff2_lin1_b, lname("enc.blocks.%d.ff2.linear1.bias",   i), dff);
+    GET_LN(b.norm_ff2_w, lname("enc.blocks.%d.norm_ff2.weight", i));
+    GET_LN(b.norm_ff2_b, lname("enc.blocks.%d.norm_ff2.bias", i));
+    GET_LIN_W(b.ff2_lin1_w, lname("enc.blocks.%d.ff2.linear1.weight", i), d, dff);
+    GET_LIN_B(b.ff2_lin1_b, lname("enc.blocks.%d.ff2.linear1.bias", i), dff);
     GET_LIN_W(b.ff2_lin2_w, lname("enc.blocks.%d.ff2.linear2.weight", i), dff, d);
-    GET_LIN_B(b.ff2_lin2_b, lname("enc.blocks.%d.ff2.linear2.bias",   i), d);
+    GET_LIN_B(b.ff2_lin2_b, lname("enc.blocks.%d.ff2.linear2.bias", i), d);
 
-    GET_LN  (b.norm_out_w, lname("enc.blocks.%d.norm_out.weight", i));
-    GET_LN  (b.norm_out_b, lname("enc.blocks.%d.norm_out.bias",   i));
+    GET_LN(b.norm_out_w, lname("enc.blocks.%d.norm_out.weight", i));
+    GET_LN(b.norm_out_b, lname("enc.blocks.%d.norm_out.bias", i));
 
     return TRANSCRIBE_OK;
 }
 
-} // namespace
+}  // namespace
 
-transcribe_status build_gigaam_weights(ggml_context *        ctx_meta,
-                                       const GigaamHParams & hp,
-                                       GigaamWeights &       weights)
-{
-    if (ctx_meta == nullptr) return TRANSCRIBE_ERR_INVALID_ARG;
+transcribe_status build_gigaam_weights(ggml_context * ctx_meta, const GigaamHParams & hp, GigaamWeights & weights) {
+    if (ctx_meta == nullptr) {
+        return TRANSCRIBE_ERR_INVALID_ARG;
+    }
 
-    const int d   = hp.enc_d_model;
+    const int d       = hp.enc_d_model;
     const int feat_in = hp.enc_feat_in;
-    const int sub_k = hp.enc_subs_kernel_size;
-    const int n_freq = hp.fe_n_fft / 2 + 1;
+    const int sub_k   = hp.enc_subs_kernel_size;
+    const int n_freq  = hp.fe_n_fft / 2 + 1;
 
     // Frontend buffers (baked into the GGUF by the converter).
-    GET_F32_2D(weights.frontend_mel_filterbank,
-               "frontend.mel_filterbank", n_freq, hp.fe_num_mels);
+    GET_F32_2D(weights.frontend_mel_filterbank, "frontend.mel_filterbank", n_freq, hp.fe_num_mels);
     GET_F32_1D(weights.frontend_window, "frontend.window", hp.fe_win_length);
 
     // Pre-encode (2 stride-2 conv1d).
-    GET_CONV_W(weights.pre_encode.conv0_w, "enc.pre_encode.conv.0.weight",
-               sub_k, feat_in, d);
-    GET_LIN_B (weights.pre_encode.conv0_b, "enc.pre_encode.conv.0.bias", d);
-    GET_CONV_W(weights.pre_encode.conv2_w, "enc.pre_encode.conv.2.weight",
-               sub_k, d, d);
-    GET_LIN_B (weights.pre_encode.conv2_b, "enc.pre_encode.conv.2.bias", d);
+    GET_CONV_W(weights.pre_encode.conv0_w, "enc.pre_encode.conv.0.weight", sub_k, feat_in, d);
+    GET_LIN_B(weights.pre_encode.conv0_b, "enc.pre_encode.conv.0.bias", d);
+    GET_CONV_W(weights.pre_encode.conv2_w, "enc.pre_encode.conv.2.weight", sub_k, d, d);
+    GET_LIN_B(weights.pre_encode.conv2_b, "enc.pre_encode.conv.2.bias", d);
 
     // Conformer blocks.
     weights.blocks.resize(hp.enc_n_layers);
     for (int i = 0; i < hp.enc_n_layers; ++i) {
-        if (auto st = build_block(ctx_meta, hp, i, weights.blocks[i]);
-            st != TRANSCRIBE_OK) return st;
+        if (auto st = build_block(ctx_meta, hp, i, weights.blocks[i]); st != TRANSCRIBE_OK) {
+            return st;
+        }
     }
 
     // Head.
@@ -273,33 +366,28 @@ transcribe_status build_gigaam_weights(ggml_context *        ctx_meta,
         // tile (TRANSCRIBE_QUANT_LINEAR_TYPES: F32/F16/Q*), so the loader
         // must too. decoder.cpp's readback_f32 dequantizes once at load
         // time via ggml type traits.
-        GET_LIN_W(weights.predictor.embed_w, "pred.embed.weight",
-                  hp.pred_hidden, hp.pred_vocab);
+        GET_LIN_W(weights.predictor.embed_w, "pred.embed.weight", hp.pred_hidden, hp.pred_vocab);
 
         weights.predictor.lstm.resize(hp.pred_n_layers);
         for (int i = 0; i < hp.pred_n_layers; ++i) {
             auto & L = weights.predictor.lstm[i];
             // PyTorch nn.LSTM packs 4 gates along the row dim.
-            GET_LIN_W(L.Wx, lname("pred.lstm.%d.Wx", i),
-                      hp.pred_hidden, 4 * hp.pred_hidden);
-            GET_LIN_W(L.Wh, lname("pred.lstm.%d.Wh", i),
-                      hp.pred_hidden, 4 * hp.pred_hidden);
-            GET_LIN_B(L.b,  lname("pred.lstm.%d.bias", i),
-                      4 * hp.pred_hidden);
+            GET_LIN_W(L.Wx, lname("pred.lstm.%d.Wx", i), hp.pred_hidden, 4 * hp.pred_hidden);
+            GET_LIN_W(L.Wh, lname("pred.lstm.%d.Wh", i), hp.pred_hidden, 4 * hp.pred_hidden);
+            GET_LIN_B(L.b, lname("pred.lstm.%d.bias", i), 4 * hp.pred_hidden);
         }
-        GET_LIN_W(weights.joint.enc_w,  "joint.enc.weight",  d,   hp.joint_hidden);
-        GET_LIN_B(weights.joint.enc_b,  "joint.enc.bias",         hp.joint_hidden);
+        GET_LIN_W(weights.joint.enc_w, "joint.enc.weight", d, hp.joint_hidden);
+        GET_LIN_B(weights.joint.enc_b, "joint.enc.bias", hp.joint_hidden);
         GET_LIN_W(weights.joint.pred_w, "joint.pred.weight", hp.pred_hidden, hp.joint_hidden);
-        GET_LIN_B(weights.joint.pred_b, "joint.pred.bias",         hp.joint_hidden);
-        GET_LIN_W(weights.joint.out_w,  "joint.out.weight",  hp.joint_hidden, hp.joint_n_classes);
-        GET_LIN_B(weights.joint.out_b,  "joint.out.bias",         hp.joint_n_classes);
-    } else { // CTC
-        GET_CONV_W(weights.ctc_head.weight, "head.ctc.weight",
-                   1, d, hp.head_n_classes);
-        GET_LIN_B (weights.ctc_head.bias,   "head.ctc.bias", hp.head_n_classes);
+        GET_LIN_B(weights.joint.pred_b, "joint.pred.bias", hp.joint_hidden);
+        GET_LIN_W(weights.joint.out_w, "joint.out.weight", hp.joint_hidden, hp.joint_n_classes);
+        GET_LIN_B(weights.joint.out_b, "joint.out.bias", hp.joint_n_classes);
+    } else {  // CTC
+        GET_CONV_W(weights.ctc_head.weight, "head.ctc.weight", 1, d, hp.head_n_classes);
+        GET_LIN_B(weights.ctc_head.bias, "head.ctc.bias", hp.head_n_classes);
     }
 
     return TRANSCRIBE_OK;
 }
 
-} // namespace transcribe::gigaam
+}  // namespace transcribe::gigaam
diff --git a/src/arch/gigaam/weights.h b/src/arch/gigaam/weights.h
index cc16f272..37346350 100644
--- a/src/arch/gigaam/weights.h
+++ b/src/arch/gigaam/weights.h
@@ -45,15 +45,15 @@ struct GigaamHParams {
     HeadKind head_kind = HeadKind::RNNT;
 
     // Encoder (Conformer).
-    int32_t enc_n_layers          = 0;
-    int32_t enc_d_model           = 0;
-    int32_t enc_n_heads           = 0;
-    int32_t enc_d_ff              = 0;
-    int32_t enc_conv_kernel       = 0;
-    int32_t enc_subsampling_factor = 0;
-    int32_t enc_subs_kernel_size  = 0;
-    int32_t enc_pos_emb_max_len   = 0;
-    int32_t enc_feat_in           = 0;
+    int32_t     enc_n_layers           = 0;
+    int32_t     enc_d_model            = 0;
+    int32_t     enc_n_heads            = 0;
+    int32_t     enc_d_ff               = 0;
+    int32_t     enc_conv_kernel        = 0;
+    int32_t     enc_subsampling_factor = 0;
+    int32_t     enc_subs_kernel_size   = 0;
+    int32_t     enc_pos_emb_max_len    = 0;
+    int32_t     enc_feat_in            = 0;
     // Recorded for documentation; today only "rotary" is in scope.
     std::string enc_self_attention_model;
     // Conv module normalisation. GigaAM always ships "layer_norm" but
@@ -61,20 +61,20 @@ struct GigaamHParams {
     std::string enc_conv_norm_type;
 
     // RNN-T predictor + joint (HeadKind::RNNT only).
-    int32_t pred_hidden    = 0;
-    int32_t pred_n_layers  = 0;
-    int32_t pred_vocab     = 0;
-    int32_t joint_hidden   = 0;
-    int32_t joint_n_classes = 0;
+    int32_t     pred_hidden     = 0;
+    int32_t     pred_n_layers   = 0;
+    int32_t     pred_vocab      = 0;
+    int32_t     joint_hidden    = 0;
+    int32_t     joint_n_classes = 0;
     std::string joint_activation;
 
     // CTC head (HeadKind::CTC only). Stored separately so the same
     // hparam struct can describe both head kinds.
-    int32_t head_feat_in     = 0;
-    int32_t head_n_classes   = 0;
+    int32_t head_feat_in   = 0;
+    int32_t head_n_classes = 0;
 
     // Frontend.
-    std::string fe_type;       // "mel"
+    std::string fe_type;  // "mel"
     int32_t     fe_num_mels    = 0;
     int32_t     fe_sample_rate = 0;
     int32_t     fe_n_fft       = 0;
@@ -87,17 +87,14 @@ struct GigaamHParams {
     float       fe_f_min        = 0.0f;
     float       fe_f_max        = 0.0f;
     bool        fe_center       = false;
-    std::string fe_mel_norm;   // "htk"
+    std::string fe_mel_norm;  // "htk"
     float       fe_log_clamp_min = 1e-9f;
     float       fe_log_clamp_max = 1e9f;
 
-    int32_t enc_head_dim() const {
-        return enc_n_heads > 0 ? enc_d_model / enc_n_heads : 0;
-    }
+    int32_t enc_head_dim() const { return enc_n_heads > 0 ? enc_d_model / enc_n_heads : 0; }
 };
 
-transcribe_status read_gigaam_hparams(const gguf_context * gguf,
-                                      GigaamHParams &      hp);
+transcribe_status read_gigaam_hparams(const gguf_context * gguf, GigaamHParams & hp);
 
 // ---------------------------------------------------------------------------
 // Weight slots
@@ -105,10 +102,10 @@ transcribe_status read_gigaam_hparams(const gguf_context * gguf,
 
 struct GigaamPreEncode {
     // 2 stride-2 conv1d layers (the in-between ReLU is stateless).
-    ggml_tensor * conv0_w = nullptr; // [k=5, in=64,  out=768]
-    ggml_tensor * conv0_b = nullptr; // [768]
-    ggml_tensor * conv2_w = nullptr; // [k=5, in=768, out=768]
-    ggml_tensor * conv2_b = nullptr; // [768]
+    ggml_tensor * conv0_w = nullptr;  // [k=5, in=64,  out=768]
+    ggml_tensor * conv0_b = nullptr;  // [768]
+    ggml_tensor * conv2_w = nullptr;  // [k=5, in=768, out=768]
+    ggml_tensor * conv2_b = nullptr;  // [768]
 };
 
 // One Conformer block. All biases present (GigaAM is always-bias).
@@ -116,34 +113,34 @@ struct GigaamBlock {
     // Macaron FF1.
     ggml_tensor * norm_ff1_w = nullptr;
     ggml_tensor * norm_ff1_b = nullptr;
-    ggml_tensor * ff1_lin1_w = nullptr; // [d_ff,    d_model]
+    ggml_tensor * ff1_lin1_w = nullptr;  // [d_ff,    d_model]
     ggml_tensor * ff1_lin1_b = nullptr;
-    ggml_tensor * ff1_lin2_w = nullptr; // [d_model, d_ff]
+    ggml_tensor * ff1_lin2_w = nullptr;  // [d_model, d_ff]
     ggml_tensor * ff1_lin2_b = nullptr;
 
     // Conv module (LayerNorm post-depthwise).
     ggml_tensor * norm_conv_w = nullptr;
     ggml_tensor * norm_conv_b = nullptr;
-    ggml_tensor * conv_pw1_w  = nullptr; // [k=1, in=d_model, out=2*d_model]
-    ggml_tensor * conv_pw1_b  = nullptr; // [2*d_model]
-    ggml_tensor * conv_dw_w   = nullptr; // [k=conv_kernel, 1, d_model]
-    ggml_tensor * conv_dw_b   = nullptr; // [d_model]
-    ggml_tensor * conv_ln_w   = nullptr; // [d_model]
-    ggml_tensor * conv_ln_b   = nullptr; // [d_model]
-    ggml_tensor * conv_pw2_w  = nullptr; // [k=1, in=d_model, out=d_model]
-    ggml_tensor * conv_pw2_b  = nullptr; // [d_model]
+    ggml_tensor * conv_pw1_w  = nullptr;  // [k=1, in=d_model, out=2*d_model]
+    ggml_tensor * conv_pw1_b  = nullptr;  // [2*d_model]
+    ggml_tensor * conv_dw_w   = nullptr;  // [k=conv_kernel, 1, d_model]
+    ggml_tensor * conv_dw_b   = nullptr;  // [d_model]
+    ggml_tensor * conv_ln_w   = nullptr;  // [d_model]
+    ggml_tensor * conv_ln_b   = nullptr;  // [d_model]
+    ggml_tensor * conv_pw2_w  = nullptr;  // [k=1, in=d_model, out=d_model]
+    ggml_tensor * conv_pw2_b  = nullptr;  // [d_model]
 
     // Self-attention (rotary). No linear_pos / pos_bias_*.
-    ggml_tensor * norm_attn_w   = nullptr;
-    ggml_tensor * norm_attn_b   = nullptr;
-    ggml_tensor * attn_q_w      = nullptr; // [d_model, d_model]
-    ggml_tensor * attn_q_b      = nullptr;
-    ggml_tensor * attn_k_w      = nullptr;
-    ggml_tensor * attn_k_b      = nullptr;
-    ggml_tensor * attn_v_w      = nullptr;
-    ggml_tensor * attn_v_b      = nullptr;
-    ggml_tensor * attn_out_w    = nullptr;
-    ggml_tensor * attn_out_b    = nullptr;
+    ggml_tensor * norm_attn_w = nullptr;
+    ggml_tensor * norm_attn_b = nullptr;
+    ggml_tensor * attn_q_w    = nullptr;  // [d_model, d_model]
+    ggml_tensor * attn_q_b    = nullptr;
+    ggml_tensor * attn_k_w    = nullptr;
+    ggml_tensor * attn_k_b    = nullptr;
+    ggml_tensor * attn_v_w    = nullptr;
+    ggml_tensor * attn_v_b    = nullptr;
+    ggml_tensor * attn_out_w  = nullptr;
+    ggml_tensor * attn_out_b  = nullptr;
 
     // Macaron FF2.
     ggml_tensor * norm_ff2_w = nullptr;
@@ -160,36 +157,38 @@ struct GigaamBlock {
 
 // RNN-T predictor (only when head_kind=RNNT).
 struct GigaamPredictor {
-    ggml_tensor * embed_w = nullptr; // [pred_vocab, pred_hidden]
+    ggml_tensor * embed_w = nullptr;  // [pred_vocab, pred_hidden]
+
     struct LstmLayer {
-        ggml_tensor * Wx = nullptr; // [4*pred_hidden, pred_hidden]
-        ggml_tensor * Wh = nullptr; // [4*pred_hidden, pred_hidden]
-        ggml_tensor * b  = nullptr; // [4*pred_hidden] (collapsed bias_ih+bias_hh)
+        ggml_tensor * Wx = nullptr;  // [4*pred_hidden, pred_hidden]
+        ggml_tensor * Wh = nullptr;  // [4*pred_hidden, pred_hidden]
+        ggml_tensor * b  = nullptr;  // [4*pred_hidden] (collapsed bias_ih+bias_hh)
     };
+
     std::vector<LstmLayer> lstm;
 };
 
 // RNN-T joint network (only when head_kind=RNNT). 2-element
 // Sequential(ReLU, Linear) — no inner Linear like parakeet TDT.
 struct GigaamJoint {
-    ggml_tensor * enc_w  = nullptr; // [joint_hidden, enc_d_model]
+    ggml_tensor * enc_w  = nullptr;  // [joint_hidden, enc_d_model]
     ggml_tensor * enc_b  = nullptr;
-    ggml_tensor * pred_w = nullptr; // [joint_hidden, pred_hidden]
+    ggml_tensor * pred_w = nullptr;  // [joint_hidden, pred_hidden]
     ggml_tensor * pred_b = nullptr;
-    ggml_tensor * out_w  = nullptr; // [n_classes, joint_hidden]
+    ggml_tensor * out_w  = nullptr;  // [n_classes, joint_hidden]
     ggml_tensor * out_b  = nullptr;
 };
 
 // CTC head (only when head_kind=CTC). Single 1×1 Conv1d.
 struct GigaamCtcHead {
-    ggml_tensor * weight = nullptr; // [k=1, d_model, n_classes]
-    ggml_tensor * bias   = nullptr; // [n_classes]
+    ggml_tensor * weight = nullptr;  // [k=1, d_model, n_classes]
+    ggml_tensor * bias   = nullptr;  // [n_classes]
 };
 
 struct GigaamWeights {
     // Baked frontend buffers (always present).
-    ggml_tensor * frontend_mel_filterbank = nullptr; // [n_freq_bins, n_mels]
-    ggml_tensor * frontend_window         = nullptr; // [win_length]
+    ggml_tensor * frontend_mel_filterbank = nullptr;  // [n_freq_bins, n_mels]
+    ggml_tensor * frontend_window         = nullptr;  // [win_length]
 
     GigaamPreEncode          pre_encode;
     std::vector<GigaamBlock> blocks;
@@ -198,8 +197,6 @@ struct GigaamWeights {
     GigaamCtcHead            ctc_head;
 };
 
-transcribe_status build_gigaam_weights(ggml_context *        ctx_meta,
-                                       const GigaamHParams & hp,
-                                       GigaamWeights &       weights);
+transcribe_status build_gigaam_weights(ggml_context * ctx_meta, const GigaamHParams & hp, GigaamWeights & weights);
 
-} // namespace transcribe::gigaam
+}  // namespace transcribe::gigaam
diff --git a/src/arch/granite/capabilities.cpp b/src/arch/granite/capabilities.cpp
index ae040c40..3a4356b7 100644
--- a/src/arch/granite/capabilities.cpp
+++ b/src/arch/granite/capabilities.cpp
@@ -33,4 +33,4 @@ void apply_family_invariants(transcribe_model & model) {
     transcribe::set_feature(&model, TRANSCRIBE_FEATURE_CANCELLATION, true);
 }
 
-} // namespace transcribe::granite
+}  // namespace transcribe::granite
diff --git a/src/arch/granite/decoder.cpp b/src/arch/granite/decoder.cpp
index 5e190ab7..91cd1cfa 100644
--- a/src/arch/granite/decoder.cpp
+++ b/src/arch/granite/decoder.cpp
@@ -18,11 +18,10 @@
 #include "decoder.h"
 
 #include "causal_lm/causal_lm.h"
+#include "ggml.h"
 #include "transcribe-debug.h"
 #include "transcribe-log.h"
 
-#include "ggml.h"
-
 #include <cmath>
 #include <cstdio>
 
@@ -31,13 +30,13 @@ namespace transcribe::granite {
 namespace {
 
 ggml_tensor * named(ggml_tensor * t, const char * name) {
-    if (t != nullptr && name != nullptr) ggml_set_name(t, name);
+    if (t != nullptr && name != nullptr) {
+        ggml_set_name(t, name);
+    }
     return t;
 }
 
-ggml_tensor * rms_norm(ggml_context * ctx, ggml_tensor * x,
-                       ggml_tensor * weight, float eps)
-{
+ggml_tensor * rms_norm(ggml_context * ctx, ggml_tensor * x, ggml_tensor * weight, float eps) {
     return ggml_mul(ctx, ggml_rms_norm(ctx, x, eps), weight);
 }
 
@@ -53,7 +52,7 @@ struct GraniteBlockParams {
 };
 
 GraniteBlockParams to_params(const GraniteHParams & hp) {
-    GraniteBlockParams p {};
+    GraniteBlockParams p{};
     p.n_heads      = hp.dec_n_heads;
     p.n_kv_heads   = hp.dec_n_kv_heads;
     p.head_dim     = hp.dec_head_dim;
@@ -66,24 +65,22 @@ GraniteBlockParams to_params(const GraniteHParams & hp) {
 }
 
 // Granite block (prefill). x: [hidden, T_seq].
-ggml_tensor * block_prefill(
-    ggml_context *               ctx,
-    ggml_cgraph *                gf,
-    ggml_tensor *                x,
-    const GraniteDecBlock &      view,
-    const GraniteBlockParams &   params,
-    transcribe::causal_lm::KvCache & kv_cache,
-    int                          layer_idx,
-    int                          T_seq,
-    ggml_tensor *                mask,
-    ggml_tensor *                positions,
-    bool                         use_flash)
-{
+ggml_tensor * block_prefill(ggml_context *                   ctx,
+                            ggml_cgraph *                    gf,
+                            ggml_tensor *                    x,
+                            const GraniteDecBlock &          view,
+                            const GraniteBlockParams &       params,
+                            transcribe::causal_lm::KvCache & kv_cache,
+                            int                              layer_idx,
+                            int                              T_seq,
+                            ggml_tensor *                    mask,
+                            ggml_tensor *                    positions,
+                            bool                             use_flash) {
     const int64_t n_heads    = params.n_heads;
     const int64_t n_kv_heads = params.n_kv_heads;
     const int64_t n_groups   = n_heads / n_kv_heads;
     const int64_t head_dim   = params.head_dim;
-    const int64_t q_dim      = n_heads    * head_dim;
+    const int64_t q_dim      = n_heads * head_dim;
     const int64_t kv_dim     = n_kv_heads * head_dim;
     const int     n_ctx      = kv_cache.n_ctx;
     const float   rms_eps    = params.rms_eps;
@@ -100,85 +97,59 @@ ggml_tensor * block_prefill(
     ggml_tensor * K = ggml_mul_mat(ctx, view.attn_k_w, x_norm);
     ggml_tensor * V = ggml_mul_mat(ctx, view.attn_v_w, x_norm);
 
-    Q = ggml_reshape_4d(ctx, Q, head_dim, n_heads,    T_seq, 1);
+    Q = ggml_reshape_4d(ctx, Q, head_dim, n_heads, T_seq, 1);
     K = ggml_reshape_4d(ctx, K, head_dim, n_kv_heads, T_seq, 1);
     V = ggml_reshape_4d(ctx, V, head_dim, n_kv_heads, T_seq, 1);
 
     // RoPE (NeoX) on Q and K. No q_norm/k_norm on Granite.
-    Q = ggml_rope_ext(ctx, Q, positions, /*c=*/nullptr,
-                      static_cast<int>(head_dim),
-                      GGML_ROPE_TYPE_NEOX,
-                      params.max_position,
-                      rope_theta,
-                      1.0f, 0.0f, 1.0f, 32.0f, 1.0f);
-    K = ggml_rope_ext(ctx, K, positions, nullptr,
-                      static_cast<int>(head_dim),
-                      GGML_ROPE_TYPE_NEOX,
-                      params.max_position,
-                      rope_theta,
-                      1.0f, 0.0f, 1.0f, 32.0f, 1.0f);
+    Q = ggml_rope_ext(ctx, Q, positions, /*c=*/nullptr, static_cast<int>(head_dim), GGML_ROPE_TYPE_NEOX,
+                      params.max_position, rope_theta, 1.0f, 0.0f, 1.0f, 32.0f, 1.0f);
+    K = ggml_rope_ext(ctx, K, positions, nullptr, static_cast<int>(head_dim), GGML_ROPE_TYPE_NEOX, params.max_position,
+                      rope_theta, 1.0f, 0.0f, 1.0f, 32.0f, 1.0f);
 
     // KV write (1D cpy; same memory order as causal_lm).
     {
-        const size_t layer_off = static_cast<size_t>(layer_idx) * n_ctx * kv_dim;
-        const size_t n_elem    = static_cast<size_t>(T_seq) * kv_dim;
-        ggml_tensor * k_dst = ggml_view_1d(
-            ctx, kv_cache.self_k, n_elem, k_elem * layer_off);
-        ggml_tensor * v_dst = ggml_view_1d(
-            ctx, kv_cache.self_v, n_elem, v_elem * layer_off);
+        const size_t  layer_off = static_cast<size_t>(layer_idx) * n_ctx * kv_dim;
+        const size_t  n_elem    = static_cast<size_t>(T_seq) * kv_dim;
+        ggml_tensor * k_dst     = ggml_view_1d(ctx, kv_cache.self_k, n_elem, k_elem * layer_off);
+        ggml_tensor * v_dst     = ggml_view_1d(ctx, kv_cache.self_v, n_elem, v_elem * layer_off);
         ggml_build_forward_expand(gf, ggml_cpy(ctx, K, k_dst));
         ggml_build_forward_expand(gf, ggml_cpy(ctx, V, v_dst));
     }
 
     // Read K/V back as strided 3D views.
-    const size_t layer_off_bytes_k =
-        k_elem * static_cast<size_t>(layer_idx) * n_ctx * kv_dim;
-    const size_t layer_off_bytes_v =
-        v_elem * static_cast<size_t>(layer_idx) * n_ctx * kv_dim;
-    ggml_tensor * K_att = ggml_view_3d(
-        ctx, kv_cache.self_k,
-        head_dim, T_seq, n_kv_heads,
-        k_elem * kv_dim, k_elem * head_dim,
-        layer_off_bytes_k);
-    ggml_tensor * V_att = ggml_view_3d(
-        ctx, kv_cache.self_v,
-        head_dim, T_seq, n_kv_heads,
-        v_elem * kv_dim, v_elem * head_dim,
-        layer_off_bytes_v);
+    const size_t  layer_off_bytes_k = k_elem * static_cast<size_t>(layer_idx) * n_ctx * kv_dim;
+    const size_t  layer_off_bytes_v = v_elem * static_cast<size_t>(layer_idx) * n_ctx * kv_dim;
+    ggml_tensor * K_att             = ggml_view_3d(ctx, kv_cache.self_k, head_dim, T_seq, n_kv_heads, k_elem * kv_dim,
+                                                   k_elem * head_dim, layer_off_bytes_k);
+    ggml_tensor * V_att             = ggml_view_3d(ctx, kv_cache.self_v, head_dim, T_seq, n_kv_heads, v_elem * kv_dim,
+                                                   v_elem * head_dim, layer_off_bytes_v);
 
     ggml_tensor * Q_att = ggml_cont(ctx, ggml_permute(ctx, Q, 0, 2, 1, 3));
 
     ggml_tensor * o;
     if (use_flash) {
-        o = ggml_flash_attn_ext(ctx, Q_att, K_att, V_att, mask,
-                                scale_attn, /*max_bias=*/0.0f,
+        o = ggml_flash_attn_ext(ctx, Q_att, K_att, V_att, mask, scale_attn, /*max_bias=*/0.0f,
                                 /*logit_softcap=*/0.0f);
         o = ggml_reshape_2d(ctx, o, q_dim, T_seq);
     } else {
-        ggml_tensor * K_att_c = ggml_cont(ctx, K_att);
-        ggml_tensor * V_att_c = ggml_cont(ctx, V_att);
-        ggml_tensor * K_4d = ggml_reshape_4d(
-            ctx, K_att_c, head_dim, T_seq, 1, n_kv_heads);
-        ggml_tensor * V_4d = ggml_reshape_4d(
-            ctx, V_att_c, head_dim, T_seq, 1, n_kv_heads);
-        ggml_tensor * K_rep_template = ggml_new_tensor_4d(
-            ctx, K_att->type, head_dim, T_seq, n_groups, n_kv_heads);
-        ggml_tensor * V_rep_template = ggml_new_tensor_4d(
-            ctx, V_att->type, head_dim, T_seq, n_groups, n_kv_heads);
-        ggml_tensor * K_rep = ggml_repeat(ctx, K_4d, K_rep_template);
-        ggml_tensor * V_rep = ggml_repeat(ctx, V_4d, V_rep_template);
-        ggml_tensor * K_full = ggml_reshape_3d(
-            ctx, K_rep, head_dim, T_seq, n_heads);
-        ggml_tensor * V_full = ggml_reshape_3d(
-            ctx, V_rep, head_dim, T_seq, n_heads);
-
-        ggml_tensor * kq = ggml_mul_mat(ctx, K_full, Q_att);
-        ggml_tensor * kq_soft = ggml_soft_max_ext(
-            ctx, kq, mask, scale_attn, /*max_bias=*/0.0f);
-        ggml_tensor * V_t = ggml_cont(ctx, ggml_permute(ctx, V_full, 1, 0, 2, 3));
-        o = ggml_mul_mat(ctx, V_t, kq_soft);
-        o = ggml_cont(ctx, ggml_permute(ctx, o, 0, 2, 1, 3));
-        o = ggml_reshape_2d(ctx, o, q_dim, T_seq);
+        ggml_tensor * K_att_c        = ggml_cont(ctx, K_att);
+        ggml_tensor * V_att_c        = ggml_cont(ctx, V_att);
+        ggml_tensor * K_4d           = ggml_reshape_4d(ctx, K_att_c, head_dim, T_seq, 1, n_kv_heads);
+        ggml_tensor * V_4d           = ggml_reshape_4d(ctx, V_att_c, head_dim, T_seq, 1, n_kv_heads);
+        ggml_tensor * K_rep_template = ggml_new_tensor_4d(ctx, K_att->type, head_dim, T_seq, n_groups, n_kv_heads);
+        ggml_tensor * V_rep_template = ggml_new_tensor_4d(ctx, V_att->type, head_dim, T_seq, n_groups, n_kv_heads);
+        ggml_tensor * K_rep          = ggml_repeat(ctx, K_4d, K_rep_template);
+        ggml_tensor * V_rep          = ggml_repeat(ctx, V_4d, V_rep_template);
+        ggml_tensor * K_full         = ggml_reshape_3d(ctx, K_rep, head_dim, T_seq, n_heads);
+        ggml_tensor * V_full         = ggml_reshape_3d(ctx, V_rep, head_dim, T_seq, n_heads);
+
+        ggml_tensor * kq      = ggml_mul_mat(ctx, K_full, Q_att);
+        ggml_tensor * kq_soft = ggml_soft_max_ext(ctx, kq, mask, scale_attn, /*max_bias=*/0.0f);
+        ggml_tensor * V_t     = ggml_cont(ctx, ggml_permute(ctx, V_full, 1, 0, 2, 3));
+        o                     = ggml_mul_mat(ctx, V_t, kq_soft);
+        o                     = ggml_cont(ctx, ggml_permute(ctx, o, 0, 2, 1, 3));
+        o                     = ggml_reshape_2d(ctx, o, q_dim, T_seq);
     }
 
     o = ggml_mul_mat(ctx, view.attn_o_w, o);
@@ -188,35 +159,33 @@ ggml_tensor * block_prefill(
 
     // ---- MLP sub-layer (SwiGLU, separate gate + up) ----
     ggml_tensor * ff_norm = rms_norm(ctx, x, view.norm_ffn_w, rms_eps);
-    ggml_tensor * gate = ggml_mul_mat(ctx, view.ffn_gate_w, ff_norm);
-    ggml_tensor * up   = ggml_mul_mat(ctx, view.ffn_up_w,   ff_norm);
-    ggml_tensor * ff   = ggml_mul(ctx, ggml_silu(ctx, gate), up);
-    ff = ggml_mul_mat(ctx, view.ffn_down_w, ff);
-    ff = ggml_scale(ctx, ff, params.residual_mul);
-    x = ggml_add(ctx, x, ff);
+    ggml_tensor * gate    = ggml_mul_mat(ctx, view.ffn_gate_w, ff_norm);
+    ggml_tensor * up      = ggml_mul_mat(ctx, view.ffn_up_w, ff_norm);
+    ggml_tensor * ff      = ggml_mul(ctx, ggml_silu(ctx, gate), up);
+    ff                    = ggml_mul_mat(ctx, view.ffn_down_w, ff);
+    ff                    = ggml_scale(ctx, ff, params.residual_mul);
+    x                     = ggml_add(ctx, x, ff);
     return x;
 }
 
 // Granite block (step). x: [hidden, 1]. KV index from `kv_idx` tensor.
-ggml_tensor * block_step(
-    ggml_context *                  ctx,
-    ggml_cgraph *                   gf,
-    ggml_tensor *                   x,
-    const GraniteDecBlock &         view,
-    const GraniteBlockParams &      params,
-    transcribe::causal_lm::KvCache & kv_cache,
-    int                             layer_idx,
-    int                             max_n_kv,
-    ggml_tensor *                   mask,
-    ggml_tensor *                   position,
-    ggml_tensor *                   kv_idx,
-    bool                            use_flash)
-{
+ggml_tensor * block_step(ggml_context *                   ctx,
+                         ggml_cgraph *                    gf,
+                         ggml_tensor *                    x,
+                         const GraniteDecBlock &          view,
+                         const GraniteBlockParams &       params,
+                         transcribe::causal_lm::KvCache & kv_cache,
+                         int                              layer_idx,
+                         int                              max_n_kv,
+                         ggml_tensor *                    mask,
+                         ggml_tensor *                    position,
+                         ggml_tensor *                    kv_idx,
+                         bool                             use_flash) {
     const int64_t n_heads    = params.n_heads;
     const int64_t n_kv_heads = params.n_kv_heads;
     const int64_t n_groups   = n_heads / n_kv_heads;
     const int64_t head_dim   = params.head_dim;
-    const int64_t q_dim      = n_heads    * head_dim;
+    const int64_t q_dim      = n_heads * head_dim;
     const int64_t kv_dim     = n_kv_heads * head_dim;
     const int     n_ctx      = kv_cache.n_ctx;
     const float   rms_eps    = params.rms_eps;
@@ -232,93 +201,61 @@ ggml_tensor * block_step(
     ggml_tensor * K = ggml_mul_mat(ctx, view.attn_k_w, x_norm);
     ggml_tensor * V = ggml_mul_mat(ctx, view.attn_v_w, x_norm);
 
-    Q = ggml_reshape_4d(ctx, Q, head_dim, n_heads,    1, 1);
+    Q = ggml_reshape_4d(ctx, Q, head_dim, n_heads, 1, 1);
     K = ggml_reshape_4d(ctx, K, head_dim, n_kv_heads, 1, 1);
     V = ggml_reshape_4d(ctx, V, head_dim, n_kv_heads, 1, 1);
 
-    Q = ggml_rope_ext(ctx, Q, position, nullptr,
-                      static_cast<int>(head_dim),
-                      GGML_ROPE_TYPE_NEOX,
-                      params.max_position,
+    Q = ggml_rope_ext(ctx, Q, position, nullptr, static_cast<int>(head_dim), GGML_ROPE_TYPE_NEOX, params.max_position,
                       rope_theta, 1.0f, 0.0f, 1.0f, 32.0f, 1.0f);
-    K = ggml_rope_ext(ctx, K, position, nullptr,
-                      static_cast<int>(head_dim),
-                      GGML_ROPE_TYPE_NEOX,
-                      params.max_position,
+    K = ggml_rope_ext(ctx, K, position, nullptr, static_cast<int>(head_dim), GGML_ROPE_TYPE_NEOX, params.max_position,
                       rope_theta, 1.0f, 0.0f, 1.0f, 32.0f, 1.0f);
 
     {
-        const size_t layer_off_k =
-            k_elem * static_cast<size_t>(layer_idx) * n_ctx * kv_dim;
-        const size_t layer_off_v =
-            v_elem * static_cast<size_t>(layer_idx) * n_ctx * kv_dim;
-
-        ggml_tensor * k_layer = ggml_view_2d(
-            ctx, kv_cache.self_k,
-            kv_dim, n_ctx,
-            k_elem * kv_dim, layer_off_k);
-        ggml_tensor * v_layer = ggml_view_2d(
-            ctx, kv_cache.self_v,
-            kv_dim, n_ctx,
-            v_elem * kv_dim, layer_off_v);
+        const size_t layer_off_k = k_elem * static_cast<size_t>(layer_idx) * n_ctx * kv_dim;
+        const size_t layer_off_v = v_elem * static_cast<size_t>(layer_idx) * n_ctx * kv_dim;
+
+        ggml_tensor * k_layer = ggml_view_2d(ctx, kv_cache.self_k, kv_dim, n_ctx, k_elem * kv_dim, layer_off_k);
+        ggml_tensor * v_layer = ggml_view_2d(ctx, kv_cache.self_v, kv_dim, n_ctx, v_elem * kv_dim, layer_off_v);
 
         ggml_tensor * K_row = ggml_reshape_2d(ctx, K, kv_dim, 1);
         ggml_tensor * V_row = ggml_reshape_2d(ctx, V, kv_dim, 1);
 
-        ggml_build_forward_expand(
-            gf, ggml_set_rows(ctx, k_layer, K_row, kv_idx));
-        ggml_build_forward_expand(
-            gf, ggml_set_rows(ctx, v_layer, V_row, kv_idx));
-    }
-
-    const size_t layer_off_bytes_k =
-        k_elem * static_cast<size_t>(layer_idx) * n_ctx * kv_dim;
-    const size_t layer_off_bytes_v =
-        v_elem * static_cast<size_t>(layer_idx) * n_ctx * kv_dim;
-    ggml_tensor * K_att = ggml_view_3d(
-        ctx, kv_cache.self_k,
-        head_dim, max_n_kv, n_kv_heads,
-        k_elem * kv_dim, k_elem * head_dim,
-        layer_off_bytes_k);
-    ggml_tensor * V_att = ggml_view_3d(
-        ctx, kv_cache.self_v,
-        head_dim, max_n_kv, n_kv_heads,
-        v_elem * kv_dim, v_elem * head_dim,
-        layer_off_bytes_v);
+        ggml_build_forward_expand(gf, ggml_set_rows(ctx, k_layer, K_row, kv_idx));
+        ggml_build_forward_expand(gf, ggml_set_rows(ctx, v_layer, V_row, kv_idx));
+    }
+
+    const size_t  layer_off_bytes_k = k_elem * static_cast<size_t>(layer_idx) * n_ctx * kv_dim;
+    const size_t  layer_off_bytes_v = v_elem * static_cast<size_t>(layer_idx) * n_ctx * kv_dim;
+    ggml_tensor * K_att = ggml_view_3d(ctx, kv_cache.self_k, head_dim, max_n_kv, n_kv_heads, k_elem * kv_dim,
+                                       k_elem * head_dim, layer_off_bytes_k);
+    ggml_tensor * V_att = ggml_view_3d(ctx, kv_cache.self_v, head_dim, max_n_kv, n_kv_heads, v_elem * kv_dim,
+                                       v_elem * head_dim, layer_off_bytes_v);
 
     ggml_tensor * Q_att = ggml_cont(ctx, ggml_permute(ctx, Q, 0, 2, 1, 3));
 
     ggml_tensor * o;
     if (use_flash) {
-        o = ggml_flash_attn_ext(ctx, Q_att, K_att, V_att, mask,
-                                scale_attn, /*max_bias=*/0.0f,
+        o = ggml_flash_attn_ext(ctx, Q_att, K_att, V_att, mask, scale_attn, /*max_bias=*/0.0f,
                                 /*logit_softcap=*/0.0f);
         o = ggml_reshape_2d(ctx, o, q_dim, 1);
     } else {
-        ggml_tensor * K_att_c = ggml_cont(ctx, K_att);
-        ggml_tensor * V_att_c = ggml_cont(ctx, V_att);
-        ggml_tensor * K_4d = ggml_reshape_4d(
-            ctx, K_att_c, head_dim, max_n_kv, 1, n_kv_heads);
-        ggml_tensor * V_4d = ggml_reshape_4d(
-            ctx, V_att_c, head_dim, max_n_kv, 1, n_kv_heads);
-        ggml_tensor * K_rep_template = ggml_new_tensor_4d(
-            ctx, K_att->type, head_dim, max_n_kv, n_groups, n_kv_heads);
-        ggml_tensor * V_rep_template = ggml_new_tensor_4d(
-            ctx, V_att->type, head_dim, max_n_kv, n_groups, n_kv_heads);
-        ggml_tensor * K_rep = ggml_repeat(ctx, K_4d, K_rep_template);
-        ggml_tensor * V_rep = ggml_repeat(ctx, V_4d, V_rep_template);
-        ggml_tensor * K_full = ggml_reshape_3d(
-            ctx, K_rep, head_dim, max_n_kv, n_heads);
-        ggml_tensor * V_full = ggml_reshape_3d(
-            ctx, V_rep, head_dim, max_n_kv, n_heads);
-
-        ggml_tensor * kq = ggml_mul_mat(ctx, K_full, Q_att);
-        ggml_tensor * kq_soft = ggml_soft_max_ext(
-            ctx, kq, mask, scale_attn, /*max_bias=*/0.0f);
-        ggml_tensor * V_t = ggml_cont(ctx, ggml_permute(ctx, V_full, 1, 0, 2, 3));
-        o = ggml_mul_mat(ctx, V_t, kq_soft);
-        o = ggml_cont(ctx, ggml_permute(ctx, o, 0, 2, 1, 3));
-        o = ggml_reshape_2d(ctx, o, q_dim, 1);
+        ggml_tensor * K_att_c        = ggml_cont(ctx, K_att);
+        ggml_tensor * V_att_c        = ggml_cont(ctx, V_att);
+        ggml_tensor * K_4d           = ggml_reshape_4d(ctx, K_att_c, head_dim, max_n_kv, 1, n_kv_heads);
+        ggml_tensor * V_4d           = ggml_reshape_4d(ctx, V_att_c, head_dim, max_n_kv, 1, n_kv_heads);
+        ggml_tensor * K_rep_template = ggml_new_tensor_4d(ctx, K_att->type, head_dim, max_n_kv, n_groups, n_kv_heads);
+        ggml_tensor * V_rep_template = ggml_new_tensor_4d(ctx, V_att->type, head_dim, max_n_kv, n_groups, n_kv_heads);
+        ggml_tensor * K_rep          = ggml_repeat(ctx, K_4d, K_rep_template);
+        ggml_tensor * V_rep          = ggml_repeat(ctx, V_4d, V_rep_template);
+        ggml_tensor * K_full         = ggml_reshape_3d(ctx, K_rep, head_dim, max_n_kv, n_heads);
+        ggml_tensor * V_full         = ggml_reshape_3d(ctx, V_rep, head_dim, max_n_kv, n_heads);
+
+        ggml_tensor * kq      = ggml_mul_mat(ctx, K_full, Q_att);
+        ggml_tensor * kq_soft = ggml_soft_max_ext(ctx, kq, mask, scale_attn, /*max_bias=*/0.0f);
+        ggml_tensor * V_t     = ggml_cont(ctx, ggml_permute(ctx, V_full, 1, 0, 2, 3));
+        o                     = ggml_mul_mat(ctx, V_t, kq_soft);
+        o                     = ggml_cont(ctx, ggml_permute(ctx, o, 0, 2, 1, 3));
+        o                     = ggml_reshape_2d(ctx, o, q_dim, 1);
     }
 
     o = ggml_mul_mat(ctx, view.attn_o_w, o);
@@ -329,39 +266,37 @@ ggml_tensor * block_step(
     ggml_tensor * ff;
     if (view.ffn_gate_up_w != nullptr) {
         ggml_tensor * gate_up = ggml_mul_mat(ctx, view.ffn_gate_up_w, ff_norm);
-        ff = ggml_swiglu(ctx, gate_up);
+        ff                    = ggml_swiglu(ctx, gate_up);
     } else {
         ggml_tensor * gate = ggml_mul_mat(ctx, view.ffn_gate_w, ff_norm);
-        ggml_tensor * up   = ggml_mul_mat(ctx, view.ffn_up_w,   ff_norm);
-        ff = ggml_mul(ctx, ggml_silu(ctx, gate), up);
+        ggml_tensor * up   = ggml_mul_mat(ctx, view.ffn_up_w, ff_norm);
+        ff                 = ggml_mul(ctx, ggml_silu(ctx, gate), up);
     }
     ff = ggml_mul_mat(ctx, view.ffn_down_w, ff);
     ff = ggml_scale(ctx, ff, params.residual_mul);
-    x = ggml_add(ctx, x, ff);
+    x  = ggml_add(ctx, x, ff);
     return x;
 }
 
 // Granite batched block (prefill). x: [hidden, T, B], batch on ne[2].
 // Requires flash. Mirrors causal_lm::block_prefill_batched with Granite math.
-ggml_tensor * block_prefill_batched(
-    ggml_context *                  ctx,
-    ggml_cgraph *                   gf,
-    ggml_tensor *                   x,
-    const GraniteDecBlock &         view,
-    const GraniteBlockParams &      params,
-    transcribe::causal_lm::KvCache & kv_cache,
-    int                             layer_idx,
-    int                             T_seq,
-    int                             n_batch,
-    ggml_tensor *                   mask,
-    ggml_tensor *                   positions,
-    ggml_tensor *                   kv_idx,
-    bool                            use_flash)
-{
+ggml_tensor * block_prefill_batched(ggml_context *                   ctx,
+                                    ggml_cgraph *                    gf,
+                                    ggml_tensor *                    x,
+                                    const GraniteDecBlock &          view,
+                                    const GraniteBlockParams &       params,
+                                    transcribe::causal_lm::KvCache & kv_cache,
+                                    int                              layer_idx,
+                                    int                              T_seq,
+                                    int                              n_batch,
+                                    ggml_tensor *                    mask,
+                                    ggml_tensor *                    positions,
+                                    ggml_tensor *                    kv_idx,
+                                    bool                             use_flash) {
     const int64_t n_heads    = params.n_heads;
     const int64_t n_kv_heads = params.n_kv_heads;
     const int64_t head_dim   = params.head_dim;
-    const int64_t q_dim      = n_heads    * head_dim;
+    const int64_t q_dim      = n_heads * head_dim;
     const int64_t kv_dim     = n_kv_heads * head_dim;
     const int64_t n_ctx      = kv_cache.n_ctx;
     const int64_t T          = T_seq;
@@ -369,8 +304,8 @@ ggml_tensor * block_prefill_batched(
     const float   rms_eps    = params.rms_eps;
     const float   rope_theta = params.rope_theta;
     const float   scale_attn = params.attn_scale;
-    const size_t  k_elem = ggml_element_size(kv_cache.self_k);
-    const size_t  v_elem = ggml_element_size(kv_cache.self_v);
+    const size_t  k_elem     = ggml_element_size(kv_cache.self_k);
+    const size_t  v_elem     = ggml_element_size(kv_cache.self_v);
 
     if (!use_flash) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "granite block_prefill_batched: requires flash");
@@ -378,43 +313,40 @@ ggml_tensor * block_prefill_batched(
     }
 
     ggml_tensor * x_norm = rms_norm(ctx, x, view.norm_attn_w, rms_eps);
-    ggml_tensor * Q = ggml_mul_mat(ctx, view.attn_q_w, x_norm);
-    ggml_tensor * K = ggml_mul_mat(ctx, view.attn_k_w, x_norm);
-    ggml_tensor * V = ggml_mul_mat(ctx, view.attn_v_w, x_norm);
-    Q = ggml_reshape_4d(ctx, Q, head_dim, n_heads,    T, B);
-    K = ggml_reshape_4d(ctx, K, head_dim, n_kv_heads, T, B);
-    V = ggml_reshape_4d(ctx, V, head_dim, n_kv_heads, T, B);
-    Q = ggml_rope_ext(ctx, Q, positions, nullptr, static_cast<int>(head_dim),
-                      GGML_ROPE_TYPE_NEOX, params.max_position,
+    ggml_tensor * Q      = ggml_mul_mat(ctx, view.attn_q_w, x_norm);
+    ggml_tensor * K      = ggml_mul_mat(ctx, view.attn_k_w, x_norm);
+    ggml_tensor * V      = ggml_mul_mat(ctx, view.attn_v_w, x_norm);
+    Q                    = ggml_reshape_4d(ctx, Q, head_dim, n_heads, T, B);
+    K                    = ggml_reshape_4d(ctx, K, head_dim, n_kv_heads, T, B);
+    V                    = ggml_reshape_4d(ctx, V, head_dim, n_kv_heads, T, B);
+    Q = ggml_rope_ext(ctx, Q, positions, nullptr, static_cast<int>(head_dim), GGML_ROPE_TYPE_NEOX, params.max_position,
                       rope_theta, 1.0f, 0.0f, 1.0f, 32.0f, 1.0f);
-    K = ggml_rope_ext(ctx, K, positions, nullptr, static_cast<int>(head_dim),
-                      GGML_ROPE_TYPE_NEOX, params.max_position,
+    K = ggml_rope_ext(ctx, K, positions, nullptr, static_cast<int>(head_dim), GGML_ROPE_TYPE_NEOX, params.max_position,
                       rope_theta, 1.0f, 0.0f, 1.0f, 32.0f, 1.0f);
     {
-        const size_t off_k = k_elem * static_cast<size_t>(layer_idx) * n_ctx * kv_dim * B;
-        const size_t off_v = v_elem * static_cast<size_t>(layer_idx) * n_ctx * kv_dim * B;
-        ggml_tensor * k_layer = ggml_view_3d(ctx, kv_cache.self_k, kv_dim, n_ctx, B,
-            k_elem * kv_dim, k_elem * kv_dim * n_ctx, off_k);
-        ggml_tensor * v_layer = ggml_view_3d(ctx, kv_cache.self_v, kv_dim, n_ctx, B,
-            v_elem * kv_dim, v_elem * kv_dim * n_ctx, off_v);
+        const size_t  off_k = k_elem * static_cast<size_t>(layer_idx) * n_ctx * kv_dim * B;
+        const size_t  off_v = v_elem * static_cast<size_t>(layer_idx) * n_ctx * kv_dim * B;
+        ggml_tensor * k_layer =
+            ggml_view_3d(ctx, kv_cache.self_k, kv_dim, n_ctx, B, k_elem * kv_dim, k_elem * kv_dim * n_ctx, off_k);
+        ggml_tensor * v_layer =
+            ggml_view_3d(ctx, kv_cache.self_v, kv_dim, n_ctx, B, v_elem * kv_dim, v_elem * kv_dim * n_ctx, off_v);
         ggml_tensor * K_rows = ggml_reshape_3d(ctx, K, kv_dim, T, B);
         ggml_tensor * V_rows = ggml_reshape_3d(ctx, V, kv_dim, T, B);
         ggml_build_forward_expand(gf, ggml_set_rows(ctx, k_layer, K_rows, kv_idx));
         ggml_build_forward_expand(gf, ggml_set_rows(ctx, v_layer, V_rows, kv_idx));
     }
-    const size_t off_k = k_elem * static_cast<size_t>(layer_idx) * n_ctx * kv_dim * B;
-    const size_t off_v = v_elem * static_cast<size_t>(layer_idx) * n_ctx * kv_dim * B;
-    ggml_tensor * K_att = ggml_view_4d(ctx, kv_cache.self_k, head_dim, T, n_kv_heads, B,
-        k_elem * kv_dim, k_elem * head_dim, k_elem * kv_dim * n_ctx, off_k);
-    ggml_tensor * V_att = ggml_view_4d(ctx, kv_cache.self_v, head_dim, T, n_kv_heads, B,
-        v_elem * kv_dim, v_elem * head_dim, v_elem * kv_dim * n_ctx, off_v);
+    const size_t  off_k = k_elem * static_cast<size_t>(layer_idx) * n_ctx * kv_dim * B;
+    const size_t  off_v = v_elem * static_cast<size_t>(layer_idx) * n_ctx * kv_dim * B;
+    ggml_tensor * K_att = ggml_view_4d(ctx, kv_cache.self_k, head_dim, T, n_kv_heads, B, k_elem * kv_dim,
+                                       k_elem * head_dim, k_elem * kv_dim * n_ctx, off_k);
+    ggml_tensor * V_att = ggml_view_4d(ctx, kv_cache.self_v, head_dim, T, n_kv_heads, B, v_elem * kv_dim,
+                                       v_elem * head_dim, v_elem * kv_dim * n_ctx, off_v);
     ggml_tensor * Q_att = ggml_cont(ctx, ggml_permute(ctx, Q, 0, 2, 1, 3));
-    ggml_tensor * o = ggml_flash_attn_ext(ctx, Q_att, K_att, V_att, mask,
-                                          scale_attn, 0.0f, 0.0f);
-    o = ggml_reshape_3d(ctx, o, q_dim, T, B);
-    o = ggml_mul_mat(ctx, view.attn_o_w, o);
-    o = ggml_scale(ctx, o, params.residual_mul);
-    x = ggml_add(ctx, x, o);
+    ggml_tensor * o     = ggml_flash_attn_ext(ctx, Q_att, K_att, V_att, mask, scale_attn, 0.0f, 0.0f);
+    o                   = ggml_reshape_3d(ctx, o, q_dim, T, B);
+    o                   = ggml_mul_mat(ctx, view.attn_o_w, o);
+    o                   = ggml_scale(ctx, o, params.residual_mul);
+    x                   = ggml_add(ctx, x, o);
 
     ggml_tensor * ff_norm = rms_norm(ctx, x, view.norm_ffn_w, rms_eps);
     ggml_tensor * ff;
@@ -422,44 +354,42 @@ ggml_tensor * block_prefill_batched(
         ff = ggml_swiglu(ctx, ggml_mul_mat(ctx, view.ffn_gate_up_w, ff_norm));
     } else {
         ggml_tensor * gate = ggml_mul_mat(ctx, view.ffn_gate_w, ff_norm);
-        ggml_tensor * up   = ggml_mul_mat(ctx, view.ffn_up_w,   ff_norm);
-        ff = ggml_mul(ctx, ggml_silu(ctx, gate), up);
+        ggml_tensor * up   = ggml_mul_mat(ctx, view.ffn_up_w, ff_norm);
+        ff                 = ggml_mul(ctx, ggml_silu(ctx, gate), up);
     }
     ff = ggml_mul_mat(ctx, view.ffn_down_w, ff);
     ff = ggml_scale(ctx, ff, params.residual_mul);
-    x = ggml_add(ctx, x, ff);
+    x  = ggml_add(ctx, x, ff);
     return x;
 }
 
 // Granite batched block (step). x: [hidden, B], batch on ne[2] for RoPE,
 // permute to ne[3] for flash. Mirrors causal_lm::block_step_batched.
-ggml_tensor * block_step_batched(
-    ggml_context *                  ctx,
-    ggml_cgraph *                   gf,
-    ggml_tensor *                   x,
-    const GraniteDecBlock &         view,
-    const GraniteBlockParams &      params,
-    transcribe::causal_lm::KvCache & kv_cache,
-    int                             layer_idx,
-    int                             max_n_kv,
-    int                             n_batch,
-    ggml_tensor *                   mask,
-    ggml_tensor *                   position,
-    ggml_tensor *                   kv_idx,
-    bool                            use_flash)
-{
+ggml_tensor * block_step_batched(ggml_context *                   ctx,
+                                 ggml_cgraph *                    gf,
+                                 ggml_tensor *                    x,
+                                 const GraniteDecBlock &          view,
+                                 const GraniteBlockParams &       params,
+                                 transcribe::causal_lm::KvCache & kv_cache,
+                                 int                              layer_idx,
+                                 int                              max_n_kv,
+                                 int                              n_batch,
+                                 ggml_tensor *                    mask,
+                                 ggml_tensor *                    position,
+                                 ggml_tensor *                    kv_idx,
+                                 bool                             use_flash) {
     const int64_t n_heads    = params.n_heads;
     const int64_t n_kv_heads = params.n_kv_heads;
     const int64_t head_dim   = params.head_dim;
-    const int64_t q_dim      = n_heads    * head_dim;
+    const int64_t q_dim      = n_heads * head_dim;
     const int64_t kv_dim     = n_kv_heads * head_dim;
     const int64_t n_ctx      = kv_cache.n_ctx;
     const int64_t B          = n_batch;
     const float   rms_eps    = params.rms_eps;
     const float   rope_theta = params.rope_theta;
     const float   scale_attn = params.attn_scale;
-    const size_t  k_elem = ggml_element_size(kv_cache.self_k);
-    const size_t  v_elem = ggml_element_size(kv_cache.self_v);
+    const size_t  k_elem     = ggml_element_size(kv_cache.self_k);
+    const size_t  v_elem     = ggml_element_size(kv_cache.self_v);
 
     if (!use_flash) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "granite block_step_batched: requires flash");
@@ -467,43 +397,40 @@ ggml_tensor * block_step_batched(
     }
 
     ggml_tensor * x_norm = rms_norm(ctx, x, view.norm_attn_w, rms_eps);
-    ggml_tensor * Q = ggml_mul_mat(ctx, view.attn_q_w, x_norm);  // [q_dim, B]
-    ggml_tensor * K = ggml_mul_mat(ctx, view.attn_k_w, x_norm);
-    ggml_tensor * V = ggml_mul_mat(ctx, view.attn_v_w, x_norm);
-    Q = ggml_reshape_3d(ctx, Q, head_dim, n_heads,    B);
-    K = ggml_reshape_3d(ctx, K, head_dim, n_kv_heads, B);
-    V = ggml_reshape_3d(ctx, V, head_dim, n_kv_heads, B);
-    Q = ggml_rope_ext(ctx, Q, position, nullptr, static_cast<int>(head_dim),
-                      GGML_ROPE_TYPE_NEOX, params.max_position,
+    ggml_tensor * Q      = ggml_mul_mat(ctx, view.attn_q_w, x_norm);  // [q_dim, B]
+    ggml_tensor * K      = ggml_mul_mat(ctx, view.attn_k_w, x_norm);
+    ggml_tensor * V      = ggml_mul_mat(ctx, view.attn_v_w, x_norm);
+    Q                    = ggml_reshape_3d(ctx, Q, head_dim, n_heads, B);
+    K                    = ggml_reshape_3d(ctx, K, head_dim, n_kv_heads, B);
+    V                    = ggml_reshape_3d(ctx, V, head_dim, n_kv_heads, B);
+    Q = ggml_rope_ext(ctx, Q, position, nullptr, static_cast<int>(head_dim), GGML_ROPE_TYPE_NEOX, params.max_position,
                       rope_theta, 1.0f, 0.0f, 1.0f, 32.0f, 1.0f);
-    K = ggml_rope_ext(ctx, K, position, nullptr, static_cast<int>(head_dim),
-                      GGML_ROPE_TYPE_NEOX, params.max_position,
+    K = ggml_rope_ext(ctx, K, position, nullptr, static_cast<int>(head_dim), GGML_ROPE_TYPE_NEOX, params.max_position,
                       rope_theta, 1.0f, 0.0f, 1.0f, 32.0f, 1.0f);
     {
-        const size_t off_k = k_elem * static_cast<size_t>(layer_idx) * n_ctx * kv_dim * B;
-        const size_t off_v = v_elem * static_cast<size_t>(layer_idx) * n_ctx * kv_dim * B;
-        ggml_tensor * k_layer = ggml_view_3d(ctx, kv_cache.self_k, kv_dim, n_ctx, B,
-            k_elem * kv_dim, k_elem * kv_dim * n_ctx, off_k);
-        ggml_tensor * v_layer = ggml_view_3d(ctx, kv_cache.self_v, kv_dim, n_ctx, B,
-            v_elem * kv_dim, v_elem * kv_dim * n_ctx, off_v);
+        const size_t  off_k = k_elem * static_cast<size_t>(layer_idx) * n_ctx * kv_dim * B;
+        const size_t  off_v = v_elem * static_cast<size_t>(layer_idx) * n_ctx * kv_dim * B;
+        ggml_tensor * k_layer =
+            ggml_view_3d(ctx, kv_cache.self_k, kv_dim, n_ctx, B, k_elem * kv_dim, k_elem * kv_dim * n_ctx, off_k);
+        ggml_tensor * v_layer =
+            ggml_view_3d(ctx, kv_cache.self_v, kv_dim, n_ctx, B, v_elem * kv_dim, v_elem * kv_dim * n_ctx, off_v);
         ggml_tensor * K_row = ggml_reshape_3d(ctx, K, kv_dim, 1, B);
         ggml_tensor * V_row = ggml_reshape_3d(ctx, V, kv_dim, 1, B);
         ggml_build_forward_expand(gf, ggml_set_rows(ctx, k_layer, K_row, kv_idx));
         ggml_build_forward_expand(gf, ggml_set_rows(ctx, v_layer, V_row, kv_idx));
     }
-    const size_t off_k = k_elem * static_cast<size_t>(layer_idx) * n_ctx * kv_dim * B;
-    const size_t off_v = v_elem * static_cast<size_t>(layer_idx) * n_ctx * kv_dim * B;
-    ggml_tensor * K_att = ggml_view_4d(ctx, kv_cache.self_k, head_dim, max_n_kv, n_kv_heads, B,
-        k_elem * kv_dim, k_elem * head_dim, k_elem * kv_dim * n_ctx, off_k);
-    ggml_tensor * V_att = ggml_view_4d(ctx, kv_cache.self_v, head_dim, max_n_kv, n_kv_heads, B,
-        v_elem * kv_dim, v_elem * head_dim, v_elem * kv_dim * n_ctx, off_v);
+    const size_t  off_k = k_elem * static_cast<size_t>(layer_idx) * n_ctx * kv_dim * B;
+    const size_t  off_v = v_elem * static_cast<size_t>(layer_idx) * n_ctx * kv_dim * B;
+    ggml_tensor * K_att = ggml_view_4d(ctx, kv_cache.self_k, head_dim, max_n_kv, n_kv_heads, B, k_elem * kv_dim,
+                                       k_elem * head_dim, k_elem * kv_dim * n_ctx, off_k);
+    ggml_tensor * V_att = ggml_view_4d(ctx, kv_cache.self_v, head_dim, max_n_kv, n_kv_heads, B, v_elem * kv_dim,
+                                       v_elem * head_dim, v_elem * kv_dim * n_ctx, off_v);
     ggml_tensor * Q_att = ggml_cont(ctx, ggml_permute(ctx, Q, 0, 2, 3, 1));
-    ggml_tensor * o = ggml_flash_attn_ext(ctx, Q_att, K_att, V_att, mask,
-                                          scale_attn, 0.0f, 0.0f);
-    o = ggml_reshape_2d(ctx, o, q_dim, B);
-    o = ggml_mul_mat(ctx, view.attn_o_w, o);
-    o = ggml_scale(ctx, o, params.residual_mul);
-    x = ggml_add(ctx, x, o);
+    ggml_tensor * o     = ggml_flash_attn_ext(ctx, Q_att, K_att, V_att, mask, scale_attn, 0.0f, 0.0f);
+    o                   = ggml_reshape_2d(ctx, o, q_dim, B);
+    o                   = ggml_mul_mat(ctx, view.attn_o_w, o);
+    o                   = ggml_scale(ctx, o, params.residual_mul);
+    x                   = ggml_add(ctx, x, o);
 
     ggml_tensor * ff_norm = rms_norm(ctx, x, view.norm_ffn_w, rms_eps);
     ggml_tensor * ff;
@@ -511,48 +438,43 @@ ggml_tensor * block_step_batched(
         ff = ggml_swiglu(ctx, ggml_mul_mat(ctx, view.ffn_gate_up_w, ff_norm));
     } else {
         ggml_tensor * gate = ggml_mul_mat(ctx, view.ffn_gate_w, ff_norm);
-        ggml_tensor * up   = ggml_mul_mat(ctx, view.ffn_up_w,   ff_norm);
-        ff = ggml_mul(ctx, ggml_silu(ctx, gate), up);
+        ggml_tensor * up   = ggml_mul_mat(ctx, view.ffn_up_w, ff_norm);
+        ff                 = ggml_mul(ctx, ggml_silu(ctx, gate), up);
     }
     ff = ggml_mul_mat(ctx, view.ffn_down_w, ff);
     ff = ggml_scale(ctx, ff, params.residual_mul);
-    x = ggml_add(ctx, x, ff);
+    x  = ggml_add(ctx, x, ff);
     return x;
 }
 
-} // namespace
+}  // namespace
 
 // Prefill graph.
 
-PrefillBuild build_prefill_graph(ggml_context *                  ctx,
-                                 const GraniteWeights &          weights,
-                                 const GraniteHParams &          hp,
+PrefillBuild build_prefill_graph(ggml_context *                   ctx,
+                                 const GraniteWeights &           weights,
+                                 const GraniteHParams &           hp,
                                  transcribe::causal_lm::KvCache & kv_cache,
-                                 int                             T_prompt,
-                                 int                             n_audio_tokens,
-                                 int                             prefix_len,
-                                 int                             suffix_len,
-                                 bool                            use_flash,
-                                 bool                            slice_last)
-{
-    PrefillBuild pb {};
+                                 int                              T_prompt,
+                                 int                              n_audio_tokens,
+                                 int                              prefix_len,
+                                 int                              suffix_len,
+                                 bool                             use_flash,
+                                 bool                             slice_last) {
+    PrefillBuild pb{};
     pb.T_prompt       = T_prompt;
     pb.n_audio_tokens = n_audio_tokens;
     pb.prefix_len     = prefix_len;
     pb.suffix_len     = suffix_len;
 
     if (ctx == nullptr || T_prompt <= 0 || n_audio_tokens <= 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "granite decoder: invalid arg (T_prompt=%d, n_audio=%d)",
-                     T_prompt, n_audio_tokens);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "granite decoder: invalid arg (T_prompt=%d, n_audio=%d)", T_prompt,
+                n_audio_tokens);
         return pb;
     }
-    if (prefix_len < 0 || suffix_len < 0 ||
-        prefix_len + n_audio_tokens + suffix_len != T_prompt)
-    {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "granite decoder: prefix(%d)+n_audio(%d)+suffix(%d) != T_prompt(%d)",
-                     prefix_len, n_audio_tokens, suffix_len, T_prompt);
+    if (prefix_len < 0 || suffix_len < 0 || prefix_len + n_audio_tokens + suffix_len != T_prompt) {
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "granite decoder: prefix(%d)+n_audio(%d)+suffix(%d) != T_prompt(%d)",
+                prefix_len, n_audio_tokens, suffix_len, T_prompt);
         return pb;
     }
     if (kv_cache.self_k == nullptr || kv_cache.self_v == nullptr) {
@@ -560,9 +482,8 @@ PrefillBuild build_prefill_graph(ggml_context *                  ctx,
         return pb;
     }
     if (T_prompt > kv_cache.n_ctx) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "granite decoder: T_prompt=%d exceeds kv_cache.n_ctx=%d",
-                     T_prompt, kv_cache.n_ctx);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "granite decoder: T_prompt=%d exceeds kv_cache.n_ctx=%d", T_prompt,
+                kv_cache.n_ctx);
         return pb;
     }
 
@@ -571,8 +492,7 @@ PrefillBuild build_prefill_graph(ggml_context *                  ctx,
     const int     n_layer = hp.dec_n_layers;
     const float   rms_eps = hp.dec_rms_norm_eps;
     const float   emb_mul = hp.dec_embedding_multiplier;
-    const float   inv_log = (hp.dec_logits_scaling > 0.0f)
-                            ? (1.0f / hp.dec_logits_scaling) : 1.0f;
+    const float   inv_log = (hp.dec_logits_scaling > 0.0f) ? (1.0f / hp.dec_logits_scaling) : 1.0f;
 
     const auto params = to_params(hp);
 
@@ -581,8 +501,7 @@ PrefillBuild build_prefill_graph(ggml_context *                  ctx,
     named(pb.input_ids_in, "dec.input_ids");
     ggml_set_input(pb.input_ids_in);
 
-    pb.audio_feats_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32,
-                                           hidden, n_audio_tokens);
+    pb.audio_feats_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, hidden, n_audio_tokens);
     named(pb.audio_feats_in, "dec.audio_features");
     ggml_set_input(pb.audio_feats_in);
 
@@ -596,45 +515,40 @@ PrefillBuild build_prefill_graph(ggml_context *                  ctx,
 
     ggml_cgraph * gf = ggml_new_graph_custom(ctx, /*size=*/16384, /*grads=*/false);
     if (gf == nullptr) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "granite decoder: ggml_new_graph_custom failed");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "granite decoder: ggml_new_graph_custom failed");
         return pb;
     }
     pb.graph = gf;
 
     // Token embedding (for full prompt, for dump parity).
-    ggml_tensor * token_emb_all = ggml_get_rows(
-        ctx, weights.dec_embed.token_w, pb.input_ids_in);
+    ggml_tensor * token_emb_all = ggml_get_rows(ctx, weights.dec_embed.token_w, pb.input_ids_in);
     named(token_emb_all, "dec.token_emb");
     pb.dumps.token_emb = token_emb_all;
     transcribe::debug::mark_tensor_for_dump(token_emb_all);
 
     // Audio injection via 3-way concat.
-    const size_t emb_elem = ggml_element_size(token_emb_all);
+    const size_t  emb_elem = ggml_element_size(token_emb_all);
     ggml_tensor * x_prefix = nullptr;
     if (prefix_len > 0) {
-        x_prefix = ggml_view_2d(
-            ctx, token_emb_all,
-            hidden, prefix_len,
-            emb_elem * hidden,
-            /*off=*/0);
+        x_prefix = ggml_view_2d(ctx, token_emb_all, hidden, prefix_len, emb_elem * hidden,
+                                /*off=*/0);
         x_prefix = ggml_cont(ctx, x_prefix);
     }
-    ggml_tensor * x_audio = pb.audio_feats_in;
+    ggml_tensor * x_audio  = pb.audio_feats_in;
     ggml_tensor * x_suffix = nullptr;
     if (suffix_len > 0) {
-        x_suffix = ggml_view_2d(
-            ctx, token_emb_all,
-            hidden, suffix_len,
-            emb_elem * hidden,
-            emb_elem * hidden *
-                static_cast<size_t>(prefix_len + n_audio_tokens));
+        x_suffix = ggml_view_2d(ctx, token_emb_all, hidden, suffix_len, emb_elem * hidden,
+                                emb_elem * hidden * static_cast<size_t>(prefix_len + n_audio_tokens));
         x_suffix = ggml_cont(ctx, x_suffix);
     }
 
     ggml_tensor * x = x_audio;
-    if (x_prefix != nullptr) x = ggml_concat(ctx, x_prefix, x, /*dim=*/1);
-    if (x_suffix != nullptr) x = ggml_concat(ctx, x, x_suffix, /*dim=*/1);
+    if (x_prefix != nullptr) {
+        x = ggml_concat(ctx, x_prefix, x, /*dim=*/1);
+    }
+    if (x_suffix != nullptr) {
+        x = ggml_concat(ctx, x, x_suffix, /*dim=*/1);
+    }
     named(x, "dec.audio_injected");
     pb.dumps.audio_injected = x;
     transcribe::debug::mark_tensor_for_dump(x);
@@ -645,16 +559,8 @@ PrefillBuild build_prefill_graph(ggml_context *                  ctx,
     // Block stack.
     const int mid_idx = n_layer / 2;
     for (int il = 0; il < n_layer; ++il) {
-        x = block_prefill(
-            ctx, gf, x,
-            weights.dec_blocks[il],
-            params,
-            kv_cache,
-            il,
-            T_prompt,
-            pb.mask_in,
-            pb.positions_in,
-            use_flash);
+        x = block_prefill(ctx, gf, x, weights.dec_blocks[il], params, kv_cache, il, T_prompt, pb.mask_in,
+                          pb.positions_in, use_flash);
 
         if (il == 0) {
             named(x, "dec.block.0.out");
@@ -682,23 +588,18 @@ PrefillBuild build_prefill_graph(ggml_context *                  ctx,
     transcribe::debug::mark_tensor_for_dump(x);
 
     // LM head (slice last position).
-    ggml_tensor * last_x = ggml_view_2d(
-        ctx, x,
-        hidden, 1,
-        ggml_element_size(x) * hidden,
-        ggml_element_size(x) * hidden *
-            static_cast<size_t>(T_prompt - 1));
-    last_x = ggml_cont(ctx, last_x);
-    (void)slice_last;  // single-position slice is unconditional in granite
+    ggml_tensor * last_x = ggml_view_2d(ctx, x, hidden, 1, ggml_element_size(x) * hidden,
+                                        ggml_element_size(x) * hidden * static_cast<size_t>(T_prompt - 1));
+    last_x               = ggml_cont(ctx, last_x);
+    (void) slice_last;  // single-position slice is unconditional in granite
 
     // -plus has tie_word_embeddings=true; use token_w for the head.
-    ggml_tensor * head_w = (weights.dec_final.output_w != nullptr)
-                            ? weights.dec_final.output_w
-                            : weights.dec_embed.token_w;
+    ggml_tensor * head_w =
+        (weights.dec_final.output_w != nullptr) ? weights.dec_final.output_w : weights.dec_embed.token_w;
     ggml_tensor * logits = ggml_mul_mat(ctx, head_w, last_x);
-    logits = ggml_reshape_1d(ctx, logits, vocab);
+    logits               = ggml_reshape_1d(ctx, logits, vocab);
     // logits_scaling divides logits (Granite scales the head down).
-    logits = ggml_scale(ctx, logits, inv_log);
+    logits               = ggml_scale(ctx, logits, inv_log);
     named(logits, "dec.logits_raw");
     pb.dumps.logits_raw = logits;
     transcribe::debug::mark_tensor_for_dump(logits);
@@ -707,31 +608,41 @@ PrefillBuild build_prefill_graph(ggml_context *                  ctx,
     ggml_set_output(pb.out);
 
     ggml_build_forward_expand(gf, pb.out);
-    if (pb.dumps.token_emb)       ggml_build_forward_expand(gf, pb.dumps.token_emb);
-    if (pb.dumps.audio_injected)  ggml_build_forward_expand(gf, pb.dumps.audio_injected);
-    if (pb.dumps.block_0_out)     ggml_build_forward_expand(gf, pb.dumps.block_0_out);
-    if (pb.dumps.block_mid_out)   ggml_build_forward_expand(gf, pb.dumps.block_mid_out);
-    if (pb.dumps.block_last_out)  ggml_build_forward_expand(gf, pb.dumps.block_last_out);
-    if (pb.dumps.out_before_head) ggml_build_forward_expand(gf, pb.dumps.out_before_head);
+    if (pb.dumps.token_emb) {
+        ggml_build_forward_expand(gf, pb.dumps.token_emb);
+    }
+    if (pb.dumps.audio_injected) {
+        ggml_build_forward_expand(gf, pb.dumps.audio_injected);
+    }
+    if (pb.dumps.block_0_out) {
+        ggml_build_forward_expand(gf, pb.dumps.block_0_out);
+    }
+    if (pb.dumps.block_mid_out) {
+        ggml_build_forward_expand(gf, pb.dumps.block_mid_out);
+    }
+    if (pb.dumps.block_last_out) {
+        ggml_build_forward_expand(gf, pb.dumps.block_last_out);
+    }
+    if (pb.dumps.out_before_head) {
+        ggml_build_forward_expand(gf, pb.dumps.out_before_head);
+    }
 
     return pb;
 }
 
 // Step graph.
 
-StepBuild build_step_graph(ggml_context *                  ctx,
-                           const GraniteWeights &          weights,
-                           const GraniteHParams &          hp,
+StepBuild build_step_graph(ggml_context *                   ctx,
+                           const GraniteWeights &           weights,
+                           const GraniteHParams &           hp,
                            transcribe::causal_lm::KvCache & kv_cache,
-                           int                             max_n_kv,
-                           bool                            use_flash)
-{
-    StepBuild sb {};
+                           int                              max_n_kv,
+                           bool                             use_flash) {
+    StepBuild sb{};
     sb.max_n_kv = max_n_kv;
 
     if (ctx == nullptr || max_n_kv <= 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "granite step: invalid arg (max_n_kv=%d)", max_n_kv);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "granite step: invalid arg (max_n_kv=%d)", max_n_kv);
         return sb;
     }
     if (kv_cache.self_k == nullptr) {
@@ -739,9 +650,8 @@ StepBuild build_step_graph(ggml_context *                  ctx,
         return sb;
     }
     if (max_n_kv > kv_cache.n_ctx) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "granite step: max_n_kv=%d exceeds kv_cache.n_ctx=%d",
-                     max_n_kv, kv_cache.n_ctx);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "granite step: max_n_kv=%d exceeds kv_cache.n_ctx=%d", max_n_kv,
+                kv_cache.n_ctx);
         return sb;
     }
 
@@ -749,8 +659,7 @@ StepBuild build_step_graph(ggml_context *                  ctx,
     const int     n_layer = hp.dec_n_layers;
     const float   rms_eps = hp.dec_rms_norm_eps;
     const float   emb_mul = hp.dec_embedding_multiplier;
-    const float   inv_log = (hp.dec_logits_scaling > 0.0f)
-                            ? (1.0f / hp.dec_logits_scaling) : 1.0f;
+    const float   inv_log = (hp.dec_logits_scaling > 0.0f) ? (1.0f / hp.dec_logits_scaling) : 1.0f;
 
     const auto params = to_params(hp);
 
@@ -772,8 +681,7 @@ StepBuild build_step_graph(ggml_context *                  ctx,
 
     ggml_cgraph * gf = ggml_new_graph_custom(ctx, /*size=*/8192, /*grads=*/false);
     if (gf == nullptr) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "granite step: ggml_new_graph_custom failed");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "granite step: ggml_new_graph_custom failed");
         return sb;
     }
     sb.graph = gf;
@@ -781,29 +689,19 @@ StepBuild build_step_graph(ggml_context *                  ctx,
     // Token embedding for the single new token + embedding_multiplier.
     ggml_tensor * x = ggml_get_rows(ctx, weights.dec_embed.token_w,
                                     sb.input_id_in);  // [hidden, 1]
-    x = ggml_scale(ctx, x, emb_mul);
+    x               = ggml_scale(ctx, x, emb_mul);
 
     for (int il = 0; il < n_layer; ++il) {
-        x = block_step(
-            ctx, gf, x,
-            weights.dec_blocks[il],
-            params,
-            kv_cache,
-            il,
-            max_n_kv,
-            sb.mask_in,
-            sb.position_in,
-            sb.kv_idx_in,
-            use_flash);
+        x = block_step(ctx, gf, x, weights.dec_blocks[il], params, kv_cache, il, max_n_kv, sb.mask_in, sb.position_in,
+                       sb.kv_idx_in, use_flash);
     }
 
     x = rms_norm(ctx, x, weights.dec_final.norm_w, rms_eps);
-    ggml_tensor * head_w = (weights.dec_final.output_w != nullptr)
-                            ? weights.dec_final.output_w
-                            : weights.dec_embed.token_w;
+    ggml_tensor * head_w =
+        (weights.dec_final.output_w != nullptr) ? weights.dec_final.output_w : weights.dec_embed.token_w;
     ggml_tensor * logits = ggml_mul_mat(ctx, head_w, x);
-    logits = ggml_reshape_1d(ctx, logits, vocab);
-    logits = ggml_scale(ctx, logits, inv_log);
+    logits               = ggml_reshape_1d(ctx, logits, vocab);
+    logits               = ggml_scale(ctx, logits, inv_log);
     ggml_set_name(logits, "step.logits");
 
     ggml_tensor * amax = ggml_argmax(ctx, logits);
@@ -820,25 +718,21 @@ StepBuild build_step_graph(ggml_context *                  ctx,
 
 // Batched prefill / step (offline transcribe_run_batch).
 
-PrefillBuildBatched build_prefill_graph_batched(
-    ggml_context *                  ctx,
-    const GraniteWeights &          weights,
-    const GraniteHParams &          hp,
-    transcribe::causal_lm::KvCache & kv_cache,
-    int                             T_prompt_max,
-    int                             n_audio_max,
-    int                             n_batch,
-    bool                            use_flash)
-{
-    PrefillBuildBatched pb {};
+PrefillBuildBatched build_prefill_graph_batched(ggml_context *                   ctx,
+                                                const GraniteWeights &           weights,
+                                                const GraniteHParams &           hp,
+                                                transcribe::causal_lm::KvCache & kv_cache,
+                                                int                              T_prompt_max,
+                                                int                              n_audio_max,
+                                                int                              n_batch,
+                                                bool                             use_flash) {
+    PrefillBuildBatched pb{};
     pb.T_prompt_max = T_prompt_max;
     pb.n_audio_max  = n_audio_max;
     pb.n_batch      = n_batch;
 
-    if (ctx == nullptr || T_prompt_max <= 0 || n_audio_max <= 0 ||
-        n_batch <= 0 || !use_flash ||
-        kv_cache.self_k == nullptr || kv_cache.n_batch != n_batch ||
-        T_prompt_max > kv_cache.n_ctx) {
+    if (ctx == nullptr || T_prompt_max <= 0 || n_audio_max <= 0 || n_batch <= 0 || !use_flash ||
+        kv_cache.self_k == nullptr || kv_cache.n_batch != n_batch || T_prompt_max > kv_cache.n_ctx) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "granite prefill(batched): invalid arg");
         return pb;
     }
@@ -848,10 +742,9 @@ PrefillBuildBatched build_prefill_graph_batched(
     const int     n_layer = hp.dec_n_layers;
     const float   rms_eps = hp.dec_rms_norm_eps;
     const float   emb_mul = hp.dec_embedding_multiplier;
-    const float   inv_log = (hp.dec_logits_scaling > 0.0f)
-                            ? (1.0f / hp.dec_logits_scaling) : 1.0f;
+    const float   inv_log = (hp.dec_logits_scaling > 0.0f) ? (1.0f / hp.dec_logits_scaling) : 1.0f;
     const int     B       = n_batch;
-    const auto params = to_params(hp);
+    const auto    params  = to_params(hp);
 
     pb.input_ids_in = ggml_new_tensor_2d(ctx, GGML_TYPE_I32, T_prompt_max, B);
     ggml_set_input(pb.input_ids_in);
@@ -859,11 +752,9 @@ PrefillBuildBatched build_prefill_graph_batched(
     // set_rows): a k-quant token_embd get_rows is unsupported on CUDA and runs
     // on CPU; a set_rows consuming that CPU tensor straddles the CPU/CUDA split
     // and faults. x*keep_mask + audio_dense crosses the split cleanly.
-    pb.audio_dense_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, hidden,
-                                           static_cast<int64_t>(T_prompt_max) * B);
+    pb.audio_dense_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, hidden, static_cast<int64_t>(T_prompt_max) * B);
     ggml_set_input(pb.audio_dense_in);
-    pb.keep_mask_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, 1,
-                                         static_cast<int64_t>(T_prompt_max) * B);
+    pb.keep_mask_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, 1, static_cast<int64_t>(T_prompt_max) * B);
     ggml_set_input(pb.keep_mask_in);
     pb.positions_in = ggml_new_tensor_1d(ctx, GGML_TYPE_I32, T_prompt_max);
     ggml_set_input(pb.positions_in);
@@ -875,57 +766,57 @@ PrefillBuildBatched build_prefill_graph_batched(
     ggml_set_input(pb.last_idx_in);
 
     ggml_cgraph * gf = ggml_new_graph_custom(ctx, /*size=*/16384, /*grads=*/false);
-    if (gf == nullptr) return pb;
+    if (gf == nullptr) {
+        return pb;
+    }
     pb.graph = gf;
 
-    ggml_tensor * ids_flat =
-        ggml_reshape_1d(ctx, pb.input_ids_in, static_cast<int64_t>(T_prompt_max) * B);
+    ggml_tensor * ids_flat = ggml_reshape_1d(ctx, pb.input_ids_in, static_cast<int64_t>(T_prompt_max) * B);
     // x is 2D [hidden, T_prompt_max*B] (contiguous). Blend the audio embeds in
     // elementwise: x = x*keep_mask + audio_dense. keep_mask broadcasts over
     // hidden (ne[0]). Then reshape to 3D for the batched block stack.
-    ggml_tensor * x = ggml_get_rows(ctx, weights.dec_embed.token_w, ids_flat);
-    x = ggml_add(ctx, ggml_mul(ctx, x, pb.keep_mask_in), pb.audio_dense_in);
-    x = ggml_reshape_3d(ctx, x, hidden, T_prompt_max, B);
-    x = ggml_scale(ctx, x, emb_mul);   // embedding_multiplier (after injection)
+    ggml_tensor * x        = ggml_get_rows(ctx, weights.dec_embed.token_w, ids_flat);
+    x                      = ggml_add(ctx, ggml_mul(ctx, x, pb.keep_mask_in), pb.audio_dense_in);
+    x                      = ggml_reshape_3d(ctx, x, hidden, T_prompt_max, B);
+    x                      = ggml_scale(ctx, x, emb_mul);  // embedding_multiplier (after injection)
 
     for (int il = 0; il < n_layer; ++il) {
-        x = block_prefill_batched(ctx, gf, x, weights.dec_blocks[il], params,
-                                  kv_cache, il, T_prompt_max, B,
-                                  pb.mask_in, pb.positions_in, pb.kv_idx_in, use_flash);
-        if (x == nullptr) { pb.graph = nullptr; return pb; }
+        x = block_prefill_batched(ctx, gf, x, weights.dec_blocks[il], params, kv_cache, il, T_prompt_max, B, pb.mask_in,
+                                  pb.positions_in, pb.kv_idx_in, use_flash);
+        if (x == nullptr) {
+            pb.graph = nullptr;
+            return pb;
+        }
     }
 
     ggml_tensor * x_last = ggml_get_rows(ctx, x, pb.last_idx_in);
-    x_last = ggml_reshape_2d(ctx, x_last, hidden, B);
-    x_last = rms_norm(ctx, x_last, weights.dec_final.norm_w, rms_eps);
-    ggml_tensor * head_w = (weights.dec_final.output_w != nullptr)
-                            ? weights.dec_final.output_w : weights.dec_embed.token_w;
+    x_last               = ggml_reshape_2d(ctx, x_last, hidden, B);
+    x_last               = rms_norm(ctx, x_last, weights.dec_final.norm_w, rms_eps);
+    ggml_tensor * head_w =
+        (weights.dec_final.output_w != nullptr) ? weights.dec_final.output_w : weights.dec_embed.token_w;
     ggml_tensor * logits = ggml_mul_mat(ctx, head_w, x_last);
-    logits = ggml_reshape_2d(ctx, logits, vocab, B);
-    logits = ggml_scale(ctx, logits, inv_log);
-    pb.logits = logits;
-    pb.out = ggml_argmax(ctx, logits);
+    logits               = ggml_reshape_2d(ctx, logits, vocab, B);
+    logits               = ggml_scale(ctx, logits, inv_log);
+    pb.logits            = logits;
+    pb.out               = ggml_argmax(ctx, logits);
     ggml_set_output(pb.out);
     ggml_build_forward_expand(gf, pb.out);
     ggml_build_forward_expand(gf, logits);
     return pb;
 }
 
-StepBuildBatched build_step_graph_batched(
-    ggml_context *                  ctx,
-    const GraniteWeights &          weights,
-    const GraniteHParams &          hp,
-    transcribe::causal_lm::KvCache & kv_cache,
-    int                             max_n_kv,
-    int                             n_batch,
-    bool                            use_flash)
-{
-    StepBuildBatched sb {};
+StepBuildBatched build_step_graph_batched(ggml_context *                   ctx,
+                                          const GraniteWeights &           weights,
+                                          const GraniteHParams &           hp,
+                                          transcribe::causal_lm::KvCache & kv_cache,
+                                          int                              max_n_kv,
+                                          int                              n_batch,
+                                          bool                             use_flash) {
+    StepBuildBatched sb{};
     sb.max_n_kv = max_n_kv;
     sb.n_batch  = n_batch;
-    if (ctx == nullptr || max_n_kv <= 0 || n_batch <= 0 || !use_flash ||
-        kv_cache.self_k == nullptr || kv_cache.n_batch != n_batch ||
-        max_n_kv > kv_cache.n_ctx) {
+    if (ctx == nullptr || max_n_kv <= 0 || n_batch <= 0 || !use_flash || kv_cache.self_k == nullptr ||
+        kv_cache.n_batch != n_batch || max_n_kv > kv_cache.n_ctx) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "granite step(batched): invalid arg");
         return sb;
     }
@@ -934,10 +825,9 @@ StepBuildBatched build_step_graph_batched(
     const int     n_layer = hp.dec_n_layers;
     const float   rms_eps = hp.dec_rms_norm_eps;
     const float   emb_mul = hp.dec_embedding_multiplier;
-    const float   inv_log = (hp.dec_logits_scaling > 0.0f)
-                            ? (1.0f / hp.dec_logits_scaling) : 1.0f;
+    const float   inv_log = (hp.dec_logits_scaling > 0.0f) ? (1.0f / hp.dec_logits_scaling) : 1.0f;
     const int     B       = n_batch;
-    const auto params = to_params(hp);
+    const auto    params  = to_params(hp);
 
     sb.input_ids_in = ggml_new_tensor_1d(ctx, GGML_TYPE_I32, B);
     ggml_set_input(sb.input_ids_in);
@@ -949,30 +839,34 @@ StepBuildBatched build_step_graph_batched(
     ggml_set_input(sb.mask_in);
 
     ggml_cgraph * gf = ggml_new_graph_custom(ctx, /*size=*/8192, /*grads=*/false);
-    if (gf == nullptr) return sb;
+    if (gf == nullptr) {
+        return sb;
+    }
     sb.graph = gf;
 
     ggml_tensor * x = ggml_get_rows(ctx, weights.dec_embed.token_w, sb.input_ids_in);
-    x = ggml_scale(ctx, x, emb_mul);
+    x               = ggml_scale(ctx, x, emb_mul);
     for (int il = 0; il < n_layer; ++il) {
-        x = block_step_batched(ctx, gf, x, weights.dec_blocks[il], params,
-                               kv_cache, il, max_n_kv, B,
-                               sb.mask_in, sb.position_in, sb.kv_idx_in, use_flash);
-        if (x == nullptr) { sb.graph = nullptr; return sb; }
+        x = block_step_batched(ctx, gf, x, weights.dec_blocks[il], params, kv_cache, il, max_n_kv, B, sb.mask_in,
+                               sb.position_in, sb.kv_idx_in, use_flash);
+        if (x == nullptr) {
+            sb.graph = nullptr;
+            return sb;
+        }
     }
 
     x = rms_norm(ctx, x, weights.dec_final.norm_w, rms_eps);
-    ggml_tensor * head_w = (weights.dec_final.output_w != nullptr)
-                            ? weights.dec_final.output_w : weights.dec_embed.token_w;
+    ggml_tensor * head_w =
+        (weights.dec_final.output_w != nullptr) ? weights.dec_final.output_w : weights.dec_embed.token_w;
     ggml_tensor * logits = ggml_mul_mat(ctx, head_w, x);
-    logits = ggml_reshape_2d(ctx, logits, vocab, B);
-    logits = ggml_scale(ctx, logits, inv_log);
-    sb.logits = logits;
-    sb.out = ggml_argmax(ctx, logits);
+    logits               = ggml_reshape_2d(ctx, logits, vocab, B);
+    logits               = ggml_scale(ctx, logits, inv_log);
+    sb.logits            = logits;
+    sb.out               = ggml_argmax(ctx, logits);
     ggml_set_output(sb.out);
     ggml_build_forward_expand(gf, sb.out);
     ggml_build_forward_expand(gf, logits);
     return sb;
 }
 
-} // namespace transcribe::granite
+}  // namespace transcribe::granite
diff --git a/src/arch/granite/decoder.h b/src/arch/granite/decoder.h
index 18e2c033..3c6c9bc3 100644
--- a/src/arch/granite/decoder.h
+++ b/src/arch/granite/decoder.h
@@ -36,12 +36,11 @@
 
 #pragma once
 
+#include "causal_lm/causal_lm.h"  // reuse KvCache only
+#include "ggml.h"
 #include "granite.h"
-#include "causal_lm/causal_lm.h"   // reuse KvCache only
 #include "weights.h"
 
-#include "ggml.h"
-
 struct ggml_context;
 struct ggml_cgraph;
 struct ggml_tensor;
@@ -64,8 +63,8 @@ struct PrefillBuild {
     ggml_tensor * positions_in   = nullptr;  // [T_prompt] i32 for RoPE
     ggml_tensor * mask_in        = nullptr;  // [T_prompt, T_prompt] f16 (causal)
     ggml_tensor * out            = nullptr;  // [vocab] — last-position logits
-    DecoderDumps  dumps {};
-    ggml_cgraph * graph          = nullptr;
+    DecoderDumps  dumps{};
+    ggml_cgraph * graph = nullptr;
 
     int T_prompt       = 0;
     int n_audio_tokens = 0;
@@ -81,38 +80,38 @@ struct PrefillBuild {
 //
 // The kv_cache is WRITTEN by the graph. Callers should set
 // kv_cache.n = T_prompt and kv_cache.head = T_prompt after compute.
-PrefillBuild build_prefill_graph(ggml_context *                  ctx,
-                                 const GraniteWeights &          weights,
-                                 const GraniteHParams &          hp,
+PrefillBuild build_prefill_graph(ggml_context *                   ctx,
+                                 const GraniteWeights &           weights,
+                                 const GraniteHParams &           hp,
                                  transcribe::causal_lm::KvCache & kv_cache,
-                                 int                             T_prompt,
-                                 int                             n_audio_tokens,
-                                 int                             prefix_len,
-                                 int                             suffix_len,
-                                 bool                            use_flash,
-                                 bool                            slice_last);
+                                 int                              T_prompt,
+                                 int                              n_audio_tokens,
+                                 int                              prefix_len,
+                                 int                              suffix_len,
+                                 bool                             use_flash,
+                                 bool                             slice_last);
 
 // Step graph (one token).
 
 struct StepBuild {
-    ggml_tensor * input_id_in  = nullptr;  // [1] i32
-    ggml_tensor * position_in  = nullptr;  // [1] i32, value = n_past
-    ggml_tensor * kv_idx_in    = nullptr;  // [1] i64, KV write position
-    ggml_tensor * mask_in      = nullptr;  // [max_n_kv, 1] f16
-    ggml_tensor * out          = nullptr;  // [1] i32 — argmax token id
-    ggml_cgraph * graph        = nullptr;
+    ggml_tensor * input_id_in = nullptr;  // [1] i32
+    ggml_tensor * position_in = nullptr;  // [1] i32, value = n_past
+    ggml_tensor * kv_idx_in   = nullptr;  // [1] i64, KV write position
+    ggml_tensor * mask_in     = nullptr;  // [max_n_kv, 1] f16
+    ggml_tensor * out         = nullptr;  // [1] i32 — argmax token id
+    ggml_cgraph * graph       = nullptr;
 
     int max_n_kv = 0;
 };
 
 // Build a static-shape single-token step graph reusable across every
 // autoregressive step. Topology depends only on max_n_kv.
-StepBuild build_step_graph(ggml_context *                  ctx,
-                           const GraniteWeights &          weights,
-                           const GraniteHParams &          hp,
+StepBuild build_step_graph(ggml_context *                   ctx,
+                           const GraniteWeights &           weights,
+                           const GraniteHParams &           hp,
                            transcribe::causal_lm::KvCache & kv_cache,
-                           int                             max_n_kv,
-                           bool                            use_flash);
+                           int                              max_n_kv,
+                           bool                             use_flash);
 
 // Batched prefill / step (offline transcribe_run_batch).
 // Same recipe as the causal_lm families but with Granite block math (no Q/K
@@ -135,20 +134,19 @@ struct PrefillBuildBatched {
     ggml_tensor * logits         = nullptr;  // [vocab, B]
     ggml_tensor * out            = nullptr;  // [B] i32 argmax
     ggml_cgraph * graph          = nullptr;
-    int T_prompt_max   = 0;
-    int n_audio_max    = 0;
-    int n_batch        = 0;
+    int           T_prompt_max   = 0;
+    int           n_audio_max    = 0;
+    int           n_batch        = 0;
 };
 
-PrefillBuildBatched build_prefill_graph_batched(
-    ggml_context *                  ctx,
-    const GraniteWeights &          weights,
-    const GraniteHParams &          hp,
-    transcribe::causal_lm::KvCache & kv_cache,
-    int                             T_prompt_max,
-    int                             n_audio_max,
-    int                             n_batch,
-    bool                            use_flash);
+PrefillBuildBatched build_prefill_graph_batched(ggml_context *                   ctx,
+                                                const GraniteWeights &           weights,
+                                                const GraniteHParams &           hp,
+                                                transcribe::causal_lm::KvCache & kv_cache,
+                                                int                              T_prompt_max,
+                                                int                              n_audio_max,
+                                                int                              n_batch,
+                                                bool                             use_flash);
 
 struct StepBuildBatched {
     ggml_tensor * input_ids_in = nullptr;  // [B] i32
@@ -158,17 +156,16 @@ struct StepBuildBatched {
     ggml_tensor * logits       = nullptr;  // [vocab, B]
     ggml_tensor * out          = nullptr;  // [B] i32 argmax
     ggml_cgraph * graph        = nullptr;
-    int max_n_kv = 0;
-    int n_batch  = 0;
+    int           max_n_kv     = 0;
+    int           n_batch      = 0;
 };
 
-StepBuildBatched build_step_graph_batched(
-    ggml_context *                  ctx,
-    const GraniteWeights &          weights,
-    const GraniteHParams &          hp,
-    transcribe::causal_lm::KvCache & kv_cache,
-    int                             max_n_kv,
-    int                             n_batch,
-    bool                            use_flash);
+StepBuildBatched build_step_graph_batched(ggml_context *                   ctx,
+                                          const GraniteWeights &           weights,
+                                          const GraniteHParams &           hp,
+                                          transcribe::causal_lm::KvCache & kv_cache,
+                                          int                              max_n_kv,
+                                          int                              n_batch,
+                                          bool                             use_flash);
 
-} // namespace transcribe::granite
+}  // namespace transcribe::granite
diff --git a/src/arch/granite/encoder.cpp b/src/arch/granite/encoder.cpp
index 14971993..08da2c8f 100644
--- a/src/arch/granite/encoder.cpp
+++ b/src/arch/granite/encoder.cpp
@@ -28,16 +28,14 @@
 
 #include "encoder.h"
 
-#include "granite.h"
-#include "weights.h"
-
 #include "conformer/conformer.h"
+#include "ggml.h"
+#include "granite.h"
 #include "granite_conformer/shaw_attn.h"
 #include "transcribe-debug.h"
-#include "transcribe-mel.h"
 #include "transcribe-log.h"
-
-#include "ggml.h"
+#include "transcribe-mel.h"
+#include "weights.h"
 
 #include <algorithm>
 #include <cmath>
@@ -63,20 +61,16 @@ ggml_tensor * named(ggml_tensor * t, const char * name) {
     return t;
 }
 
-ggml_tensor * layer_norm(ggml_context * ctx, ggml_tensor * x,
-                         ggml_tensor * gamma, ggml_tensor * beta)
-{
+ggml_tensor * layer_norm(ggml_context * ctx, ggml_tensor * x, ggml_tensor * gamma, ggml_tensor * beta) {
     ggml_tensor * y = ggml_norm(ctx, x, kLayerNormEps);
-    y = ggml_mul(ctx, y, gamma);
+    y               = ggml_mul(ctx, y, gamma);
     if (beta != nullptr) {
         y = ggml_add(ctx, y, beta);
     }
     return y;
 }
 
-ggml_tensor * linear(ggml_context * ctx, ggml_tensor * x,
-                     ggml_tensor * w, ggml_tensor * b)
-{
+ggml_tensor * linear(ggml_context * ctx, ggml_tensor * x, ggml_tensor * w, ggml_tensor * b) {
     ggml_tensor * y = ggml_mul_mat(ctx, w, x);
     if (b != nullptr) {
         y = ggml_add(ctx, y, b);
@@ -84,31 +78,25 @@ ggml_tensor * linear(ggml_context * ctx, ggml_tensor * x,
     return y;
 }
 
-} // namespace
+}  // namespace
 
 // Host-side mel + 2-frame stack.
 
-transcribe_status compute_mel_encoder_input(
-    const transcribe::MelFrontend & mel,
-    const float *                   pcm,
-    int                             n_samples,
-    int                             n_threads,
-    std::vector<float> &            out_mel,
-    int &                           out_t_enc)
-{
+transcribe_status compute_mel_encoder_input(const transcribe::MelFrontend & mel,
+                                            const float *                   pcm,
+                                            int                             n_samples,
+                                            int                             n_threads,
+                                            std::vector<float> &            out_mel,
+                                            int &                           out_t_enc) {
     if (pcm == nullptr || n_samples <= 0) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
 
     std::vector<float> raw;
-    int n_mels   = 0;
-    int n_frames = 0;
-    if (const transcribe_status st = mel.compute(pcm,
-                                                 static_cast<size_t>(n_samples),
-                                                 raw, n_mels, n_frames,
-                                                 n_threads);
-        st != TRANSCRIBE_OK)
-    {
+    int                n_mels   = 0;
+    int                n_frames = 0;
+    if (const transcribe_status st = mel.compute(pcm, static_cast<size_t>(n_samples), raw, n_mels, n_frames, n_threads);
+        st != TRANSCRIBE_OK) {
         return st;
     }
 
@@ -131,9 +119,7 @@ transcribe_status compute_mel_encoder_input(
     // recover that as raw.size() / n_mels.
     const int stride = static_cast<int>(raw.size() / static_cast<size_t>(n_mels));
     if (stride <= 0 || stride < n_frames) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "granite: mel buffer stride (%d) < expected frames (%d)",
-                     stride, n_frames);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "granite: mel buffer stride (%d) < expected frames (%d)", stride, n_frames);
         return TRANSCRIBE_ERR_GGUF;
     }
 
@@ -142,8 +128,8 @@ transcribe_status compute_mel_encoder_input(
     for (int t = 0; t < t_enc; ++t) {
         float * dst = out_mel.data() + static_cast<size_t>(t) * input_dim;
         for (int m = 0; m < n_mels; ++m) {
-            dst[m]            = raw[static_cast<size_t>(m) * stride + 2 * t    ];
-            dst[m + n_mels]   = raw[static_cast<size_t>(m) * stride + 2 * t + 1];
+            dst[m]          = raw[static_cast<size_t>(m) * stride + 2 * t];
+            dst[m + n_mels] = raw[static_cast<size_t>(m) * stride + 2 * t + 1];
         }
     }
     out_t_enc = t_enc;
@@ -152,8 +138,7 @@ transcribe_status compute_mel_encoder_input(
 
 // Shaw attention_dists + last-block mask.
 
-std::vector<int32_t> precompute_attention_dists(int context_size, int max_pos_emb)
-{
+std::vector<int32_t> precompute_attention_dists(int context_size, int max_pos_emb) {
     // Reference (modeling_granite_speech.py:295-297):
     //   seq = torch.arange(context_size)
     //   relpos_dist = seq.view(-1, 1) - seq.view(1, -1)
@@ -168,18 +153,20 @@ std::vector<int32_t> precompute_attention_dists(int context_size, int max_pos_em
     for (int c = 0; c < context_size; ++c) {
         for (int r = 0; r < context_size; ++r) {
             int d = c - r;
-            if (d < -context_size) d = -context_size;
-            if (d >  context_size) d =  context_size;
+            if (d < -context_size) {
+                d = -context_size;
+            }
+            if (d > context_size) {
+                d = context_size;
+            }
             // Row-major: dists[c * context_size + r].
-            dists[static_cast<size_t>(c) * context_size + r] =
-                static_cast<int32_t>(d + max_pos_emb);
+            dists[static_cast<size_t>(c) * context_size + r] = static_cast<int32_t>(d + max_pos_emb);
         }
     }
     return dists;
 }
 
-std::vector<float> precompute_last_block_mask(int context_size, int t_enc_remainder)
-{
+std::vector<float> precompute_last_block_mask(int context_size, int t_enc_remainder) {
     // t_enc_remainder is the number of REAL positions in the last
     // block. Positions in [t_enc_remainder, context_size) are pad.
     //
@@ -217,23 +204,13 @@ namespace {
 // Reuses transcribe::conformer::macaron_ff_residual which has the
 // exact same shape (pre-LN with bias, two biased linears, SiLU between,
 // 0.5x residual scale).
-ggml_tensor * granite_macaron(ggml_context * ctx,
-                              ggml_tensor *  x,
-                              const GraniteEncBlock & b,
-                              bool           is_ff1)
-{
+ggml_tensor * granite_macaron(ggml_context * ctx, ggml_tensor * x, const GraniteEncBlock & b, bool is_ff1) {
     if (is_ff1) {
-        return transcribe::conformer::macaron_ff_residual(
-            ctx, x,
-            b.norm_ff1_w, b.norm_ff1_b,
-            b.ff1_up_w,   b.ff1_up_b,
-            b.ff1_down_w, b.ff1_down_b);
+        return transcribe::conformer::macaron_ff_residual(ctx, x, b.norm_ff1_w, b.norm_ff1_b, b.ff1_up_w, b.ff1_up_b,
+                                                          b.ff1_down_w, b.ff1_down_b);
     } else {
-        return transcribe::conformer::macaron_ff_residual(
-            ctx, x,
-            b.norm_ff2_w, b.norm_ff2_b,
-            b.ff2_up_w,   b.ff2_up_b,
-            b.ff2_down_w, b.ff2_down_b);
+        return transcribe::conformer::macaron_ff_residual(ctx, x, b.norm_ff2_w, b.norm_ff2_b, b.ff2_up_w, b.ff2_up_b,
+                                                          b.ff2_down_w, b.ff2_down_b);
     }
 }
 
@@ -249,8 +226,7 @@ ggml_tensor * granite_conv_module(ggml_context *          ctx,
                                   ggml_tensor *           bn_fused_scale,
                                   ggml_tensor *           bn_fused_bias,
                                   int                     conv_kernel,
-                                  int                     inner_dim)
-{
+                                  int                     inner_dim) {
     const int64_t d_model = x->ne[0];
     const int64_t T       = x->ne[1];
 
@@ -261,20 +237,16 @@ ggml_tensor * granite_conv_module(ggml_context *          ctx,
     // After reshape to [d_model, 2*inner_dim] and mul_mat with
     // [d_model, T], output is [2*inner_dim, T].
     {
-        ggml_tensor * pw1 = ggml_reshape_2d(ctx, b.conv_pointwise1_w,
-                                            d_model, 2 * inner_dim);
-        x = ggml_mul_mat(ctx, pw1, x);  // [2*inner_dim, T]
-        x = ggml_add(ctx, x, b.conv_pointwise1_b);
+        ggml_tensor * pw1 = ggml_reshape_2d(ctx, b.conv_pointwise1_w, d_model, 2 * inner_dim);
+        x                 = ggml_mul_mat(ctx, pw1, x);  // [2*inner_dim, T]
+        x                 = ggml_add(ctx, x, b.conv_pointwise1_b);
     }
 
     // GLU: split ne[0] in half, gate * sigmoid(value).
     {
-        ggml_tensor * gate  = ggml_view_2d(ctx, x, inner_dim, T,
-                                           x->nb[1], /*offset=*/0);
-        ggml_tensor * value = ggml_view_2d(ctx, x, inner_dim, T,
-                                           x->nb[1],
-                                           inner_dim * ggml_element_size(x));
-        x = ggml_mul(ctx, gate, ggml_sigmoid(ctx, value));
+        ggml_tensor * gate  = ggml_view_2d(ctx, x, inner_dim, T, x->nb[1], /*offset=*/0);
+        ggml_tensor * value = ggml_view_2d(ctx, x, inner_dim, T, x->nb[1], inner_dim * ggml_element_size(x));
+        x                   = ggml_mul(ctx, gate, ggml_sigmoid(ctx, value));
     }
     // x ne = [inner_dim, T]
 
@@ -284,15 +256,12 @@ ggml_tensor * granite_conv_module(ggml_context *          ctx,
     // Depthwise conv1d: kernel [k, 1, inner_dim], symmetric pad (k-1)/2
     // (= 7 for k=15). Granite's depthwise has no bias.
     const int padding = (conv_kernel - 1) / 2;
-    x = transcribe::conformer::conv_1d_dw_f32(
-        ctx, b.conv_depthwise_w, x,
-        /*stride=*/1, /*padding=*/padding, /*dilation=*/1);
+    x                 = transcribe::conformer::conv_1d_dw_f32(ctx, b.conv_depthwise_w, x,
+                                                              /*stride=*/1, /*padding=*/padding, /*dilation=*/1);
 
     // Fused BatchNorm: y = x * fused_scale + fused_bias, with 1-D scale
     // and bias broadcast across the time axis.
-    x = transcribe::conformer::fused_batch_norm(ctx, x,
-                                                bn_fused_scale,
-                                                bn_fused_bias);
+    x = transcribe::conformer::fused_batch_norm(ctx, x, bn_fused_scale, bn_fused_bias);
 
     x = ggml_silu(ctx, x);
 
@@ -303,39 +272,35 @@ ggml_tensor * granite_conv_module(ggml_context *          ctx,
     // After reshape to [inner_dim, d_model] and mul_mat with
     // [inner_dim, T], output is [d_model, T].
     {
-        ggml_tensor * pw2 = ggml_reshape_2d(ctx, b.conv_pointwise2_w,
-                                            inner_dim, d_model);
-        x = ggml_mul_mat(ctx, pw2, x);
-        x = ggml_add(ctx, x, b.conv_pointwise2_b);
+        ggml_tensor * pw2 = ggml_reshape_2d(ctx, b.conv_pointwise2_w, inner_dim, d_model);
+        x                 = ggml_mul_mat(ctx, pw2, x);
+        x                 = ggml_add(ctx, x, b.conv_pointwise2_b);
     }
 
     return x;
 }
 
-
-} // namespace
+}  // namespace
 
 // Encoder graph.
 
-EncoderBuild build_encoder_graph(ggml_context *           ctx,
-                                 const GraniteWeights &   weights,
-                                 const GraniteHParams &   hp,
-                                 int                      T_enc,
-                                 bool                     /*use_flash*/)
-{
-    EncoderBuild eb {};
+EncoderBuild build_encoder_graph(ggml_context *         ctx,
+                                 const GraniteWeights & weights,
+                                 const GraniteHParams & hp,
+                                 int                    T_enc,
+                                 bool /*use_flash*/) {
+    EncoderBuild eb{};
     eb.n_blocks_local = (T_enc + hp.enc_context_size - 1) / hp.enc_context_size;
     const int T_pad   = eb.n_blocks_local * hp.enc_context_size;
     eb.last_block_rem = T_enc - (eb.n_blocks_local - 1) * hp.enc_context_size;
 
-    const int64_t d_model    = hp.enc_hidden;
-    const int64_t input_dim  = hp.enc_input_dim;
-    const int64_t inner_dim  = static_cast<int64_t>(hp.enc_hidden) *
-                                hp.enc_conv_expansion;
-    const int     conv_k     = hp.enc_conv_kernel_size;
-    const int     n_heads    = hp.enc_n_heads;
-    const int     head_dim   = hp.enc_head_dim;
-    const int     ctx_size   = hp.enc_context_size;
+    const int64_t d_model   = hp.enc_hidden;
+    const int64_t input_dim = hp.enc_input_dim;
+    const int64_t inner_dim = static_cast<int64_t>(hp.enc_hidden) * hp.enc_conv_expansion;
+    const int     conv_k    = hp.enc_conv_kernel_size;
+    const int     n_heads   = hp.enc_n_heads;
+    const int     head_dim  = hp.enc_head_dim;
+    const int     ctx_size  = hp.enc_context_size;
 
     // Graph inputs.
     // mel_in: [input_dim, T_enc]. Encoder operates at T_enc throughout;
@@ -348,16 +313,13 @@ EncoderBuild build_encoder_graph(ggml_context *           ctx,
     ggml_set_input(eb.mel_in);
 
     // attention_dists: [ctx_size, ctx_size] int32, row-major over (c, r).
-    eb.attention_dists = ggml_new_tensor_1d(ctx, GGML_TYPE_I32,
-                                            static_cast<int64_t>(ctx_size) * ctx_size);
+    eb.attention_dists = ggml_new_tensor_1d(ctx, GGML_TYPE_I32, static_cast<int64_t>(ctx_size) * ctx_size);
     named(eb.attention_dists, "enc.attention_dists");
     ggml_set_input(eb.attention_dists);
 
     // last_block_mask: [ctx_size, ctx_size, n_blocks_local] additive
     // mask, all zero except last slice which carries -INF in pad cells.
-    eb.last_block_mask = ggml_new_tensor_3d(ctx, GGML_TYPE_F32,
-                                            ctx_size, ctx_size,
-                                            eb.n_blocks_local);
+    eb.last_block_mask = ggml_new_tensor_3d(ctx, GGML_TYPE_F32, ctx_size, ctx_size, eb.n_blocks_local);
     named(eb.last_block_mask, "enc.last_block_mask");
     ggml_set_input(eb.last_block_mask);
 
@@ -366,16 +328,13 @@ EncoderBuild build_encoder_graph(ggml_context *           ctx,
     // is the buffer that attention's internal pre-norm output is
     // concatenated against to reach T_pad.
     if (T_pad > T_enc) {
-        eb.zero_pad = ggml_new_tensor_2d(ctx, GGML_TYPE_F32,
-                                         d_model, T_pad - T_enc);
+        eb.zero_pad = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, d_model, T_pad - T_enc);
         named(eb.zero_pad, "enc.zero_pad");
         ggml_set_input(eb.zero_pad);
     }
 
     // Input linear (160 -> 1024).
-    ggml_tensor * x = linear(ctx, eb.mel_in,
-                             weights.enc_top.input_linear_w,
-                             weights.enc_top.input_linear_b);
+    ggml_tensor * x = linear(ctx, eb.mel_in, weights.enc_top.input_linear_w, weights.enc_top.input_linear_b);
     // x ne = [d_model, T_enc]
     named(x, "enc.input_linear.out");
     eb.dumps.input_linear_out = x;
@@ -386,7 +345,7 @@ EncoderBuild build_encoder_graph(ggml_context *           ctx,
     //   scale_i = bn_gamma_i / sqrt(bn_var_i + eps)
     //   bias_i  = bn_beta_i  - bn_mean_i * scale_i
 
-    const int n_layers = static_cast<int>(weights.enc_blocks.size());
+    const int n_layers     = static_cast<int>(weights.enc_blocks.size());
     const int bypass_after = hp.enc_n_layers / 2;  // 1-indexed boundary
 
     // cat_hidden_layers captures (post-LN, pre-bypass). Empty for 1b/2b;
@@ -408,17 +367,12 @@ EncoderBuild build_encoder_graph(ggml_context *           ctx,
         // reference where to_out runs on the unpadded slice. This is
         // load-bearing: the conv module below cannot see pad-row
         // garbage near the tail (depthwise kernel would spread it).
-        const transcribe::granite_conformer::ShawAttnWeights shaw_w {
-            b.norm_attn_w, b.norm_attn_b,
-            b.attn_q_w, b.attn_kv_w, b.attn_rel_pos_emb,
-            b.attn_out_w, b.attn_out_b,
+        const transcribe::granite_conformer::ShawAttnWeights shaw_w{
+            b.norm_attn_w, b.norm_attn_b, b.attn_q_w, b.attn_kv_w, b.attn_rel_pos_emb, b.attn_out_w, b.attn_out_b,
         };
         ggml_tensor * attn_out = transcribe::granite_conformer::shaw_block_attn(
-            ctx, x,
-            eb.zero_pad, eb.attention_dists, eb.last_block_mask,
-            shaw_w,
-            n_heads, head_dim, ctx_size, eb.n_blocks_local, T_enc,
-            kLayerNormEps);
+            ctx, x, eb.zero_pad, eb.attention_dists, eb.last_block_mask, shaw_w, n_heads, head_dim, ctx_size,
+            eb.n_blocks_local, T_enc, kLayerNormEps);
         if (attn_out == nullptr) {
             return eb;
         }
@@ -429,11 +383,9 @@ EncoderBuild build_encoder_graph(ggml_context *           ctx,
         //   scale = bn_w / sqrt(bn_var + eps)
         //   bias  = bn_b - bn_mean * scale
         // into [inner_dim] tensors stashed under conv_bn_fused_*.
-        ggml_tensor * conv_out = granite_conv_module(
-            ctx, x, b,
-            b.conv_bn_fused_scale, b.conv_bn_fused_bias,
-            conv_k, static_cast<int>(inner_dim));
-        x = ggml_add(ctx, x, conv_out);
+        ggml_tensor * conv_out = granite_conv_module(ctx, x, b, b.conv_bn_fused_scale, b.conv_bn_fused_bias, conv_k,
+                                                     static_cast<int>(inner_dim));
+        x                      = ggml_add(ctx, x, conv_out);
 
         // --- FF2 macaron half ---
         x = granite_macaron(ctx, x, b, /*is_ff1=*/false);
@@ -462,18 +414,14 @@ EncoderBuild build_encoder_graph(ggml_context *           ctx,
         // Reference: triggered when (i + 1) == num_layers // 2.
         if ((i + 1) == bypass_after) {
             // x: [d_model, T_pad]. ctc_proj: d_model -> output_dim.
-            ggml_tensor * ctc_logits = ggml_mul_mat(ctx,
-                                                    weights.enc_top.ctc_proj_w,
-                                                    x);
-            ctc_logits = ggml_add(ctx, ctc_logits, weights.enc_top.ctc_proj_b);
+            ggml_tensor * ctc_logits = ggml_mul_mat(ctx, weights.enc_top.ctc_proj_w, x);
+            ctc_logits               = ggml_add(ctx, ctc_logits, weights.enc_top.ctc_proj_b);
             // softmax over the channel axis (ne[0]).
-            ggml_tensor * ctc_soft = ggml_soft_max(ctx, ctc_logits);
+            ggml_tensor * ctc_soft   = ggml_soft_max(ctx, ctc_logits);
             // ctc_bypass: output_dim -> d_model.
-            ggml_tensor * bypass = ggml_mul_mat(ctx,
-                                                weights.enc_top.ctc_bypass_w,
-                                                ctc_soft);
-            bypass = ggml_add(ctx, bypass, weights.enc_top.ctc_bypass_b);
-            x = ggml_add(ctx, x, bypass);
+            ggml_tensor * bypass     = ggml_mul_mat(ctx, weights.enc_top.ctc_bypass_w, ctc_soft);
+            bypass                   = ggml_add(ctx, bypass, weights.enc_top.ctc_bypass_b);
+            x                        = ggml_add(ctx, x, bypass);
         }
 
         // --- Dumps ---
@@ -508,15 +456,13 @@ EncoderBuild build_encoder_graph(ggml_context *           ctx,
     // channel axis. ggml dim=0 is the channel axis for [hidden, T].
     // Build right-to-left so the final order matches HF: walk captures
     // in reverse, each prepended via concat(exp, acc).
-    for (auto it = exported_hidden_states.rbegin();
-         it != exported_hidden_states.rend(); ++it)
-    {
+    for (auto it = exported_hidden_states.rbegin(); it != exported_hidden_states.rend(); ++it) {
         x = ggml_concat(ctx, *it, x, /*dim=*/0);
     }
 
     // Final output (already at T_enc).
     named(x, "enc.out");
-    eb.out = x;
+    eb.out             = x;
     eb.dumps.out_named = x;
     ggml_set_output(eb.out);
     transcribe::debug::mark_tensor_for_dump(eb.out);
@@ -527,12 +473,20 @@ EncoderBuild build_encoder_graph(ggml_context *           ctx,
         return eb;
     }
     ggml_build_forward_expand(eb.graph, eb.out);
-    if (eb.dumps.input_linear_out) ggml_build_forward_expand(eb.graph, eb.dumps.input_linear_out);
-    if (eb.dumps.block_0_out)      ggml_build_forward_expand(eb.graph, eb.dumps.block_0_out);
-    if (eb.dumps.block_mid_out)    ggml_build_forward_expand(eb.graph, eb.dumps.block_mid_out);
-    if (eb.dumps.block_last_out)   ggml_build_forward_expand(eb.graph, eb.dumps.block_last_out);
+    if (eb.dumps.input_linear_out) {
+        ggml_build_forward_expand(eb.graph, eb.dumps.input_linear_out);
+    }
+    if (eb.dumps.block_0_out) {
+        ggml_build_forward_expand(eb.graph, eb.dumps.block_0_out);
+    }
+    if (eb.dumps.block_mid_out) {
+        ggml_build_forward_expand(eb.graph, eb.dumps.block_mid_out);
+    }
+    if (eb.dumps.block_last_out) {
+        ggml_build_forward_expand(eb.graph, eb.dumps.block_last_out);
+    }
 
     return eb;
 }
 
-} // namespace transcribe::granite
+}  // namespace transcribe::granite
diff --git a/src/arch/granite/encoder.h b/src/arch/granite/encoder.h
index 1ef92be4..1e10b5fc 100644
--- a/src/arch/granite/encoder.h
+++ b/src/arch/granite/encoder.h
@@ -23,9 +23,8 @@
 
 #pragma once
 
-#include "weights.h"
-
 #include "ggml.h"
+#include "weights.h"
 
 #include <cstdint>
 #include <vector>
@@ -34,7 +33,9 @@ struct ggml_context;
 struct ggml_tensor;
 struct ggml_cgraph;
 
-namespace transcribe { class MelFrontend; }
+namespace transcribe {
+class MelFrontend;
+}
 
 namespace transcribe::granite {
 
@@ -48,33 +49,32 @@ namespace transcribe::granite {
 //
 // Output: out_mel laid out as `[T_enc, 160]` row-major (T_enc =
 // (n_frames_after_whisper_norm // 2)).
-transcribe_status compute_mel_encoder_input(
-    const transcribe::MelFrontend & mel,
-    const float *                   pcm,
-    int                             n_samples,
-    int                             n_threads,
-    std::vector<float> &            out_mel,
-    int &                           out_t_enc);
+transcribe_status compute_mel_encoder_input(const transcribe::MelFrontend & mel,
+                                            const float *                   pcm,
+                                            int                             n_samples,
+                                            int                             n_threads,
+                                            std::vector<float> &            out_mel,
+                                            int &                           out_t_enc);
 
 // Graph construction.
 
 struct EncoderBuild {
     // Graph inputs (caller uploads at compute time).
-    ggml_tensor * mel_in            = nullptr;  // [input_dim, T_enc]
-    ggml_tensor * attention_dists   = nullptr;  // [context_size, context_size]
-                                                //  int32, Shaw bias indices
-    ggml_tensor * last_block_mask   = nullptr;  // [context_size, context_size]
-                                                //  f32 additive mask, all
-                                                //  zeros except final-block
-                                                //  pad positions = -INF
+    ggml_tensor * mel_in          = nullptr;  // [input_dim, T_enc]
+    ggml_tensor * attention_dists = nullptr;  // [context_size, context_size]
+                                              //  int32, Shaw bias indices
+    ggml_tensor * last_block_mask = nullptr;  // [context_size, context_size]
+                                              //  f32 additive mask, all
+                                              //  zeros except final-block
+                                              //  pad positions = -INF
     // Zero-pad tile for attention's internal T_enc → T_pad expansion.
     // Allocated only when T_enc is not a multiple of context_size;
     // shape [hidden, T_pad - T_enc] f32. Caller uploads explicit zeros.
-    ggml_tensor * zero_pad          = nullptr;
+    ggml_tensor * zero_pad        = nullptr;
     // Graph output (encoder's [hidden, T_enc] tensor).
-    ggml_tensor * out               = nullptr;
+    ggml_tensor * out             = nullptr;
 
-    ggml_cgraph * graph             = nullptr;
+    ggml_cgraph * graph = nullptr;
 
     // Dump points (exposed so model.cpp can wire them up).
     struct Dumps {
@@ -87,8 +87,8 @@ struct EncoderBuild {
 
     // Padding bookkeeping computed at build (caller uploads matching
     // attention_dists / last_block_mask shapes).
-    int n_blocks_local = 0;   // ceil(T_enc / context_size)
-    int last_block_rem = 0;   // T_enc % context_size (== 0 means no pad)
+    int n_blocks_local = 0;  // ceil(T_enc / context_size)
+    int last_block_rem = 0;  // T_enc % context_size (== 0 means no pad)
 };
 
 // Build the encoder graph. `T_enc` is the number of post-stack frames
@@ -96,11 +96,11 @@ struct EncoderBuild {
 // reserved for future use — the implementation uses manual mul_mat + soft_max
 // because the Shaw bias requires a per-(head, block) additive term and
 // the flash_attn_ext path doesn't yet broadcast that cleanly.
-EncoderBuild build_encoder_graph(ggml_context *           ctx,
-                                 const GraniteWeights &   weights,
-                                 const GraniteHParams &   hp,
-                                 int                      T_enc,
-                                 bool                     use_flash);
+EncoderBuild build_encoder_graph(ggml_context *         ctx,
+                                 const GraniteWeights & weights,
+                                 const GraniteHParams & hp,
+                                 int                    T_enc,
+                                 bool                   use_flash);
 
 // Host-side precomputation of the Shaw attention_dists matrix.
 // attention_dists[c, r] = clamp(c - r, -context_size, context_size) + max_pos_emb,
@@ -122,4 +122,4 @@ std::vector<int32_t> precompute_attention_dists(int context_size, int max_pos_em
 // graph builder).
 std::vector<float> precompute_last_block_mask(int context_size, int t_enc_remainder);
 
-} // namespace transcribe::granite
+}  // namespace transcribe::granite
diff --git a/src/arch/granite/granite.h b/src/arch/granite/granite.h
index c5fc35ce..7a89b0d5 100644
--- a/src/arch/granite/granite.h
+++ b/src/arch/granite/granite.h
@@ -23,17 +23,16 @@
 
 #pragma once
 
+#include "causal_lm/causal_lm.h"
+#include "ggml-backend.h"
+#include "ggml.h"
 #include "transcribe-backend.h"
-#include "transcribe-session.h"
 #include "transcribe-mel.h"
 #include "transcribe-model.h"
+#include "transcribe-session.h"
 #include "transcribe-tokenizer.h"
-#include "causal_lm/causal_lm.h"
 #include "weights.h"
 
-#include "ggml.h"
-#include "ggml-backend.h"
-
 #include <cstdint>
 #include <optional>
 #include <string>
@@ -57,20 +56,20 @@ void apply_family_invariants(transcribe_model & model);
 // piece is resolved ahead of time so vocab drift fails loudly at load instead
 // of mid-decode. All fields are resolved ids — looked up, not hardcoded.
 struct ChatTokens {
-    int32_t audio          = -1;   // <|audio|>
-    int32_t end_of_text    = -1;   // <|end_of_text|>  (also EOS / BOS)
-    int32_t pad            = -1;   // <|pad|>
-    int32_t start_of_role  = -1;   // <|start_of_role|>  (granite-4 chat only)
-    int32_t end_of_role    = -1;   // <|end_of_role|>    (granite-4 chat only)
+    int32_t audio         = -1;  // <|audio|>
+    int32_t end_of_text   = -1;  // <|end_of_text|>  (also EOS / BOS)
+    int32_t pad           = -1;  // <|pad|>
+    int32_t start_of_role = -1;  // <|start_of_role|>  (granite-4 chat only)
+    int32_t end_of_role   = -1;  // <|end_of_role|>    (granite-4 chat only)
 };
 
 // Model / Context.
 
 struct GraniteModel final : public transcribe_model {
-    Tokenizer        tok;
-    GraniteHParams   hparams;
-    GraniteWeights   weights;
-    ggml_context *   ctx_meta = nullptr;
+    Tokenizer      tok;
+    GraniteHParams hparams;
+    GraniteWeights weights;
+    ggml_context * ctx_meta = nullptr;
 
     transcribe::BackendPlan plan;
     ggml_backend_buffer_t   backend_buffer = nullptr;
@@ -114,7 +113,6 @@ struct GraniteSession final : public transcribe_session {
     std::vector<float> audio_tokens_host;
     int32_t            n_audio_tokens = 0;
 
-
     bool encoder_use_flash = true;
     bool decoder_use_flash = true;
 
@@ -125,11 +123,11 @@ struct GraniteSession final : public transcribe_session {
 
     // Batched KV cache for offline transcribe_run_batch (n_batch slabs).
     transcribe::causal_lm::KvCache kv_batch;
-    int                           kv_batch_cap   = 0;
-    int                           kv_batch_n_ctx = 0;
+    int                            kv_batch_cap   = 0;
+    int                            kv_batch_n_ctx = 0;
 
     GraniteSession() = default;
     ~GraniteSession() override;
 };
 
-} // namespace transcribe::granite
+}  // namespace transcribe::granite
diff --git a/src/arch/granite/model.cpp b/src/arch/granite/model.cpp
index 597d792e..ebfce90d 100644
--- a/src/arch/granite/model.cpp
+++ b/src/arch/granite/model.cpp
@@ -1,12 +1,12 @@
 // arch/granite/model.cpp - Granite Speech family handler.
 
-#include "granite.h"
-
 #include "decoder.h"
 #include "encoder.h"
+#include "ggml-backend.h"
+#include "ggml.h"
+#include "gguf.h"
+#include "granite.h"
 #include "projector.h"
-#include "weights.h"
-
 #include "transcribe-arch.h"
 #include "transcribe-batch-util.h"
 #include "transcribe-debug.h"
@@ -17,10 +17,7 @@
 #include "transcribe-log.h"
 #include "transcribe-mel.h"
 #include "transcribe-meta.h"
-
-#include "ggml.h"
-#include "ggml-backend.h"
-#include "gguf.h"
+#include "weights.h"
 
 #include <algorithm>
 #include <cmath>
@@ -37,7 +34,7 @@ namespace transcribe::granite {
 
 extern const Arch arch;
 
-static_assert(std::is_base_of_v<transcribe_model,   GraniteModel>);
+static_assert(std::is_base_of_v<transcribe_model, GraniteModel>);
 static_assert(std::is_base_of_v<transcribe_session, GraniteSession>);
 
 GraniteSession::~GraniteSession() {
@@ -71,9 +68,7 @@ GraniteModel::~GraniteModel() {
         ggml_backend_buffer_free(backend_buffer);
         backend_buffer = nullptr;
     }
-    for (auto it = plan.scheduler_list.rbegin();
-         it != plan.scheduler_list.rend(); ++it)
-    {
+    for (auto it = plan.scheduler_list.rbegin(); it != plan.scheduler_list.rend(); ++it) {
         ggml_backend_free(*it);
     }
     plan.scheduler_list.clear();
@@ -84,7 +79,7 @@ GraniteModel::~GraniteModel() {
 namespace {
 
 constexpr const char k_default_variant[] = "granite-speech";
-constexpr float kBnEps = 1e-5f;
+constexpr float      kBnEps              = 1e-5f;
 
 // Input-length contract (see docs/input-limits.md). Granite is a
 // hard-context-cap family: audio tokens + prompt + generation share the LLM
@@ -124,15 +119,13 @@ int granite_num_queries(const GraniteHParams & hp) {
 // is never advertised with a wrong finite number.
 int64_t granite_max_audio_ms(const GraniteHParams & hp) {
     const int num_queries = granite_num_queries(hp);
-    if (num_queries <= 0 || hp.window_size <= 0 ||
-        hp.fe_hop_length <= 0 || hp.fe_sample_rate <= 0 ||
+    if (num_queries <= 0 || hp.window_size <= 0 || hp.fe_hop_length <= 0 || hp.fe_sample_rate <= 0 ||
         hp.dec_max_position_embeddings <= 0) {
         return 0;
     }
     // Representative non-audio prompt overhead (chat affixes); advisory.
     constexpr int k_prompt_overhead = 64;
-    const int max_audio_tokens =
-        hp.dec_max_position_embeddings - k_prompt_overhead - k_gen_budget;
+    const int     max_audio_tokens  = hp.dec_max_position_embeddings - k_prompt_overhead - k_gen_budget;
     if (max_audio_tokens <= 0) {
         return 0;
     }
@@ -149,40 +142,38 @@ int64_t granite_max_audio_ms(const GraniteHParams & hp) {
 // fuse_batch_norm): scale = gamma / sqrt(var + eps), bias = beta - mean * scale.
 transcribe_status fuse_batch_norm(GraniteModel & m) {
     const size_t n_blocks = m.weights.enc_blocks.size();
-    if (n_blocks == 0) return TRANSCRIBE_OK;
+    if (n_blocks == 0) {
+        return TRANSCRIBE_OK;
+    }
 
-    const int64_t inner = static_cast<int64_t>(m.hparams.enc_hidden) *
-                          m.hparams.enc_conv_expansion;
-    const size_t tensor_bytes = static_cast<size_t>(inner) * sizeof(float);
+    const int64_t inner        = static_cast<int64_t>(m.hparams.enc_hidden) * m.hparams.enc_conv_expansion;
+    const size_t  tensor_bytes = static_cast<size_t>(inner) * sizeof(float);
 
-    const size_t ctx_size = n_blocks * 2 * ggml_tensor_overhead() + 256;
-    ggml_init_params params = { ctx_size, nullptr, /*no_alloc=*/true };
-    m.bn_fused_ctx = ggml_init(params);
+    const size_t     ctx_size = n_blocks * 2 * ggml_tensor_overhead() + 256;
+    ggml_init_params params   = { ctx_size, nullptr, /*no_alloc=*/true };
+    m.bn_fused_ctx            = ggml_init(params);
     if (m.bn_fused_ctx == nullptr) {
         transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "granite: BatchNorm-fusion context allocation failed — "
-            "out of memory.");
+                            "granite: BatchNorm-fusion context allocation failed — "
+                            "out of memory.");
         return TRANSCRIBE_ERR_OOM;
     }
 
     for (size_t i = 0; i < n_blocks; ++i) {
-        auto & b = m.weights.enc_blocks[i];
-        b.conv_bn_fused_scale = ggml_new_tensor_1d(m.bn_fused_ctx,
-                                                   GGML_TYPE_F32, inner);
-        b.conv_bn_fused_bias  = ggml_new_tensor_1d(m.bn_fused_ctx,
-                                                   GGML_TYPE_F32, inner);
+        auto & b              = m.weights.enc_blocks[i];
+        b.conv_bn_fused_scale = ggml_new_tensor_1d(m.bn_fused_ctx, GGML_TYPE_F32, inner);
+        b.conv_bn_fused_bias  = ggml_new_tensor_1d(m.bn_fused_ctx, GGML_TYPE_F32, inner);
     }
 
     // The plan's scheduler_list always has CPU last as fallback. We
     // could pin to the primary (Metal/Vulkan) but the fused buffers
     // are tiny and live the whole life of the model — putting them on
     // CPU keeps GPU memory free for KV cache + activations.
-    m.bn_fused_buffer = ggml_backend_alloc_ctx_tensors(
-        m.bn_fused_ctx, m.plan.scheduler_list.back());
+    m.bn_fused_buffer = ggml_backend_alloc_ctx_tensors(m.bn_fused_ctx, m.plan.scheduler_list.back());
     if (m.bn_fused_buffer == nullptr) {
         transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "granite: BatchNorm-fusion buffer allocation failed — "
-            "out of memory.");
+                            "granite: BatchNorm-fusion buffer allocation failed — "
+                            "out of memory.");
         return TRANSCRIBE_ERR_OOM;
     }
 
@@ -190,19 +181,17 @@ transcribe_status fuse_batch_norm(GraniteModel & m) {
     std::vector<float> fused_s(inner), fused_b(inner);
     for (size_t i = 0; i < n_blocks; ++i) {
         auto & b = m.weights.enc_blocks[i];
-        ggml_backend_tensor_get(b.conv_bn_w,    bn_w.data(), 0, tensor_bytes);
-        ggml_backend_tensor_get(b.conv_bn_b,    bn_b.data(), 0, tensor_bytes);
-        ggml_backend_tensor_get(b.conv_bn_mean, rm.data(),   0, tensor_bytes);
-        ggml_backend_tensor_get(b.conv_bn_var,  rv.data(),   0, tensor_bytes);
+        ggml_backend_tensor_get(b.conv_bn_w, bn_w.data(), 0, tensor_bytes);
+        ggml_backend_tensor_get(b.conv_bn_b, bn_b.data(), 0, tensor_bytes);
+        ggml_backend_tensor_get(b.conv_bn_mean, rm.data(), 0, tensor_bytes);
+        ggml_backend_tensor_get(b.conv_bn_var, rv.data(), 0, tensor_bytes);
         for (int64_t c = 0; c < inner; ++c) {
             const float s = bn_w[c] / std::sqrt(rv[c] + kBnEps);
-            fused_s[c] = s;
-            fused_b[c] = bn_b[c] - rm[c] * s;
+            fused_s[c]    = s;
+            fused_b[c]    = bn_b[c] - rm[c] * s;
         }
-        ggml_backend_tensor_set(b.conv_bn_fused_scale, fused_s.data(),
-                                0, tensor_bytes);
-        ggml_backend_tensor_set(b.conv_bn_fused_bias,  fused_b.data(),
-                                0, tensor_bytes);
+        ggml_backend_tensor_set(b.conv_bn_fused_scale, fused_s.data(), 0, tensor_bytes);
+        ggml_backend_tensor_set(b.conv_bn_fused_bias, fused_b.data(), 0, tensor_bytes);
     }
 
     return TRANSCRIBE_OK;
@@ -212,40 +201,36 @@ transcribe_status fuse_batch_norm(GraniteModel & m) {
 // 1b/2b, granite-4 system-role for -plus). audio exists on every variant;
 // start_of_role / end_of_role only on -plus, so they may be absent. Hard-fails
 // for the must-haves (audio, end_of_text, pad) so vocab drift surfaces at load.
-transcribe_status resolve_chat_tokens(const transcribe::Tokenizer & tok,
-                                      ChatTokens &                  out)
-{
+transcribe_status resolve_chat_tokens(const transcribe::Tokenizer & tok, ChatTokens & out) {
     // Must-have on every granite variant.
-    const struct { const char * piece; int32_t * slot; } required[] = {
+    const struct {
+        const char * piece;
+        int32_t *    slot;
+    } required[] = {
         { "<|audio|>",       &out.audio       },
         { "<|end_of_text|>", &out.end_of_text },
         { "<|pad|>",         &out.pad         },
     };
+
     for (const auto & p : required) {
         const int id = tok.find(p.piece);
         if (id < 0) {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "granite: tokenizer missing required piece \"%s\"",
-                         p.piece);
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "granite: tokenizer missing required piece \"%s\"", p.piece);
             return TRANSCRIBE_ERR_GGUF;
         }
         *p.slot = id;
     }
     // Optional: present in the -plus vocab, absent in 1b/2b. We resolve
     // anyway so the plus prompt builder can use them without re-looking.
-    out.start_of_role = tok.find("<|start_of_role|>");   // may be -1
-    out.end_of_role   = tok.find("<|end_of_role|>");     // may be -1
+    out.start_of_role = tok.find("<|start_of_role|>");  // may be -1
+    out.end_of_role   = tok.find("<|end_of_role|>");    // may be -1
     return TRANSCRIBE_OK;
 }
 
-transcribe_status load(
-    Loader &                         loader,
-    const transcribe_model_load_params *  params,
-    transcribe_model **              out_model)
-{
+transcribe_status load(Loader & loader, const transcribe_model_load_params * params, transcribe_model ** out_model) {
     const int64_t t_load_start = ggml_time_us();
 
-    auto m = std::make_unique<GraniteModel>();
+    auto m       = std::make_unique<GraniteModel>();
     m->arch      = &arch;
     m->t_load_us = 0;
     m->variant   = loader.variant().empty() ? k_default_variant : loader.variant();
@@ -255,29 +240,32 @@ transcribe_status load(
     m->caps.n_languages = 0;
     m->caps.languages   = nullptr;
 
-    if (const transcribe_status st = read_capability_kv(loader.gguf(), m->caps);
-        st != TRANSCRIBE_OK) return st;
-    if (const transcribe_status st = read_languages_kv(loader.gguf(), *m);
-        st != TRANSCRIBE_OK) return st;
+    if (const transcribe_status st = read_capability_kv(loader.gguf(), m->caps); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (const transcribe_status st = read_languages_kv(loader.gguf(), *m); st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Tokenizer (byte-level BPE; loader handles the "gpt2" model tag).
-    if (const transcribe_status st = m->tok.load(loader.gguf());
-        st != TRANSCRIBE_OK) return st;
+    if (const transcribe_status st = m->tok.load(loader.gguf()); st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Chat template (required at run time but the runtime accepts an
     // empty string today and the prompt builder reports a clear error
     // later). We read it eagerly so a converter regression that drops
     // the template surfaces at load.
-    (void)read_optional_string_kv(
-        loader.gguf(), "tokenizer.chat_template", "granite",
-        "", m->chat_template);
+    (void) read_optional_string_kv(loader.gguf(), "tokenizer.chat_template", "granite", "", m->chat_template);
 
-    if (const transcribe_status st = resolve_chat_tokens(m->tok, m->chat_tokens);
-        st != TRANSCRIBE_OK) return st;
+    if (const transcribe_status st = resolve_chat_tokens(m->tok, m->chat_tokens); st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Hparams.
-    if (const transcribe_status st = read_granite_hparams(loader.gguf(), m->hparams);
-        st != TRANSCRIBE_OK) return st;
+    if (const transcribe_status st = read_granite_hparams(loader.gguf(), m->hparams); st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Publish the input-length ceiling now that the decoder context window
     // and frontend rate are known (apply_family_invariants ran before the
@@ -291,23 +279,20 @@ transcribe_status load(
     // basis unset (zero model_max_ctx => the query reports "unbounded").
     {
         const int num_queries = granite_num_queries(m->hparams);
-        if (num_queries > 0 && m->hparams.window_size > 0 &&
-            m->hparams.fe_hop_length > 0 && m->hparams.fe_sample_rate > 0 &&
-            m->hparams.dec_max_position_embeddings > 0) {
-            m->limits.has_context_cap = true;
-            m->limits.model_max_ctx   = m->hparams.dec_max_position_embeddings;
-            m->limits.prompt_overhead = 64;  // match granite_max_audio_ms's k_prompt_overhead
-            m->limits.gen_reserve     = k_gen_budget;
+        if (num_queries > 0 && m->hparams.window_size > 0 && m->hparams.fe_hop_length > 0 &&
+            m->hparams.fe_sample_rate > 0 && m->hparams.dec_max_position_embeddings > 0) {
+            m->limits.has_context_cap    = true;
+            m->limits.model_max_ctx      = m->hparams.dec_max_position_embeddings;
+            m->limits.prompt_overhead    = 64;  // match granite_max_audio_ms's k_prompt_overhead
+            m->limits.gen_reserve        = k_gen_budget;
             // ms per audio token: granite emits num_queries tokens per
             // window_size encoder frames; t_enc = mel_frames/2;
             // mel_frames = ms*sr/(hop*1000). Inverting granite_max_audio_ms's
             // forward rate gives ms-per-audio-token below.
-            m->limits.ms_per_audio_token =
-                (static_cast<double>(m->hparams.window_size) / num_queries) *
-                2.0 * m->hparams.fe_hop_length * 1000.0 / m->hparams.fe_sample_rate;
+            m->limits.ms_per_audio_token = (static_cast<double>(m->hparams.window_size) / num_queries) * 2.0 *
+                                           m->hparams.fe_hop_length * 1000.0 / m->hparams.fe_sample_rate;
             m->limits.kv_elems_per_ctx_token =
-                (int64_t) m->hparams.dec_n_kv_heads *
-                m->hparams.dec_head_dim * m->hparams.dec_n_layers * 2;
+                (int64_t) m->hparams.dec_n_kv_heads * m->hparams.dec_head_dim * m->hparams.dec_n_layers * 2;
         }
     }
 
@@ -319,9 +304,8 @@ transcribe_status load(
     m->hparams.pad_token_id = m->chat_tokens.pad;
 
     if (m->hparams.vocab_size != m->hparams.dec_vocab_size) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "granite: tokenizer vocab (%d) != decoder vocab_size (%d)",
-                     m->hparams.vocab_size, m->hparams.dec_vocab_size);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "granite: tokenizer vocab (%d) != decoder vocab_size (%d)",
+                m->hparams.vocab_size, m->hparams.dec_vocab_size);
         return TRANSCRIBE_ERR_GGUF;
     }
     if (m->hparams.eos_token_id < 0) {
@@ -331,7 +315,7 @@ transcribe_status load(
 
     // Mel frontend: configured from the granite KV.
     {
-        transcribe::MelConfig cfg {};
+        transcribe::MelConfig cfg{};
         cfg.sample_rate  = m->hparams.fe_sample_rate;
         cfg.num_mels     = m->hparams.fe_num_mels;
         cfg.n_fft        = m->hparams.fe_n_fft;
@@ -348,22 +332,16 @@ transcribe_status load(
         // filterbank + periodic Hann window. We pick them up here so
         // the frontend uses bit-identical values.
         {
-            using R = transcribe::load_common::ReadF32Result;
-            const size_t fb_elems =
-                static_cast<size_t>(cfg.num_mels) *
-                static_cast<size_t>(cfg.n_fft / 2 + 1);
-            const auto fb_rc = transcribe::load_common::read_f32_tensor_checked(
-                loader.gguf(), loader.path(),
-                "frontend.mel_filterbank", fb_elems,
-                "granite", cfg.filterbank);
+            using R               = transcribe::load_common::ReadF32Result;
+            const size_t fb_elems = static_cast<size_t>(cfg.num_mels) * static_cast<size_t>(cfg.n_fft / 2 + 1);
+            const auto   fb_rc    = transcribe::load_common::read_f32_tensor_checked(
+                loader.gguf(), loader.path(), "frontend.mel_filterbank", fb_elems, "granite", cfg.filterbank);
             if (fb_rc != R::Ok && fb_rc != R::Absent) {
                 return TRANSCRIBE_ERR_GGUF;
             }
             const size_t win_elems = static_cast<size_t>(cfg.win_length);
-            const auto win_rc = transcribe::load_common::read_f32_tensor_checked(
-                loader.gguf(), loader.path(),
-                "frontend.window", win_elems,
-                "granite", cfg.window);
+            const auto   win_rc    = transcribe::load_common::read_f32_tensor_checked(
+                loader.gguf(), loader.path(), "frontend.window", win_elems, "granite", cfg.window);
             if (win_rc != R::Ok && win_rc != R::Absent) {
                 return TRANSCRIBE_ERR_GGUF;
             }
@@ -373,53 +351,43 @@ transcribe_status load(
     }
 
     // Reopen with no_alloc to build the tensor catalog.
-    gguf_init_params init_params {};
+    gguf_init_params init_params{};
     init_params.no_alloc = true;
     init_params.ctx      = &m->ctx_meta;
 
-    gguf_context * gguf_data = gguf_init_from_file(loader.path().c_str(),
-                                                   init_params);
+    gguf_context * gguf_data = gguf_init_from_file(loader.path().c_str(), init_params);
     if (gguf_data == nullptr) {
         return TRANSCRIBE_ERR_GGUF;
     }
 
-    if (const transcribe_status st = build_granite_weights(
-            m->ctx_meta, m->hparams, m->weights);
-        st != TRANSCRIBE_OK)
-    {
+    if (const transcribe_status st = build_granite_weights(m->ctx_meta, m->hparams, m->weights); st != TRANSCRIBE_OK) {
         gguf_free(gguf_data);
         return st;
     }
 
     // Backend plan.
-    const transcribe_backend_request backend_req =
-        (params != nullptr) ? params->backend : TRANSCRIBE_BACKEND_AUTO;
+    const transcribe_backend_request backend_req = (params != nullptr) ? params->backend : TRANSCRIBE_BACKEND_AUTO;
     if (const transcribe_status st = transcribe::load_common::init_backends(
             backend_req, (params != nullptr) ? params->gpu_device : 0, "granite", m->plan);
-        st != TRANSCRIBE_OK)
-    {
+        st != TRANSCRIBE_OK) {
         gguf_free(gguf_data);
         return st;
     }
-    m->backend = ggml_backend_name(m->plan.primary);
+    m->backend         = ggml_backend_name(m->plan.primary);
     m->primary_backend = m->plan.primary;
 
-    ggml_backend_buffer_t weights_buffer =
-        ggml_backend_alloc_ctx_tensors(m->ctx_meta, m->plan.primary);
+    ggml_backend_buffer_t weights_buffer = ggml_backend_alloc_ctx_tensors(m->ctx_meta, m->plan.primary);
     if (weights_buffer == nullptr) {
         gguf_free(gguf_data);
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "granite: ggml_backend_alloc_ctx_tensors failed");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "granite: ggml_backend_alloc_ctx_tensors failed");
         return TRANSCRIBE_ERR_GGUF;
     }
     m->backend_buffer = weights_buffer;
-    ggml_backend_buffer_set_usage(weights_buffer,
-                                  GGML_BACKEND_BUFFER_USAGE_WEIGHTS);
+    ggml_backend_buffer_set_usage(weights_buffer, GGML_BACKEND_BUFFER_USAGE_WEIGHTS);
 
-    if (const transcribe_status st = transcribe::load_common::stream_tensor_data(
-            loader.path(), gguf_data, m->ctx_meta, "granite");
-        st != TRANSCRIBE_OK)
-    {
+    if (const transcribe_status st =
+            transcribe::load_common::stream_tensor_data(loader.path(), gguf_data, m->ctx_meta, "granite");
+        st != TRANSCRIBE_OK) {
         gguf_free(gguf_data);
         return st;
     }
@@ -439,36 +407,28 @@ transcribe_status load(
         std::vector<transcribe::causal_lm::GateUpEntry> entries;
         entries.reserve(m->weights.dec_blocks.size());
         for (auto & b : m->weights.dec_blocks) {
-            entries.push_back({b.ffn_gate_w, b.ffn_up_w, &b.ffn_gate_up_w});
+            entries.push_back({ b.ffn_gate_w, b.ffn_up_w, &b.ffn_gate_up_w });
         }
-        if (!transcribe::causal_lm::pack_gate_up(
-                m->plan.primary,
-                m->hparams.dec_hidden,
-                m->hparams.dec_intermediate,
-                entries,
-                m->packed_gate_up,
-                "granite"))
-        {
+        if (!transcribe::causal_lm::pack_gate_up(m->plan.primary, m->hparams.dec_hidden, m->hparams.dec_intermediate,
+                                                 entries, m->packed_gate_up, "granite")) {
             m->packed_gate_up.free();
             return TRANSCRIBE_ERR_GGUF;
         }
     }
 
     m->t_load_us = ggml_time_us() - t_load_start;
-    *out_model = m.release();
+    *out_model   = m.release();
     return TRANSCRIBE_OK;
 }
 
-transcribe_status init_context(
-    transcribe_model *                model,
-    const transcribe_session_params * params,
-    transcribe_session **             out_ctx)
-{
+transcribe_status init_context(transcribe_model *                model,
+                               const transcribe_session_params * params,
+                               transcribe_session **             out_ctx) {
     if (model->arch != &arch) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
 
-    auto cc = std::make_unique<GraniteSession>();
+    auto cc       = std::make_unique<GraniteSession>();
     cc->model     = model;
     cc->n_threads = params->n_threads;
     cc->kv_type   = params->kv_type;
@@ -479,8 +439,7 @@ transcribe_status init_context(
     // flash_attn_ext doesn't broadcast cleanly yet.
     cc->encoder_use_flash = false;
     cc->decoder_use_flash = true;
-    transcribe::flash::apply_env_overrides(cc->encoder_use_flash,
-                                           cc->decoder_use_flash);
+    transcribe::flash::apply_env_overrides(cc->encoder_use_flash, cc->decoder_use_flash);
 
     *out_ctx = cc.release();
     return TRANSCRIBE_OK;
@@ -491,30 +450,47 @@ transcribe_status init_context(
 // granite-speech base AR variants advertise fr/de/es/pt/ja plus translate-only
 // targets it/zh; -plus is ASR-only, so this helper is not used for it.
 static const char * granite_target_language_name(const char * code_or_name) {
-    if (code_or_name == nullptr || *code_or_name == '\0') return nullptr;
+    if (code_or_name == nullptr || *code_or_name == '\0') {
+        return nullptr;
+    }
     std::string s = code_or_name;
-    for (auto & c : s) c = static_cast<char>(std::tolower(c));
-    if (s == "de" || s == "ger" || s == "deu" || s == "german")     return "German";
-    if (s == "fr" || s == "fra" || s == "fre" || s == "french")     return "French";
-    if (s == "es" || s == "spa" || s == "spanish")                   return "Spanish";
-    if (s == "pt" || s == "por" || s == "portuguese")                return "Portuguese";
-    if (s == "ja" || s == "jpn" || s == "japanese")                  return "Japanese";
-    if (s == "it" || s == "ita" || s == "italian")                   return "Italian";
-    if (s == "zh" || s == "zh-cn" || s == "cmn" ||
-        s == "mandarin" || s == "chinese")                           return "Mandarin";
-    if (s == "en" || s == "eng" || s == "english")                   return "English";
+    for (auto & c : s) {
+        c = static_cast<char>(std::tolower(c));
+    }
+    if (s == "de" || s == "ger" || s == "deu" || s == "german") {
+        return "German";
+    }
+    if (s == "fr" || s == "fra" || s == "fre" || s == "french") {
+        return "French";
+    }
+    if (s == "es" || s == "spa" || s == "spanish") {
+        return "Spanish";
+    }
+    if (s == "pt" || s == "por" || s == "portuguese") {
+        return "Portuguese";
+    }
+    if (s == "ja" || s == "jpn" || s == "japanese") {
+        return "Japanese";
+    }
+    if (s == "it" || s == "ita" || s == "italian") {
+        return "Italian";
+    }
+    if (s == "zh" || s == "zh-cn" || s == "cmn" || s == "mandarin" || s == "chinese") {
+        return "Mandarin";
+    }
+    if (s == "en" || s == "eng" || s == "english") {
+        return "English";
+    }
     return nullptr;
 }
 
 // Build the prompt prefix/suffix token-id lists from the shared run params and
 // model variant (the audio tokens splice in between). Single source of truth
 // for run() and run_batch().
-static transcribe_status build_granite_affixes(
-    GraniteModel *                cm,
-    const transcribe_run_params * params,
-    std::vector<int32_t> &        prefix_ids,
-    std::vector<int32_t> &        suffix_ids)
-{
+static transcribe_status build_granite_affixes(GraniteModel *                cm,
+                                               const transcribe_run_params * params,
+                                               std::vector<int32_t> &        prefix_ids,
+                                               std::vector<int32_t> &        suffix_ids) {
     std::string instruction;
     if (cm->hparams.variant == "granite-speech-4.1-2b") {
         instruction = "transcribe the speech with proper punctuation and capitalization.";
@@ -525,45 +501,39 @@ static transcribe_status build_granite_affixes(
     }
     if (params != nullptr) {
         if (params->task == TRANSCRIBE_TASK_TRANSLATE) {
-            if (params->target_language == nullptr ||
-                params->target_language[0] == '\0') {
-                log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                             "granite: translate task requires --target-language");
+            if (params->target_language == nullptr || params->target_language[0] == '\0') {
+                log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "granite: translate task requires --target-language");
                 return TRANSCRIBE_ERR_INVALID_ARG;
             }
-            const char * lang_name =
-                granite_target_language_name(params->target_language);
+            const char * lang_name = granite_target_language_name(params->target_language);
             if (lang_name == nullptr) {
-                log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                             "granite: target_language '%s' is not advertised",
-                             params->target_language);
+                log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "granite: target_language '%s' is not advertised",
+                        params->target_language);
                 return TRANSCRIBE_ERR_INVALID_ARG;
             }
-            instruction = std::string("can you translate the speech into ")
-                        + lang_name + "?";
+            instruction = std::string("can you translate the speech into ") + lang_name + "?";
         } else if (params->timestamps == TRANSCRIBE_TIMESTAMPS_WORD ||
                    params->timestamps == TRANSCRIBE_TIMESTAMPS_AUTO) {
             instruction = "transcribe the speech with timestamps in [SS:MS] format";
         }
     }
 
-    const bool use_granite4_chat =
-        cm->chat_template.find("<|start_of_role|>") != std::string::npos
-        && cm->chat_tokens.start_of_role >= 0
-        && cm->chat_tokens.end_of_role >= 0;
+    const bool use_granite4_chat = cm->chat_template.find("<|start_of_role|>") != std::string::npos &&
+                                   cm->chat_tokens.start_of_role >= 0 && cm->chat_tokens.end_of_role >= 0;
     if (use_granite4_chat) {
-        const char * system_content =
-            (cm->hparams.variant == "granite-speech-4.1-2b-plus")
-                ? "Knowledge Cutoff Date: April 2024.\n"
-                  "Today's Date: December 19, 2024.\n"
-                  "You are Granite, developed by IBM. You are a helpful AI assistant"
-                : "You are a helpful assistant. Please ensure responses "
-                  "are professional, accurate, and safe.";
+        const char *         system_content = (cm->hparams.variant == "granite-speech-4.1-2b-plus") ?
+                                                  "Knowledge Cutoff Date: April 2024.\n"
+                                                  "Today's Date: December 19, 2024.\n"
+                                                  "You are Granite, developed by IBM. You are a helpful AI assistant" :
+                                                  "You are a helpful assistant. Please ensure responses "
+                                                  "are professional, accurate, and safe.";
         std::vector<int32_t> text_a, text_b;
-        if (const transcribe_status st = cm->tok.encode("system", text_a);
-            st != TRANSCRIBE_OK) return st;
-        if (const transcribe_status st = cm->tok.encode(system_content, text_b);
-            st != TRANSCRIBE_OK) return st;
+        if (const transcribe_status st = cm->tok.encode("system", text_a); st != TRANSCRIBE_OK) {
+            return st;
+        }
+        if (const transcribe_status st = cm->tok.encode(system_content, text_b); st != TRANSCRIBE_OK) {
+            return st;
+        }
         prefix_ids.push_back(cm->chat_tokens.start_of_role);
         prefix_ids.insert(prefix_ids.end(), text_a.begin(), text_a.end());
         prefix_ids.push_back(cm->chat_tokens.end_of_role);
@@ -571,38 +541,41 @@ static transcribe_status build_granite_affixes(
         prefix_ids.push_back(cm->chat_tokens.end_of_text);
 
         std::vector<int32_t> nl_ids, user_ids;
-        if (const transcribe_status st = cm->tok.encode("\n", nl_ids);
-            st != TRANSCRIBE_OK) return st;
-        if (const transcribe_status st = cm->tok.encode("user", user_ids);
-            st != TRANSCRIBE_OK) return st;
+        if (const transcribe_status st = cm->tok.encode("\n", nl_ids); st != TRANSCRIBE_OK) {
+            return st;
+        }
+        if (const transcribe_status st = cm->tok.encode("user", user_ids); st != TRANSCRIBE_OK) {
+            return st;
+        }
         prefix_ids.insert(prefix_ids.end(), nl_ids.begin(), nl_ids.end());
         prefix_ids.push_back(cm->chat_tokens.start_of_role);
         prefix_ids.insert(prefix_ids.end(), user_ids.begin(), user_ids.end());
         prefix_ids.push_back(cm->chat_tokens.end_of_role);
 
-        if (const transcribe_status st = cm->tok.encode(instruction, suffix_ids);
-            st != TRANSCRIBE_OK) return st;
+        if (const transcribe_status st = cm->tok.encode(instruction, suffix_ids); st != TRANSCRIBE_OK) {
+            return st;
+        }
         suffix_ids.push_back(cm->chat_tokens.end_of_text);
         std::vector<int32_t> nl_ids2;
-        if (const transcribe_status st = cm->tok.encode("\n", nl_ids2);
-            st != TRANSCRIBE_OK) return st;
+        if (const transcribe_status st = cm->tok.encode("\n", nl_ids2); st != TRANSCRIBE_OK) {
+            return st;
+        }
         suffix_ids.insert(suffix_ids.end(), nl_ids2.begin(), nl_ids2.end());
         suffix_ids.push_back(cm->chat_tokens.start_of_role);
         std::vector<int32_t> asst_ids;
-        if (const transcribe_status st = cm->tok.encode("assistant", asst_ids);
-            st != TRANSCRIBE_OK) return st;
+        if (const transcribe_status st = cm->tok.encode("assistant", asst_ids); st != TRANSCRIBE_OK) {
+            return st;
+        }
         suffix_ids.insert(suffix_ids.end(), asst_ids.begin(), asst_ids.end());
         suffix_ids.push_back(cm->chat_tokens.end_of_role);
     } else {
         const std::string prefix_text = "USER: ";
         const std::string suffix_text = instruction + "\n ASSISTANT:";
-        if (const transcribe_status st = cm->tok.encode(prefix_text, prefix_ids);
-            st != TRANSCRIBE_OK) {
+        if (const transcribe_status st = cm->tok.encode(prefix_text, prefix_ids); st != TRANSCRIBE_OK) {
             log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "granite: tokenize(prefix) failed");
             return st;
         }
-        if (const transcribe_status st = cm->tok.encode(suffix_text, suffix_ids);
-            st != TRANSCRIBE_OK) {
+        if (const transcribe_status st = cm->tok.encode(suffix_text, suffix_ids); st != TRANSCRIBE_OK) {
             log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "granite: tokenize(suffix) failed");
             return st;
         }
@@ -610,12 +583,10 @@ static transcribe_status build_granite_affixes(
     return TRANSCRIBE_OK;
 }
 
-transcribe_status run(
-    transcribe_session *      ctx_base,
-    const float *             pcm,
-    int                       n_samples,
-    const transcribe_run_params * params)
-{
+transcribe_status run(transcribe_session *          ctx_base,
+                      const float *                 pcm,
+                      int                           n_samples,
+                      const transcribe_run_params * params) {
     if (ctx_base == nullptr || pcm == nullptr || n_samples <= 0) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
@@ -631,14 +602,11 @@ transcribe_status run(
 
     // Mel + 2-frame stack (host side).
     const int64_t t_mel_start = ggml_time_us();
-    int t_enc = 0;
-    if (const transcribe_status mst = compute_mel_encoder_input(
-            *cm->mel, pcm, n_samples, cc->n_threads, cc->mel_buf, t_enc);
-        mst != TRANSCRIBE_OK)
-    {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "granite run: mel/stack failed (%s)",
-                     transcribe_status_string(mst));
+    int           t_enc       = 0;
+    if (const transcribe_status mst =
+            compute_mel_encoder_input(*cm->mel, pcm, n_samples, cc->n_threads, cc->mel_buf, t_enc);
+        mst != TRANSCRIBE_OK) {
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "granite run: mel/stack failed (%s)", transcribe_status_string(mst));
         return mst;
     }
     cc->t_mel_us = ggml_time_us() - t_mel_start;
@@ -648,10 +616,8 @@ transcribe_status run(
     // comparison point on the host.
     if (transcribe::debug::enabled()) {
         const long long shape[2] = { t_enc, cm->hparams.enc_input_dim };
-        transcribe::debug::dump_host_f32(
-            "enc.mel.in", cc->mel_buf.data(),
-            static_cast<long long>(cc->mel_buf.size()),
-            shape, 2, "encoder");
+        transcribe::debug::dump_host_f32("enc.mel.in", cc->mel_buf.data(), static_cast<long long>(cc->mel_buf.size()),
+                                         shape, 2, "encoder");
     }
 
     // Reset compute state.
@@ -660,24 +626,22 @@ transcribe_status run(
         cc->compute_ctx = nullptr;
     }
     {
-        ggml_init_params ip {};
+        ggml_init_params ip{};
         // 16 conformer blocks * many ops. 32 MB is generous headroom.
-        ip.mem_size   = 32 * 1024 * 1024;
-        ip.mem_buffer = nullptr;
-        ip.no_alloc   = true;
+        ip.mem_size     = 32 * 1024 * 1024;
+        ip.mem_buffer   = nullptr;
+        ip.no_alloc     = true;
         cc->compute_ctx = ggml_init(ip);
         if (cc->compute_ctx == nullptr) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "granite run: compute context allocation failed — "
-                "out of memory.");
+                                "granite run: compute context allocation failed — "
+                                "out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
     }
 
     // Build encoder graph.
-    EncoderBuild eb = build_encoder_graph(cc->compute_ctx, cm->weights,
-                                          cm->hparams, t_enc,
-                                          cc->encoder_use_flash);
+    EncoderBuild eb = build_encoder_graph(cc->compute_ctx, cm->weights, cm->hparams, t_enc, cc->encoder_use_flash);
     if (eb.graph == nullptr || eb.out == nullptr) {
         return TRANSCRIBE_ERR_GGUF;
     }
@@ -688,61 +652,51 @@ transcribe_status run(
 
     // Scheduler.
     if (cc->sched == nullptr) {
-        cc->sched = ggml_backend_sched_new(
-            cm->plan.scheduler_list.data(), nullptr,
-            static_cast<int>(cm->plan.scheduler_list.size()),
-            32768, false, true);
+        cc->sched = ggml_backend_sched_new(cm->plan.scheduler_list.data(), nullptr,
+                                           static_cast<int>(cm->plan.scheduler_list.size()), 32768, false, true);
         if (cc->sched == nullptr) {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "granite run: ggml_backend_sched_new failed");
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "granite run: ggml_backend_sched_new failed");
             return TRANSCRIBE_ERR_GGUF;
         }
     }
     ggml_backend_sched_reset(cc->sched);
     if (!ggml_backend_sched_alloc_graph(cc->sched, eb.graph)) {
         transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "granite run: encoder graph allocation failed — out of memory.");
+                            "granite run: encoder graph allocation failed — out of memory.");
         return TRANSCRIBE_ERR_OOM;
     }
 
     // Upload inputs.
     // mel_in: contiguous [T_enc, input_dim] row-major matches ggml ne
     // [input_dim, T_enc] (ne[0]=input_dim is innermost).
-    ggml_backend_tensor_set(eb.mel_in, cc->mel_buf.data(), 0,
-                            cc->mel_buf.size() * sizeof(float));
+    ggml_backend_tensor_set(eb.mel_in, cc->mel_buf.data(), 0, cc->mel_buf.size() * sizeof(float));
 
     // Shaw attention_dists. Row-major over (c, r) with int32 indices.
-    std::vector<int32_t> dists = precompute_attention_dists(
-        cm->hparams.enc_context_size, cm->hparams.enc_max_pos_emb);
-    ggml_backend_tensor_set(eb.attention_dists, dists.data(), 0,
-                            dists.size() * sizeof(int32_t));
+    std::vector<int32_t> dists = precompute_attention_dists(cm->hparams.enc_context_size, cm->hparams.enc_max_pos_emb);
+    ggml_backend_tensor_set(eb.attention_dists, dists.data(), 0, dists.size() * sizeof(int32_t));
 
     // last_block_mask: [context_size, context_size, n_blocks_local].
     // All zeros except the last slice when t_enc is not a multiple of
     // context_size.
     {
-        const int ctx_size = cm->hparams.enc_context_size;
-        const size_t plane = static_cast<size_t>(ctx_size) * ctx_size;
+        const int          ctx_size = cm->hparams.enc_context_size;
+        const size_t       plane    = static_cast<size_t>(ctx_size) * ctx_size;
         std::vector<float> mask(plane * eb.n_blocks_local, 0.0f);
-        const int rem = eb.last_block_rem;
+        const int          rem = eb.last_block_rem;
         if (rem > 0 && rem < ctx_size) {
             std::vector<float> last = precompute_last_block_mask(ctx_size, rem);
             // Last slice index = n_blocks_local - 1. ne[2] is the slice
             // axis (row-major plane order). Offset = (n_blocks_local-1)*plane.
-            std::memcpy(mask.data() + plane * (eb.n_blocks_local - 1),
-                        last.data(), plane * sizeof(float));
+            std::memcpy(mask.data() + plane * (eb.n_blocks_local - 1), last.data(), plane * sizeof(float));
         }
-        ggml_backend_tensor_set(eb.last_block_mask, mask.data(), 0,
-                                mask.size() * sizeof(float));
+        ggml_backend_tensor_set(eb.last_block_mask, mask.data(), 0, mask.size() * sizeof(float));
     }
 
     // zero_pad: only present when t_enc is not aligned to context_size.
     if (eb.zero_pad != nullptr) {
-        const size_t n_elems = static_cast<size_t>(eb.zero_pad->ne[0]) *
-                               eb.zero_pad->ne[1];
+        const size_t       n_elems = static_cast<size_t>(eb.zero_pad->ne[0]) * eb.zero_pad->ne[1];
         std::vector<float> zeros(n_elems, 0.0f);
-        ggml_backend_tensor_set(eb.zero_pad, zeros.data(), 0,
-                                zeros.size() * sizeof(float));
+        ggml_backend_tensor_set(eb.zero_pad, zeros.data(), 0, zeros.size() * sizeof(float));
     }
 
     // Thread count.
@@ -750,33 +704,29 @@ transcribe_status run(
 
     // Compute.
     const int64_t t_enc_start = ggml_time_us();
-    if (const ggml_status gs =
-            ggml_backend_sched_graph_compute(cc->sched, eb.graph);
-        gs != GGML_STATUS_SUCCESS)
-    {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "granite run: encoder graph compute failed (%d)",
-                     static_cast<int>(gs));
+    if (const ggml_status gs = ggml_backend_sched_graph_compute(cc->sched, eb.graph); gs != GGML_STATUS_SUCCESS) {
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "granite run: encoder graph compute failed (%d)", static_cast<int>(gs));
         return TRANSCRIBE_ERR_GGUF;
     }
     cc->t_encode_us = ggml_time_us() - t_enc_start;
 
     // Dump intermediates.
     auto try_dump = [](const char * name, ggml_tensor * t, const char * stage) {
-        if (t != nullptr) transcribe::debug::dump_tensor(name, t, stage);
+        if (t != nullptr) {
+            transcribe::debug::dump_tensor(name, t, stage);
+        }
     };
     try_dump("enc.input_linear.out", eb.dumps.input_linear_out, "encoder");
-    try_dump("enc.block.0.out",      eb.dumps.block_0_out,      "encoder");
+    try_dump("enc.block.0.out", eb.dumps.block_0_out, "encoder");
     {
         const int mid_idx = cm->hparams.enc_n_layers / 2;
-        char bname[64];
+        char      bname[64];
         std::snprintf(bname, sizeof(bname), "enc.block.%d.out", mid_idx);
         try_dump(bname, eb.dumps.block_mid_out, "encoder");
     }
     {
         char bname[64];
-        std::snprintf(bname, sizeof(bname), "enc.block.%d.out",
-                      cm->hparams.enc_n_layers - 1);
+        std::snprintf(bname, sizeof(bname), "enc.block.%d.out", cm->hparams.enc_n_layers - 1);
         try_dump(bname, eb.dumps.block_last_out, "encoder");
     }
     try_dump("enc.out", eb.dumps.out_named, "encoder");
@@ -784,12 +734,10 @@ transcribe_status run(
     // Read encoder output to host for the projector pass. The projector
     // uses a separate compute graph so its dumps compare without encoder
     // graph state lingering.
-    const int64_t enc_hidden_runtime = eb.out->ne[0];
-    const int64_t enc_T_runtime      = eb.out->ne[1];
-    std::vector<float> enc_host(static_cast<size_t>(enc_hidden_runtime) *
-                                 enc_T_runtime);
-    ggml_backend_tensor_get(eb.out, enc_host.data(), 0,
-                            enc_host.size() * sizeof(float));
+    const int64_t      enc_hidden_runtime = eb.out->ne[0];
+    const int64_t      enc_T_runtime      = eb.out->ne[1];
+    std::vector<float> enc_host(static_cast<size_t>(enc_hidden_runtime) * enc_T_runtime);
+    ggml_backend_tensor_get(eb.out, enc_host.data(), 0, enc_host.size() * sizeof(float));
 
     // Cat-hidden-layers handling (-plus variant): the -plus checkpoint sets
     // enc.cat_hidden_layers = [3]; the encoder graph channel-concatenates
@@ -799,21 +747,19 @@ transcribe_status run(
     // Projector graph.
     ggml_context * proj_ctx = nullptr;
     {
-        ggml_init_params ip {};
+        ggml_init_params ip{};
         ip.mem_size   = 16 * 1024 * 1024;  // 2 Q-Former layers — small graph
         ip.mem_buffer = nullptr;
         ip.no_alloc   = true;
-        proj_ctx = ggml_init(ip);
+        proj_ctx      = ggml_init(ip);
         if (proj_ctx == nullptr) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "granite run: projector compute context allocation failed — "
-                "out of memory.");
+                                "granite run: projector compute context allocation failed — "
+                                "out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
     }
-    ProjectorBuild pb = build_projector_graph(proj_ctx, cm->weights,
-                                              cm->hparams,
-                                              static_cast<int>(enc_T_runtime));
+    ProjectorBuild pb = build_projector_graph(proj_ctx, cm->weights, cm->hparams, static_cast<int>(enc_T_runtime));
     if (pb.graph == nullptr || pb.out == nullptr) {
         ggml_free(proj_ctx);
         return TRANSCRIBE_ERR_GGUF;
@@ -822,42 +768,32 @@ transcribe_status run(
     ggml_backend_sched_reset(cc->sched);
     if (!ggml_backend_sched_alloc_graph(cc->sched, pb.graph)) {
         transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "granite run: projector graph allocation failed — out of memory.");
+                            "granite run: projector graph allocation failed — out of memory.");
         ggml_free(proj_ctx);
         return TRANSCRIBE_ERR_OOM;
     }
 
     // Upload encoder output to the projector's enc_in input.
-    ggml_backend_tensor_set(pb.enc_in, enc_host.data(), 0,
-                            enc_host.size() * sizeof(float));
+    ggml_backend_tensor_set(pb.enc_in, enc_host.data(), 0, enc_host.size() * sizeof(float));
     if (pb.enc_pad != nullptr) {
-        const size_t pad_bytes =
-            static_cast<size_t>(pb.enc_pad->ne[0]) * pb.enc_pad->ne[1] *
-            sizeof(float);
+        const size_t       pad_bytes = static_cast<size_t>(pb.enc_pad->ne[0]) * pb.enc_pad->ne[1] * sizeof(float);
         std::vector<float> pad(pad_bytes / sizeof(float), 0.0f);
         ggml_backend_tensor_set(pb.enc_pad, pad.data(), 0, pad_bytes);
     }
 
-    if (const ggml_status gs =
-            ggml_backend_sched_graph_compute(cc->sched, pb.graph);
-        gs != GGML_STATUS_SUCCESS)
-    {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "granite run: projector graph compute failed (%d)",
-                     static_cast<int>(gs));
+    if (const ggml_status gs = ggml_backend_sched_graph_compute(cc->sched, pb.graph); gs != GGML_STATUS_SUCCESS) {
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "granite run: projector graph compute failed (%d)", static_cast<int>(gs));
         ggml_free(proj_ctx);
         return TRANSCRIBE_ERR_GGUF;
     }
 
     try_dump("proj.qformer.out", pb.dumps.qformer_out, "projector");
-    try_dump("proj.out",         pb.dumps.proj_out,    "projector");
+    try_dump("proj.out", pb.dumps.proj_out, "projector");
 
     // Read projector output (the audio tokens in LM hidden space).
     cc->n_audio_tokens = pb.n_audio_tokens;
-    cc->audio_tokens_host.resize(
-        static_cast<size_t>(pb.out->ne[0]) * pb.out->ne[1]);
-    ggml_backend_tensor_get(pb.out, cc->audio_tokens_host.data(), 0,
-                            cc->audio_tokens_host.size() * sizeof(float));
+    cc->audio_tokens_host.resize(static_cast<size_t>(pb.out->ne[0]) * pb.out->ne[1]);
+    ggml_backend_tensor_get(pb.out, cc->audio_tokens_host.data(), 0, cc->audio_tokens_host.size() * sizeof(float));
 
     ggml_free(proj_ctx);
 
@@ -890,9 +826,7 @@ transcribe_status run(
     //   translate task                   : "can you translate the speech into <Language>?"
     std::vector<int32_t> prefix_ids;
     std::vector<int32_t> suffix_ids;
-    if (const transcribe_status st =
-            build_granite_affixes(cm, params, prefix_ids, suffix_ids);
-        st != TRANSCRIBE_OK) {
+    if (const transcribe_status st = build_granite_affixes(cm, params, prefix_ids, suffix_ids); st != TRANSCRIBE_OK) {
         return st;
     }
 
@@ -922,14 +856,12 @@ transcribe_status run(
     // budget means an accepted clip always has room for a real transcript.
     const int ceiling = granite_context_ceiling(cc->n_ctx, cm->hparams);
     if (T_prompt + k_gen_budget > ceiling) {
-        transcribe::log_msg(
-            TRANSCRIBE_LOG_LEVEL_ERROR,
-            "granite run: input too long — %d audio + %d prompt tokens leave "
-            "no room for output within the %d-token context (need %d). "
-            "Shorten the audio (see transcribe_capabilities.max_audio_ms) or "
-            "split it into segments.",
-            n_audio_tokens, prefix_len + suffix_len, ceiling,
-            T_prompt + k_gen_budget);
+        transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
+                            "granite run: input too long — %d audio + %d prompt tokens leave "
+                            "no room for output within the %d-token context (need %d). "
+                            "Shorten the audio (see transcribe_capabilities.max_audio_ms) or "
+                            "split it into segments.",
+                            n_audio_tokens, prefix_len + suffix_len, ceiling, T_prompt + k_gen_budget);
         return TRANSCRIBE_ERR_INPUT_TOO_LONG;
     }
 
@@ -940,59 +872,54 @@ transcribe_status run(
     // for this prompt, free and re-allocate. Round up to a 256-row bucket
     // so back-to-back runs of similar audio lengths don't keep
     // re-allocating.
-    constexpr int kKvBucket   = 256;
-    const int needed_raw = std::min(T_prompt + k_gen_budget, ceiling);
-    const int needed_n_ctx =
-        ((needed_raw + kKvBucket - 1) / kKvBucket) * kKvBucket;
+    constexpr int kKvBucket    = 256;
+    const int     needed_raw   = std::min(T_prompt + k_gen_budget, ceiling);
+    const int     needed_n_ctx = ((needed_raw + kKvBucket - 1) / kKvBucket) * kKvBucket;
 
     if (cc->kv.self_k != nullptr && cc->kv.n_ctx < needed_n_ctx) {
         cc->kv.free();
     }
     if (cc->kv.self_k == nullptr) {
         ggml_type kv_t = GGML_TYPE_F16;
-        if (cc->kv_type == TRANSCRIBE_KV_TYPE_F32) kv_t = GGML_TYPE_F32;
-        if (!transcribe::causal_lm::kv_init(
-                cc->kv, cm->plan.primary, needed_n_ctx,
-                cm->hparams.dec_n_kv_heads, cm->hparams.dec_head_dim,
-                cm->hparams.dec_n_layers, kv_t))
-        {
+        if (cc->kv_type == TRANSCRIBE_KV_TYPE_F32) {
+            kv_t = GGML_TYPE_F32;
+        }
+        if (!transcribe::causal_lm::kv_init(cc->kv, cm->plan.primary, needed_n_ctx, cm->hparams.dec_n_kv_heads,
+                                            cm->hparams.dec_head_dim, cm->hparams.dec_n_layers, kv_t)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "granite run: KV cache allocation failed (n_ctx=%d, "
-                "%d kv-heads x %d head-dim x %d layers) — out of memory. "
-                "Lower transcribe_session_params.n_ctx or shorten the audio.",
-                needed_n_ctx, cm->hparams.dec_n_kv_heads,
-                cm->hparams.dec_head_dim, cm->hparams.dec_n_layers);
+                                "granite run: KV cache allocation failed (n_ctx=%d, "
+                                "%d kv-heads x %d head-dim x %d layers) — out of memory. "
+                                "Lower transcribe_session_params.n_ctx or shorten the audio.",
+                                needed_n_ctx, cm->hparams.dec_n_kv_heads, cm->hparams.dec_head_dim,
+                                cm->hparams.dec_n_layers);
             return TRANSCRIBE_ERR_OOM;
         }
     }
     // After the gate + dynamic sizing this should be unreachable; keep as a
     // belt-and-braces invariant check.
     if (T_prompt > cc->kv.n_ctx) {
-        transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                            "granite run: T_prompt=%d exceeds kv.n_ctx=%d",
-                            T_prompt, cc->kv.n_ctx);
+        transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "granite run: T_prompt=%d exceeds kv.n_ctx=%d", T_prompt,
+                            cc->kv.n_ctx);
         return TRANSCRIBE_ERR_INPUT_TOO_LONG;
     }
 
     // Prefill graph in its own compute context.
     ggml_context * dec_ctx = nullptr;
     {
-        ggml_init_params ip {};
+        ggml_init_params ip{};
         ip.mem_size   = 64 * 1024 * 1024;  // 40 layers — generous headroom
         ip.mem_buffer = nullptr;
         ip.no_alloc   = true;
-        dec_ctx = ggml_init(ip);
+        dec_ctx       = ggml_init(ip);
         if (dec_ctx == nullptr) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "granite run: decoder compute context allocation failed — "
-                "out of memory.");
+                                "granite run: decoder compute context allocation failed — "
+                                "out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
     }
-    PrefillBuild dec = build_prefill_graph(
-        dec_ctx, cm->weights, cm->hparams, cc->kv,
-        T_prompt, n_audio_tokens, prefix_len, suffix_len,
-        cc->decoder_use_flash, /*slice_last=*/false);
+    PrefillBuild dec = build_prefill_graph(dec_ctx, cm->weights, cm->hparams, cc->kv, T_prompt, n_audio_tokens,
+                                           prefix_len, suffix_len, cc->decoder_use_flash, /*slice_last=*/false);
     if (dec.graph == nullptr || dec.out == nullptr) {
         ggml_free(dec_ctx);
         return TRANSCRIBE_ERR_GGUF;
@@ -1001,49 +928,42 @@ transcribe_status run(
     ggml_backend_sched_reset(cc->sched);
     if (!ggml_backend_sched_alloc_graph(cc->sched, dec.graph)) {
         transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "granite run: decoder prefill graph allocation failed — "
-            "out of memory.");
+                            "granite run: decoder prefill graph allocation failed — "
+                            "out of memory.");
         ggml_free(dec_ctx);
         return TRANSCRIBE_ERR_OOM;
     }
 
     // Upload decoder inputs.
-    ggml_backend_tensor_set(dec.input_ids_in, input_ids.data(), 0,
-                            input_ids.size() * sizeof(int32_t));
-    ggml_backend_tensor_set(dec.audio_feats_in, cc->audio_tokens_host.data(),
-                            0, cc->audio_tokens_host.size() * sizeof(float));
+    ggml_backend_tensor_set(dec.input_ids_in, input_ids.data(), 0, input_ids.size() * sizeof(int32_t));
+    ggml_backend_tensor_set(dec.audio_feats_in, cc->audio_tokens_host.data(), 0,
+                            cc->audio_tokens_host.size() * sizeof(float));
 
     {
         std::vector<int32_t> positions(T_prompt);
-        for (int i = 0; i < T_prompt; ++i) positions[i] = i;
-        ggml_backend_tensor_set(dec.positions_in, positions.data(), 0,
-                                positions.size() * sizeof(int32_t));
+        for (int i = 0; i < T_prompt; ++i) {
+            positions[i] = i;
+        }
+        ggml_backend_tensor_set(dec.positions_in, positions.data(), 0, positions.size() * sizeof(int32_t));
     }
 
     // Causal mask in F16: zero on/below diagonal, -inf above. f16 -inf
     // is the bit pattern 0xFC00.
     {
-        const uint16_t f16_zero    = 0x0000;
-        const uint16_t f16_neg_inf = 0xFC00;
-        std::vector<uint16_t> mask(
-            static_cast<size_t>(T_prompt) * T_prompt, f16_zero);
+        const uint16_t        f16_zero    = 0x0000;
+        const uint16_t        f16_neg_inf = 0xFC00;
+        std::vector<uint16_t> mask(static_cast<size_t>(T_prompt) * T_prompt, f16_zero);
         for (int q = 0; q < T_prompt; ++q) {
             for (int k = q + 1; k < T_prompt; ++k) {
                 mask[static_cast<size_t>(q) * T_prompt + k] = f16_neg_inf;
             }
         }
-        ggml_backend_tensor_set(dec.mask_in, mask.data(), 0,
-                                mask.size() * sizeof(uint16_t));
+        ggml_backend_tensor_set(dec.mask_in, mask.data(), 0, mask.size() * sizeof(uint16_t));
     }
 
     const int64_t t_dec_start = ggml_time_us();
-    if (const ggml_status gs =
-            ggml_backend_sched_graph_compute(cc->sched, dec.graph);
-        gs != GGML_STATUS_SUCCESS)
-    {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "granite run: decoder prefill compute failed (%d)",
-                     static_cast<int>(gs));
+    if (const ggml_status gs = ggml_backend_sched_graph_compute(cc->sched, dec.graph); gs != GGML_STATUS_SUCCESS) {
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "granite run: decoder prefill compute failed (%d)", static_cast<int>(gs));
         ggml_free(dec_ctx);
         return TRANSCRIBE_ERR_GGUF;
     }
@@ -1052,35 +972,35 @@ transcribe_status run(
     cc->kv.n    = T_prompt;
     cc->kv.head = T_prompt;
 
-    try_dump("dec.token_emb",       dec.dumps.token_emb,       "decoder");
-    try_dump("dec.audio_injected",  dec.dumps.audio_injected,  "decoder");
-    try_dump("dec.block.0.out",     dec.dumps.block_0_out,     "decoder");
+    try_dump("dec.token_emb", dec.dumps.token_emb, "decoder");
+    try_dump("dec.audio_injected", dec.dumps.audio_injected, "decoder");
+    try_dump("dec.block.0.out", dec.dumps.block_0_out, "decoder");
     if (dec.dumps.block_mid_out != nullptr) {
         char nm[64];
-        std::snprintf(nm, sizeof(nm), "dec.block.%d.out",
-                      cm->hparams.dec_n_layers / 2);
+        std::snprintf(nm, sizeof(nm), "dec.block.%d.out", cm->hparams.dec_n_layers / 2);
         try_dump(nm, dec.dumps.block_mid_out, "decoder");
     }
     if (dec.dumps.block_last_out != nullptr) {
         char nm[64];
-        std::snprintf(nm, sizeof(nm), "dec.block.%d.out",
-                      cm->hparams.dec_n_layers - 1);
+        std::snprintf(nm, sizeof(nm), "dec.block.%d.out", cm->hparams.dec_n_layers - 1);
         try_dump(nm, dec.dumps.block_last_out, "decoder");
     }
     try_dump("dec.out_before_head", dec.dumps.out_before_head, "decoder");
-    try_dump("dec.logits_raw",      dec.dumps.logits_raw,      "decoder");
+    try_dump("dec.logits_raw", dec.dumps.logits_raw, "decoder");
 
     // Read final-position logits to compute the first generated token.
     std::vector<float> last_logits(cm->hparams.dec_vocab_size);
-    ggml_backend_tensor_get(dec.out, last_logits.data(), 0,
-                            last_logits.size() * sizeof(float));
+    ggml_backend_tensor_get(dec.out, last_logits.data(), 0, last_logits.size() * sizeof(float));
     ggml_free(dec_ctx);
 
     auto argmax_logits = [](const std::vector<float> & v) -> int32_t {
-        int32_t best = 0;
+        int32_t best   = 0;
         float   best_v = v[0];
         for (int32_t i = 1; i < static_cast<int32_t>(v.size()); ++i) {
-            if (v[i] > best_v) { best_v = v[i]; best = i; }
+            if (v[i] > best_v) {
+                best_v = v[i];
+                best   = i;
+            }
         }
         return best;
     };
@@ -1095,21 +1015,17 @@ transcribe_status run(
     // Bound generation by the step budget, the allocated cache, AND the
     // context ceiling (the gate guarantees ceiling - T_prompt >= k_gen_budget,
     // so for in-spec input this stays k_gen_budget and decode is unchanged).
-    const int max_steps = std::min({ k_gen_budget,
-                                     max_n_kv - T_prompt,
-                                     ceiling  - T_prompt });
+    const int max_steps = std::min({ k_gen_budget, max_n_kv - T_prompt, ceiling - T_prompt });
 
     ggml_context * step_ctx = nullptr;
     {
-        ggml_init_params ip {};
+        ggml_init_params ip{};
         ip.mem_size   = 32 * 1024 * 1024;
         ip.mem_buffer = nullptr;
         ip.no_alloc   = true;
-        step_ctx = ggml_init(ip);
+        step_ctx      = ggml_init(ip);
     }
-    StepBuild step = build_step_graph(step_ctx, cm->weights, cm->hparams,
-                                      cc->kv, max_n_kv,
-                                      cc->decoder_use_flash);
+    StepBuild step = build_step_graph(step_ctx, cm->weights, cm->hparams, cc->kv, max_n_kv, cc->decoder_use_flash);
     if (step.graph == nullptr) {
         ggml_free(step_ctx);
         return TRANSCRIBE_ERR_GGUF;
@@ -1117,8 +1033,8 @@ transcribe_status run(
     ggml_backend_sched_reset(cc->sched);
     if (!ggml_backend_sched_alloc_graph(cc->sched, step.graph)) {
         transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "granite run: decode step graph allocation failed — "
-            "out of memory.");
+                            "granite run: decode step graph allocation failed — "
+                            "out of memory.");
         ggml_free(step_ctx);
         return TRANSCRIBE_ERR_OOM;
     }
@@ -1126,38 +1042,35 @@ transcribe_status run(
     std::vector<int32_t> gen_ids;
     gen_ids.reserve(max_steps);
 
-    const int32_t eos_id = cm->hparams.eos_token_id;
+    const int32_t         eos_id = cm->hparams.eos_token_id;
     // Step-loop mask sized for max_n_kv. We pre-fill -inf and let
     // valid positions get zeroed per step.
     std::vector<uint16_t> step_mask(max_n_kv, 0xFC00);
 
     for (int step_i = 0; step_i < max_steps; ++step_i) {
-        if (next_id == eos_id) break;
+        if (next_id == eos_id) {
+            break;
+        }
         gen_ids.push_back(next_id);
 
-        const int32_t pos = T_prompt + step_i;          // RoPE position
-        const int64_t kv_idx = pos;                     // KV write row
+        const int32_t pos      = T_prompt + step_i;  // RoPE position
+        const int64_t kv_idx   = pos;                // KV write row
         const int32_t input_id = next_id;
 
         // Zero mask up through `pos` (inclusive); the new K/V row sits
         // at index `pos`, so attention can see it.
-        std::fill(step_mask.begin(), step_mask.end(),
-                  static_cast<uint16_t>(0xFC00));
-        for (int i = 0; i <= pos; ++i) step_mask[i] = 0x0000;
+        std::fill(step_mask.begin(), step_mask.end(), static_cast<uint16_t>(0xFC00));
+        for (int i = 0; i <= pos; ++i) {
+            step_mask[i] = 0x0000;
+        }
 
         ggml_backend_tensor_set(step.input_id_in, &input_id, 0, sizeof(int32_t));
-        ggml_backend_tensor_set(step.position_in, &pos,      0, sizeof(int32_t));
-        ggml_backend_tensor_set(step.kv_idx_in,   &kv_idx,   0, sizeof(int64_t));
-        ggml_backend_tensor_set(step.mask_in, step_mask.data(), 0,
-                                step_mask.size() * sizeof(uint16_t));
-
-        if (const ggml_status gs =
-                ggml_backend_sched_graph_compute(cc->sched, step.graph);
-            gs != GGML_STATUS_SUCCESS)
-        {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "granite run: step compute failed (%d)",
-                         static_cast<int>(gs));
+        ggml_backend_tensor_set(step.position_in, &pos, 0, sizeof(int32_t));
+        ggml_backend_tensor_set(step.kv_idx_in, &kv_idx, 0, sizeof(int64_t));
+        ggml_backend_tensor_set(step.mask_in, step_mask.data(), 0, step_mask.size() * sizeof(uint16_t));
+
+        if (const ggml_status gs = ggml_backend_sched_graph_compute(cc->sched, step.graph); gs != GGML_STATUS_SUCCESS) {
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "granite run: step compute failed (%d)", static_cast<int>(gs));
             ggml_free(step_ctx);
             return TRANSCRIBE_ERR_GGUF;
         }
@@ -1166,7 +1079,7 @@ transcribe_status run(
         ggml_backend_tensor_get(step.out, &amax, 0, sizeof(int32_t));
         cc->kv.n    = pos + 1;
         cc->kv.head = pos + 1;
-        next_id = amax;
+        next_id     = amax;
     }
 
     ggml_free(step_ctx);
@@ -1177,33 +1090,29 @@ transcribe_status run(
     // silently shortened transcript.
     if (next_id != eos_id) {
         cc->was_truncated = true;
-        transcribe::log_msg(
-            TRANSCRIBE_LOG_LEVEL_WARN,
-            "granite run: output truncated at %d tokens — decode reached the "
-            "generation budget before end-of-stream; the transcript may be "
-            "incomplete.",
-            static_cast<int>(gen_ids.size()));
+        transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_WARN,
+                            "granite run: output truncated at %d tokens — decode reached the "
+                            "generation budget before end-of-stream; the transcript may be "
+                            "incomplete.",
+                            static_cast<int>(gen_ids.size()));
     }
 
     // Detokenize.
-    cc->full_text = cm->tok.decode(gen_ids.data(),
-                                   static_cast<int>(gen_ids.size()));
+    cc->full_text = cm->tok.decode(gen_ids.data(), static_cast<int>(gen_ids.size()));
 
     cc->result_kind = TRANSCRIBE_TIMESTAMPS_NONE;
     cc->has_result  = true;
-    transcribe_session::SegmentEntry seg {};
+    transcribe_session::SegmentEntry seg{};
     seg.text  = cc->full_text;
     seg.t0_ms = 0;
-    seg.t1_ms = static_cast<int64_t>(n_samples) * 1000
-              / static_cast<int64_t>(cm->hparams.fe_sample_rate);
+    seg.t1_ms = static_cast<int64_t>(n_samples) * 1000 / static_cast<int64_t>(cm->hparams.fe_sample_rate);
     cc->segments.push_back(std::move(seg));
 
     // Output truncation (decode hit the generation budget / context ceiling
     // before EOS) is a hard status, not a silent success: surface it so the
     // caller can distinguish a complete transcript from one cut short. The
     // partial transcript is still attached above for inspection.
-    return cc->was_truncated ? TRANSCRIBE_ERR_OUTPUT_TRUNCATED
-                             : TRANSCRIBE_OK;
+    return cc->was_truncated ? TRANSCRIBE_ERR_OUTPUT_TRUNCATED : TRANSCRIBE_OK;
 }
 
 // Offline batched decode (transcribe_run_batch). Serial mel + Conformer
@@ -1217,10 +1126,10 @@ transcribe_status reset_ctx_g(GraniteSession * cc, int mb) {
         ggml_free(cc->compute_ctx);
         cc->compute_ctx = nullptr;
     }
-    ggml_init_params ip {};
-    ip.mem_size   = static_cast<size_t>(mb) * 1024 * 1024;
-    ip.mem_buffer = nullptr;
-    ip.no_alloc   = true;
+    ggml_init_params ip{};
+    ip.mem_size     = static_cast<size_t>(mb) * 1024 * 1024;
+    ip.mem_buffer   = nullptr;
+    ip.no_alloc     = true;
     cc->compute_ctx = ggml_init(ip);
     return cc->compute_ctx != nullptr ? TRANSCRIBE_OK : TRANSCRIBE_ERR_GGUF;
 }
@@ -1235,106 +1144,111 @@ void apply_threads_g(GraniteSession * cc) {
 // measured wash on Metal and L40S and strictly worse for mixed-length batches
 // (it pads to the longest). Only the decode and host-side mel benefit from
 // batching/threading.
-transcribe_status encode_one(
-    GraniteSession * cc, GraniteModel * cm,
-    const std::vector<float> & mel_buf, int t_enc,
-    std::vector<float> & audio_out, int & n_audio_out,
-    int64_t & enc_us) {
+transcribe_status encode_one(GraniteSession *           cc,
+                             GraniteModel *             cm,
+                             const std::vector<float> & mel_buf,
+                             int                        t_enc,
+                             std::vector<float> &       audio_out,
+                             int &                      n_audio_out,
+                             int64_t &                  enc_us) {
     const auto & hp = cm->hparams;
-    if (t_enc <= 0) return TRANSCRIBE_ERR_GGUF;
+    if (t_enc <= 0) {
+        return TRANSCRIBE_ERR_GGUF;
+    }
 
     if (reset_ctx_g(cc, 32) != TRANSCRIBE_OK) {
         transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "granite encode_one: compute context allocation failed — "
-            "out of memory.");
+                            "granite encode_one: compute context allocation failed — "
+                            "out of memory.");
         return TRANSCRIBE_ERR_OOM;
     }
-    EncoderBuild eb = build_encoder_graph(cc->compute_ctx, cm->weights, hp,
-                                          t_enc, cc->encoder_use_flash);
-    if (eb.graph == nullptr || eb.out == nullptr) return TRANSCRIBE_ERR_GGUF;
+    EncoderBuild eb = build_encoder_graph(cc->compute_ctx, cm->weights, hp, t_enc, cc->encoder_use_flash);
+    if (eb.graph == nullptr || eb.out == nullptr) {
+        return TRANSCRIBE_ERR_GGUF;
+    }
     if (cc->sched == nullptr) {
-        cc->sched = ggml_backend_sched_new(
-            cm->plan.scheduler_list.data(), nullptr,
-            static_cast<int>(cm->plan.scheduler_list.size()),
-            32768, false, true);
-        if (cc->sched == nullptr) return TRANSCRIBE_ERR_GGUF;
+        cc->sched = ggml_backend_sched_new(cm->plan.scheduler_list.data(), nullptr,
+                                           static_cast<int>(cm->plan.scheduler_list.size()), 32768, false, true);
+        if (cc->sched == nullptr) {
+            return TRANSCRIBE_ERR_GGUF;
+        }
     }
     ggml_backend_sched_reset(cc->sched);
     if (!ggml_backend_sched_alloc_graph(cc->sched, eb.graph)) {
         transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "granite encode_one: encoder graph allocation failed — "
-            "out of memory.");
+                            "granite encode_one: encoder graph allocation failed — "
+                            "out of memory.");
         return TRANSCRIBE_ERR_OOM;
     }
 
-    ggml_backend_tensor_set(eb.mel_in, mel_buf.data(), 0,
-                            mel_buf.size() * sizeof(float));
-    std::vector<int32_t> dists = precompute_attention_dists(
-        hp.enc_context_size, hp.enc_max_pos_emb);
-    ggml_backend_tensor_set(eb.attention_dists, dists.data(), 0,
-                            dists.size() * sizeof(int32_t));
+    ggml_backend_tensor_set(eb.mel_in, mel_buf.data(), 0, mel_buf.size() * sizeof(float));
+    std::vector<int32_t> dists = precompute_attention_dists(hp.enc_context_size, hp.enc_max_pos_emb);
+    ggml_backend_tensor_set(eb.attention_dists, dists.data(), 0, dists.size() * sizeof(int32_t));
     {
-        const int ctx_size = hp.enc_context_size;
-        const size_t plane = static_cast<size_t>(ctx_size) * ctx_size;
+        const int          ctx_size = hp.enc_context_size;
+        const size_t       plane    = static_cast<size_t>(ctx_size) * ctx_size;
         std::vector<float> mask(plane * eb.n_blocks_local, 0.0f);
-        const int rem = eb.last_block_rem;
+        const int          rem = eb.last_block_rem;
         if (rem > 0 && rem < ctx_size) {
             std::vector<float> last = precompute_last_block_mask(ctx_size, rem);
-            std::memcpy(mask.data() + plane * (eb.n_blocks_local - 1),
-                        last.data(), plane * sizeof(float));
+            std::memcpy(mask.data() + plane * (eb.n_blocks_local - 1), last.data(), plane * sizeof(float));
         }
-        ggml_backend_tensor_set(eb.last_block_mask, mask.data(), 0,
-                                mask.size() * sizeof(float));
+        ggml_backend_tensor_set(eb.last_block_mask, mask.data(), 0, mask.size() * sizeof(float));
     }
     if (eb.zero_pad != nullptr) {
-        const size_t n_elems = static_cast<size_t>(eb.zero_pad->ne[0]) *
-                               eb.zero_pad->ne[1];
+        const size_t       n_elems = static_cast<size_t>(eb.zero_pad->ne[0]) * eb.zero_pad->ne[1];
         std::vector<float> zeros(n_elems, 0.0f);
-        ggml_backend_tensor_set(eb.zero_pad, zeros.data(), 0,
-                                zeros.size() * sizeof(float));
+        ggml_backend_tensor_set(eb.zero_pad, zeros.data(), 0, zeros.size() * sizeof(float));
     }
     apply_threads_g(cc);
 
     const int64_t t_enc0 = ggml_time_us();
-    if (ggml_backend_sched_graph_compute(cc->sched, eb.graph) != GGML_STATUS_SUCCESS)
+    if (ggml_backend_sched_graph_compute(cc->sched, eb.graph) != GGML_STATUS_SUCCESS) {
         return TRANSCRIBE_ERR_GGUF;
+    }
     enc_us += ggml_time_us() - t_enc0;
 
-    const int64_t enc_hidden = eb.out->ne[0];
-    const int64_t enc_T      = eb.out->ne[1];
+    const int64_t      enc_hidden = eb.out->ne[0];
+    const int64_t      enc_T      = eb.out->ne[1];
     std::vector<float> enc_host(static_cast<size_t>(enc_hidden) * enc_T);
-    ggml_backend_tensor_get(eb.out, enc_host.data(), 0,
-                            enc_host.size() * sizeof(float));
+    ggml_backend_tensor_get(eb.out, enc_host.data(), 0, enc_host.size() * sizeof(float));
 
     ggml_context * proj_ctx = nullptr;
-    { ggml_init_params ip {}; ip.mem_size = 16 * 1024 * 1024; ip.no_alloc = true;
-      proj_ctx = ggml_init(ip);
-      if (proj_ctx == nullptr) {
-          transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-              "granite encode_one: projector compute context allocation "
-              "failed — out of memory.");
-          return TRANSCRIBE_ERR_OOM;
-      } }
-    ProjectorBuild pb = build_projector_graph(proj_ctx, cm->weights, hp,
-                                              static_cast<int>(enc_T));
-    if (pb.graph == nullptr || pb.out == nullptr) { ggml_free(proj_ctx); return TRANSCRIBE_ERR_GGUF; }
+    {
+        ggml_init_params ip{};
+        ip.mem_size = 16 * 1024 * 1024;
+        ip.no_alloc = true;
+        proj_ctx    = ggml_init(ip);
+        if (proj_ctx == nullptr) {
+            transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
+                                "granite encode_one: projector compute context allocation "
+                                "failed — out of memory.");
+            return TRANSCRIBE_ERR_OOM;
+        }
+    }
+    ProjectorBuild pb = build_projector_graph(proj_ctx, cm->weights, hp, static_cast<int>(enc_T));
+    if (pb.graph == nullptr || pb.out == nullptr) {
+        ggml_free(proj_ctx);
+        return TRANSCRIBE_ERR_GGUF;
+    }
     ggml_backend_sched_reset(cc->sched);
     if (!ggml_backend_sched_alloc_graph(cc->sched, pb.graph)) {
         transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "granite encode_one: projector graph allocation failed — "
-            "out of memory.");
+                            "granite encode_one: projector graph allocation failed — "
+                            "out of memory.");
         ggml_free(proj_ctx);
         return TRANSCRIBE_ERR_OOM;
     }
     ggml_backend_tensor_set(pb.enc_in, enc_host.data(), 0, enc_host.size() * sizeof(float));
     if (pb.enc_pad != nullptr) {
-        const size_t n = static_cast<size_t>(pb.enc_pad->ne[0]) * pb.enc_pad->ne[1];
+        const size_t       n = static_cast<size_t>(pb.enc_pad->ne[0]) * pb.enc_pad->ne[1];
         std::vector<float> pad(n, 0.0f);
         ggml_backend_tensor_set(pb.enc_pad, pad.data(), 0, n * sizeof(float));
     }
     const int64_t t_enc1 = ggml_time_us();
     if (ggml_backend_sched_graph_compute(cc->sched, pb.graph) != GGML_STATUS_SUCCESS) {
-        ggml_free(proj_ctx); return TRANSCRIBE_ERR_GGUF;
+        ggml_free(proj_ctx);
+        return TRANSCRIBE_ERR_GGUF;
     }
     enc_us += ggml_time_us() - t_enc1;
     n_audio_out = pb.n_audio_tokens;
@@ -1344,66 +1258,71 @@ transcribe_status encode_one(
     return TRANSCRIBE_OK;
 }
 
-transcribe_status run(transcribe_session *, const float *, int,
-                      const transcribe_run_params *);
+transcribe_status run(transcribe_session *, const float *, int, const transcribe_run_params *);
 
-transcribe_status run_batch_serial(GraniteSession * cc,
-                                   const float * const * pcm,
-                                   const int * n_samples, int n,
+transcribe_status run_batch_serial(GraniteSession *              cc,
+                                   const float * const *         pcm,
+                                   const int *                   n_samples,
+                                   int                           n,
                                    const transcribe_run_params * params) {
     for (int i = 0; i < n; ++i) {
-        if (cc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
-        const transcribe_status st =
-            (pcm[i] == nullptr || n_samples[i] <= 0)
-                ? TRANSCRIBE_ERR_INVALID_ARG
-                : run(cc, pcm[i], n_samples[i], params);
-        if (st == TRANSCRIBE_OK) cc->batch_results.push_back(cc->capture_result(st));
-        else {
-            transcribe_session::ResultSet rs; rs.status = st;
+        if (cc->poll_abort()) {
+            return TRANSCRIBE_ERR_ABORTED;
+        }
+        const transcribe_status st = (pcm[i] == nullptr || n_samples[i] <= 0) ? TRANSCRIBE_ERR_INVALID_ARG :
+                                                                                run(cc, pcm[i], n_samples[i], params);
+        if (st == TRANSCRIBE_OK) {
+            cc->batch_results.push_back(cc->capture_result(st));
+        } else {
+            transcribe_session::ResultSet rs;
+            rs.status = st;
             cc->batch_results.push_back(std::move(rs));
         }
     }
     return TRANSCRIBE_OK;
 }
 
-} // namespace
+}  // namespace
 
-transcribe_status run_batch(
-    transcribe_session *          session,
-    const float * const *         pcm,
-    const int *                   n_samples,
-    int                           n,
-    const transcribe_run_params * params) {
-    if (session == nullptr || pcm == nullptr || n_samples == nullptr || n <= 0)
+transcribe_status run_batch(transcribe_session *          session,
+                            const float * const *         pcm,
+                            const int *                   n_samples,
+                            int                           n,
+                            const transcribe_run_params * params) {
+    if (session == nullptr || pcm == nullptr || n_samples == nullptr || n <= 0) {
         return TRANSCRIBE_ERR_INVALID_ARG;
+    }
     auto * cc = static_cast<GraniteSession *>(session);
     auto * cm = static_cast<GraniteModel *>(cc->model);
-    if (cm == nullptr || cm->plan.scheduler_list.empty() || !cm->mel.has_value())
+    if (cm == nullptr || cm->plan.scheduler_list.empty() || !cm->mel.has_value()) {
         return TRANSCRIBE_ERR_INVALID_ARG;
+    }
 
-    if (!cc->decoder_use_flash || transcribe::debug::enabled() || n == 1)
+    if (!cc->decoder_use_flash || transcribe::debug::enabled() || n == 1) {
         return run_batch_serial(cc, pcm, n_samples, n, params);
+    }
 
     transcribe::debug::init();
     const auto & hp = cm->hparams;
 
     // Shared prompt affixes (one run_params across the batch).
     std::vector<int32_t> prefix_ids, suffix_ids;
-    if (build_granite_affixes(cm, params, prefix_ids, suffix_ids) != TRANSCRIBE_OK)
+    if (build_granite_affixes(cm, params, prefix_ids, suffix_ids) != TRANSCRIBE_OK) {
         return TRANSCRIBE_ERR_INVALID_ARG;
+    }
     const int prefix_len = static_cast<int>(prefix_ids.size());
 
     // Pass 1: per-utterance mel + encoder + projector (serial).
-    std::vector<char> valid(n, 0);
+    std::vector<char>                 valid(n, 0);
     // Per-utterance failure status for the result capture below. Defaults to
     // INVALID_ARG (bad pcm / mel / encode); the input-length gate upgrades it
     // to INPUT_TOO_LONG for over-length clips.
-    std::vector<transcribe_status> fail_status(n, TRANSCRIBE_ERR_INVALID_ARG);
-    std::vector<std::vector<float>> audio_hosts(n);
-    std::vector<int> n_audio(n, 0);
+    std::vector<transcribe_status>    fail_status(n, TRANSCRIBE_ERR_INVALID_ARG);
+    std::vector<std::vector<float>>   audio_hosts(n);
+    std::vector<int>                  n_audio(n, 0);
     std::vector<std::vector<int32_t>> prompt_ids(n);
-    std::vector<int> T_prompt(n, 0);
-    int64_t mel_us = 0, enc_us = 0;
+    std::vector<int>                  T_prompt(n, 0);
+    int64_t                           mel_us = 0, enc_us = 0;
 
     // Decoder context ceiling for the per-utterance input-length gate. Same
     // value the single-utterance run() enforces; an over-length utterance is
@@ -1413,17 +1332,21 @@ transcribe_status run_batch(
 
     // Pass 0: parallel mel + 2-frame stack (host-side, thread-safe).
     std::vector<std::vector<float>> mel_bufs(n);
-    std::vector<int> mel_t_enc(n, 0);
-    int n_mel_threads = cc->n_threads;
-    if (n_mel_threads <= 0)
+    std::vector<int>                mel_t_enc(n, 0);
+    int                             n_mel_threads = cc->n_threads;
+    if (n_mel_threads <= 0) {
         n_mel_threads = transcribe::default_n_threads();
+    }
     const int64_t t_mel0 = ggml_time_us();
     transcribe::parallel_for_all(n, n_mel_threads, [&](int b) {
-        if (pcm[b] == nullptr || n_samples[b] <= 0) return true;
+        if (pcm[b] == nullptr || n_samples[b] <= 0) {
+            return true;
+        }
         int t = 0;
         if (compute_mel_encoder_input(*cm->mel, pcm[b], n_samples[b],
-                                      /*n_threads=*/1, mel_bufs[b], t) == TRANSCRIBE_OK)
+                                      /*n_threads=*/1, mel_bufs[b], t) == TRANSCRIBE_OK) {
             mel_t_enc[b] = t;
+        }
         return true;
     });
     mel_us += ggml_time_us() - t_mel0;
@@ -1431,27 +1354,33 @@ transcribe_status run_batch(
     // Pass 1: per-utterance encoder + projector (serial — see encode_one's
     // note). Only the mel (Pass 0) is parallelized; the decode is batched below.
     for (int b = 0; b < n; ++b) {
-        if (cc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
-        if (mel_t_enc[b] <= 0) continue;
-        if (encode_one(cc, cm, mel_bufs[b], mel_t_enc[b],
-                       audio_hosts[b], n_audio[b], enc_us) != TRANSCRIBE_OK)
+        if (cc->poll_abort()) {
+            return TRANSCRIBE_ERR_ABORTED;
+        }
+        if (mel_t_enc[b] <= 0) {
             continue;
-        if (n_audio[b] <= 0) continue;
+        }
+        if (encode_one(cc, cm, mel_bufs[b], mel_t_enc[b], audio_hosts[b], n_audio[b], enc_us) != TRANSCRIBE_OK) {
+            continue;
+        }
+        if (n_audio[b] <= 0) {
+            continue;
+        }
         prompt_ids[b] = prefix_ids;
-        for (int i = 0; i < n_audio[b]; ++i) prompt_ids[b].push_back(0);  // placeholder
+        for (int i = 0; i < n_audio[b]; ++i) {
+            prompt_ids[b].push_back(0);  // placeholder
+        }
         prompt_ids[b].insert(prompt_ids[b].end(), suffix_ids.begin(), suffix_ids.end());
         T_prompt[b] = static_cast<int>(prompt_ids[b].size());
 
         // Input-length gate, mirroring the single-shot run() gate.
         if (T_prompt[b] + k_gen_budget > ceiling) {
-            transcribe::log_msg(
-                TRANSCRIBE_LOG_LEVEL_ERROR,
-                "granite run_batch: utterance %d input too long — %d audio + %d "
-                "prompt tokens leave no room for output within the %d-token "
-                "context (need %d). Shorten the audio (see "
-                "transcribe_capabilities.max_audio_ms) or split it.",
-                b, n_audio[b], T_prompt[b] - n_audio[b], ceiling,
-                T_prompt[b] + k_gen_budget);
+            transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
+                                "granite run_batch: utterance %d input too long — %d audio + %d "
+                                "prompt tokens leave no room for output within the %d-token "
+                                "context (need %d). Shorten the audio (see "
+                                "transcribe_capabilities.max_audio_ms) or split it.",
+                                b, n_audio[b], T_prompt[b] - n_audio[b], ceiling, T_prompt[b] + k_gen_budget);
             fail_status[b] = TRANSCRIBE_ERR_INPUT_TOO_LONG;
             continue;
         }
@@ -1459,96 +1388,103 @@ transcribe_status run_batch(
     }
 
     int max_T_prompt = 0, n_audio_max = 0;
-    for (int b = 0; b < n; ++b) if (valid[b]) {
-        max_T_prompt = std::max(max_T_prompt, T_prompt[b]);
-        n_audio_max  = std::max(n_audio_max, n_audio[b]);
+    for (int b = 0; b < n; ++b) {
+        if (valid[b]) {
+            max_T_prompt = std::max(max_T_prompt, T_prompt[b]);
+            n_audio_max  = std::max(n_audio_max, n_audio[b]);
+        }
     }
     if (max_T_prompt == 0) {
         for (int b = 0; b < n; ++b) {
-            transcribe_session::ResultSet rs; rs.status = fail_status[b];
+            transcribe_session::ResultSet rs;
+            rs.status = fail_status[b];
             cc->batch_results.push_back(std::move(rs));
         }
         return TRANSCRIBE_OK;
     }
-    n_audio_max = std::max(1, n_audio_max);
-    const int max_new = 256;
-    int max_n_kv = 1024;
-    while (max_n_kv < max_T_prompt + max_new) max_n_kv *= 2;
+    n_audio_max        = std::max(1, n_audio_max);
+    const int max_new  = 256;
+    int       max_n_kv = 1024;
+    while (max_n_kv < max_T_prompt + max_new) {
+        max_n_kv *= 2;
+    }
     // Honor the session context cap: clamp the pow2-rounded width to the
     // ceiling (the per-utterance gate guarantees every valid row fits).
-    if (max_n_kv > ceiling) max_n_kv = ceiling;
+    if (max_n_kv > ceiling) {
+        max_n_kv = ceiling;
+    }
 
     // Allocate batched KV cache.
-    ggml_type kv_type = (cc->kv_type == TRANSCRIBE_KV_TYPE_F32)
-                      ? GGML_TYPE_F32 : GGML_TYPE_F16;
-    if (cc->kv_batch.self_k == nullptr ||
-        cc->kv_batch_cap != n || cc->kv_batch_n_ctx != max_n_kv) {
+    ggml_type kv_type = (cc->kv_type == TRANSCRIBE_KV_TYPE_F32) ? GGML_TYPE_F32 : GGML_TYPE_F16;
+    if (cc->kv_batch.self_k == nullptr || cc->kv_batch_cap != n || cc->kv_batch_n_ctx != max_n_kv) {
         cc->kv_batch.free();
-        if (!transcribe::causal_lm::kv_init_batched(
-                cc->kv_batch, cm->plan.primary, max_n_kv,
-                hp.dec_n_kv_heads, hp.dec_head_dim, hp.dec_n_layers, n, kv_type)) {
+        if (!transcribe::causal_lm::kv_init_batched(cc->kv_batch, cm->plan.primary, max_n_kv, hp.dec_n_kv_heads,
+                                                    hp.dec_head_dim, hp.dec_n_layers, n, kv_type)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "granite run_batch: batched KV cache allocation failed "
-                "(n_ctx=%d, batch=%d) — out of memory.", max_n_kv, n);
+                                "granite run_batch: batched KV cache allocation failed "
+                                "(n_ctx=%d, batch=%d) — out of memory.",
+                                max_n_kv, n);
             return TRANSCRIBE_ERR_OOM;
         }
-        cc->kv_batch_cap = n; cc->kv_batch_n_ctx = max_n_kv;
+        cc->kv_batch_cap   = n;
+        cc->kv_batch_n_ctx = max_n_kv;
     } else if (cc->kv_batch.buffer != nullptr) {
         ggml_backend_buffer_clear(cc->kv_batch.buffer, 0);
     }
 
     // Pass 2: batched prefill.
-    std::vector<int32_t> next_tok(n, 0);
-    std::vector<int> n_past(n, 0);
+    std::vector<int32_t>              next_tok(n, 0);
+    std::vector<int>                  n_past(n, 0);
     std::vector<std::vector<int32_t>> generated(n);
-    const int64_t t_pref0 = ggml_time_us();
+    const int64_t                     t_pref0 = ggml_time_us();
     {
         if (reset_ctx_g(cc, 64) != TRANSCRIBE_OK) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "granite run_batch: prefill compute context allocation failed "
-                "— out of memory.");
+                                "granite run_batch: prefill compute context allocation failed "
+                                "— out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
-        PrefillBuildBatched pb = build_prefill_graph_batched(
-            cc->compute_ctx, cm->weights, hp, cc->kv_batch,
-            max_T_prompt, n_audio_max, n, cc->decoder_use_flash);
-        if (pb.graph == nullptr || pb.out == nullptr) return TRANSCRIBE_ERR_GGUF;
+        PrefillBuildBatched pb = build_prefill_graph_batched(cc->compute_ctx, cm->weights, hp, cc->kv_batch,
+                                                             max_T_prompt, n_audio_max, n, cc->decoder_use_flash);
+        if (pb.graph == nullptr || pb.out == nullptr) {
+            return TRANSCRIBE_ERR_GGUF;
+        }
         ggml_backend_sched_reset(cc->sched);
         if (!ggml_backend_sched_alloc_graph(cc->sched, pb.graph)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "granite run_batch: batched prefill graph allocation failed "
-                "— out of memory.");
+                                "granite run_batch: batched prefill graph allocation failed "
+                                "— out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
 
-        const int hidden = hp.dec_hidden;
+        const int            hidden = hp.dec_hidden;
         std::vector<int32_t> ids(static_cast<size_t>(max_T_prompt) * n, 0);
         // Audio injection by elementwise blend: audio_dense holds each
         // utterance's audio embeds scattered into their prompt positions (zero
         // elsewhere), keep is 0 there and 1 elsewhere. x = x*keep + audio_dense.
-        std::vector<float> audio_dense(static_cast<size_t>(hidden) * max_T_prompt * n, 0.0f);
-        std::vector<float> keep(static_cast<size_t>(max_T_prompt) * n, 1.0f);
+        std::vector<float>   audio_dense(static_cast<size_t>(hidden) * max_T_prompt * n, 0.0f);
+        std::vector<float>   keep(static_cast<size_t>(max_T_prompt) * n, 1.0f);
         std::vector<int64_t> kidx(static_cast<size_t>(max_T_prompt) * n);
         std::vector<int32_t> lidx(n, 0);
         for (int b = 0; b < n; ++b) {
             const int na = valid[b] ? n_audio[b] : 0;
             const int tp = valid[b] ? T_prompt[b] : 0;
             if (valid[b]) {
-                std::memcpy(ids.data() + static_cast<size_t>(b) * max_T_prompt,
-                            prompt_ids[b].data(), static_cast<size_t>(tp) * sizeof(int32_t));
+                std::memcpy(ids.data() + static_cast<size_t>(b) * max_T_prompt, prompt_ids[b].data(),
+                            static_cast<size_t>(tp) * sizeof(int32_t));
                 // audio_hosts[b] is [hidden, na] column-major; audio token j lands
                 // at prompt position prefix_len+j, flat column b*max_T_prompt+pos.
                 for (int j = 0; j < na; ++j) {
-                    const size_t dst_col =
-                        static_cast<size_t>(b) * max_T_prompt + (prefix_len + j);
+                    const size_t dst_col = static_cast<size_t>(b) * max_T_prompt + (prefix_len + j);
                     std::memcpy(audio_dense.data() + dst_col * hidden,
                                 audio_hosts[b].data() + static_cast<size_t>(j) * hidden,
                                 static_cast<size_t>(hidden) * sizeof(float));
                     keep[dst_col] = 0.0f;
                 }
             }
-            for (int t = 0; t < max_T_prompt; ++t)
+            for (int t = 0; t < max_T_prompt; ++t) {
                 kidx[static_cast<size_t>(b) * max_T_prompt + t] = t;
+            }
             lidx[b] = valid[b] ? (tp - 1) : 0;
         }
         ggml_backend_tensor_set(pb.input_ids_in, ids.data(), 0, ids.size() * sizeof(int32_t));
@@ -1556,27 +1492,35 @@ transcribe_status run_batch(
         ggml_backend_tensor_set(pb.keep_mask_in, keep.data(), 0, keep.size() * sizeof(float));
         {
             std::vector<int32_t> pos(max_T_prompt);
-            for (int t = 0; t < max_T_prompt; ++t) pos[t] = t;
+            for (int t = 0; t < max_T_prompt; ++t) {
+                pos[t] = t;
+            }
             ggml_backend_tensor_set(pb.positions_in, pos.data(), 0, pos.size() * sizeof(int32_t));
         }
         {
-            const uint16_t f16_zero = 0x0000, f16_ninf = 0xFC00;
+            const uint16_t        f16_zero = 0x0000, f16_ninf = 0xFC00;
             std::vector<uint16_t> mask(static_cast<size_t>(max_T_prompt) * max_T_prompt, f16_zero);
-            for (int q = 0; q < max_T_prompt; ++q)
-                for (int k = q + 1; k < max_T_prompt; ++k)
+            for (int q = 0; q < max_T_prompt; ++q) {
+                for (int k = q + 1; k < max_T_prompt; ++k) {
                     mask[static_cast<size_t>(q) * max_T_prompt + k] = f16_ninf;
+                }
+            }
             ggml_backend_tensor_set(pb.mask_in, mask.data(), 0, mask.size() * sizeof(uint16_t));
         }
         ggml_backend_tensor_set(pb.kv_idx_in, kidx.data(), 0, kidx.size() * sizeof(int64_t));
         ggml_backend_tensor_set(pb.last_idx_in, lidx.data(), 0, lidx.size() * sizeof(int32_t));
         apply_threads_g(cc);
-        if (ggml_backend_sched_graph_compute(cc->sched, pb.graph) != GGML_STATUS_SUCCESS)
+        if (ggml_backend_sched_graph_compute(cc->sched, pb.graph) != GGML_STATUS_SUCCESS) {
             return TRANSCRIBE_ERR_GGUF;
+        }
         std::vector<int32_t> amax(n, 0);
         ggml_backend_tensor_get(pb.out, amax.data(), 0, amax.size() * sizeof(int32_t));
         for (int b = 0; b < n; ++b) {
-            if (!valid[b]) continue;
-            n_past[b] = T_prompt[b]; next_tok[b] = amax[b];
+            if (!valid[b]) {
+                continue;
+            }
+            n_past[b]   = T_prompt[b];
+            next_tok[b] = amax[b];
             generated[b].push_back(amax[b]);
         }
     }
@@ -1588,23 +1532,24 @@ transcribe_status run_batch(
 
     if (reset_ctx_g(cc, 32) != TRANSCRIBE_OK) {
         transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "granite run_batch: step compute context allocation failed — "
-            "out of memory.");
+                            "granite run_batch: step compute context allocation failed — "
+                            "out of memory.");
         return TRANSCRIBE_ERR_OOM;
     }
-    StepBuildBatched sb = build_step_graph_batched(
-        cc->compute_ctx, cm->weights, hp, cc->kv_batch, max_n_kv, n,
-        cc->decoder_use_flash);
-    if (sb.graph == nullptr || sb.out == nullptr) return TRANSCRIBE_ERR_GGUF;
+    StepBuildBatched sb =
+        build_step_graph_batched(cc->compute_ctx, cm->weights, hp, cc->kv_batch, max_n_kv, n, cc->decoder_use_flash);
+    if (sb.graph == nullptr || sb.out == nullptr) {
+        return TRANSCRIBE_ERR_GGUF;
+    }
     ggml_backend_sched_reset(cc->sched);
     if (!ggml_backend_sched_alloc_graph(cc->sched, sb.graph)) {
         transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "granite run_batch: batched step graph allocation failed — "
-            "out of memory.");
+                            "granite run_batch: batched step graph allocation failed — "
+                            "out of memory.");
         return TRANSCRIBE_ERR_OOM;
     }
 
-    transcribe::causal_lm::StepBatchedIO io {};
+    transcribe::causal_lm::StepBatchedIO io{};
     io.input_ids = sb.input_ids_in;
     io.positions = sb.position_in;
     io.kv_idx    = sb.kv_idx_in;
@@ -1618,58 +1563,60 @@ transcribe_status run_batch(
     step_state.n_past   = n_past;
 
     transcribe::causal_lm::StepLoopStats step_stats;
-    std::vector<char> truncated;
+    std::vector<char>                    truncated;
     if (const transcribe_status st = transcribe::causal_lm::run_batched_step_loop(
-            cc, cc->sched, io, n, max_n_kv, eos_id, max_new, step_state,
-            generated, &step_stats, &truncated); st != TRANSCRIBE_OK) {
+            cc, cc->sched, io, n, max_n_kv, eos_id, max_new, step_state, generated, &step_stats, &truncated);
+        st != TRANSCRIBE_OK) {
         return st;
     }
     const int64_t step_us = step_stats.step_us;
 
     if (transcribe::env::flag("TRANSCRIBE_PERF_DEBUG")) {
         int total_steps = 0;
-        for (int b = 0; b < n; ++b)
+        for (int b = 0; b < n; ++b) {
             total_steps = std::max<int>(total_steps, static_cast<int>(generated[b].size()));
+        }
         log_msg(TRANSCRIBE_LOG_LEVEL_DEBUG,
-            "granite run_batch: n=%d max_n_kv=%d steps=%d max_T_prompt=%d n_audio_max=%d\n"
-            "  mel=%.1fms enc+proj=%.1fms (serial x%d)  prefill=%.1fms (batched)  step_loop=%.1fms (%.2fms/step, batched)",
-            n, max_n_kv, total_steps, max_T_prompt, n_audio_max,
-            mel_us / 1000.0, enc_us / 1000.0, n,
-            prefill_us / 1000.0, step_us / 1000.0,
-            total_steps > 0 ? step_us / 1000.0 / total_steps : 0.0);
+                "granite run_batch: n=%d max_n_kv=%d steps=%d max_T_prompt=%d n_audio_max=%d\n"
+                "  mel=%.1fms enc+proj=%.1fms (serial x%d)  prefill=%.1fms (batched)  step_loop=%.1fms (%.2fms/step, "
+                "batched)",
+                n, max_n_kv, total_steps, max_T_prompt, n_audio_max, mel_us / 1000.0, enc_us / 1000.0, n,
+                prefill_us / 1000.0, step_us / 1000.0, total_steps > 0 ? step_us / 1000.0 / total_steps : 0.0);
     }
 
     // Capture results.
-    const int valid_count = std::max(1, static_cast<int>(
-        std::count(valid.begin(), valid.end(), char(1))));
+    const int valid_count = std::max(1, static_cast<int>(std::count(valid.begin(), valid.end(), char(1))));
     for (int b = 0; b < n; ++b) {
         if (!valid[b]) {
-            transcribe_session::ResultSet rs; rs.status = fail_status[b];
+            transcribe_session::ResultSet rs;
+            rs.status = fail_status[b];
             cc->batch_results.push_back(std::move(rs));
             continue;
         }
         std::vector<int32_t> gen = generated[b];
-        if (!gen.empty() && gen.back() == eos_id) gen.pop_back();
-        std::string transcript = cm->tok.decode(gen.data(), static_cast<int>(gen.size()));
+        if (!gen.empty() && gen.back() == eos_id) {
+            gen.pop_back();
+        }
+        std::string                   transcript = cm->tok.decode(gen.data(), static_cast<int>(gen.size()));
         transcribe_session::ResultSet rs;
-        rs.full_text = transcript;
+        rs.full_text   = transcript;
         rs.result_kind = TRANSCRIBE_TIMESTAMPS_NONE;
-        rs.has_result = true; rs.status = TRANSCRIBE_OK;
-        transcribe_session::SegmentEntry seg {};
-        seg.text = transcript; seg.t0_ms = 0;
-        seg.t1_ms = static_cast<int64_t>(n_samples[b]) * 1000
-                  / static_cast<int64_t>(hp.fe_sample_rate);
+        rs.has_result  = true;
+        rs.status      = TRANSCRIBE_OK;
+        transcribe_session::SegmentEntry seg{};
+        seg.text  = transcript;
+        seg.t0_ms = 0;
+        seg.t1_ms = static_cast<int64_t>(n_samples[b]) * 1000 / static_cast<int64_t>(hp.fe_sample_rate);
         rs.segments.push_back(std::move(seg));
         // Per-utterance truncation parity with single-shot run(): a row cut at
         // the generation budget / KV window before eos reports
         // TRANSCRIBE_ERR_OUTPUT_TRUNCATED (partial transcript retained). Only
         // override a TRANSCRIBE_OK status, never a worse one.
-        if (b < static_cast<int>(truncated.size()) && truncated[b] &&
-            rs.status == TRANSCRIBE_OK) {
+        if (b < static_cast<int>(truncated.size()) && truncated[b] && rs.status == TRANSCRIBE_OK) {
             cc->was_truncated = true;
-            rs.status = TRANSCRIBE_ERR_OUTPUT_TRUNCATED;
+            rs.status         = TRANSCRIBE_ERR_OUTPUT_TRUNCATED;
         }
-        rs.t_mel_us = mel_us / valid_count;
+        rs.t_mel_us    = mel_us / valid_count;
         rs.t_encode_us = enc_us / valid_count;
         rs.t_decode_us = step_us / valid_count;
         cc->batch_results.push_back(std::move(rs));
@@ -1691,4 +1638,4 @@ extern const Arch arch = {
     /* .accepts_ext_kind = */ nullptr,
 };
 
-} // namespace transcribe::granite
+}  // namespace transcribe::granite
diff --git a/src/arch/granite/projector.cpp b/src/arch/granite/projector.cpp
index 9c997c9c..37d45546 100644
--- a/src/arch/granite/projector.cpp
+++ b/src/arch/granite/projector.cpp
@@ -14,13 +14,11 @@
 
 #include "projector.h"
 
+#include "ggml.h"
 #include "granite.h"
-#include "weights.h"
-
 #include "transcribe-debug.h"
 #include "transcribe-log.h"
-
-#include "ggml.h"
+#include "weights.h"
 
 #include <cmath>
 #include <cstdio>
@@ -43,19 +41,16 @@ ggml_tensor * qformer_layer_norm(ggml_context * ctx,
                                  ggml_tensor *  x,
                                  ggml_tensor *  gamma,
                                  ggml_tensor *  beta,
-                                 float          eps)
-{
+                                 float          eps) {
     ggml_tensor * y = ggml_norm(ctx, x, eps);
-    y = ggml_mul(ctx, y, gamma);
+    y               = ggml_mul(ctx, y, gamma);
     if (beta != nullptr) {
         y = ggml_add(ctx, y, beta);
     }
     return y;
 }
 
-ggml_tensor * linear(ggml_context * ctx, ggml_tensor * x,
-                     ggml_tensor * w, ggml_tensor * b)
-{
+ggml_tensor * linear(ggml_context * ctx, ggml_tensor * x, ggml_tensor * w, ggml_tensor * b) {
     ggml_tensor * y = ggml_mul_mat(ctx, w, x);
     if (b != nullptr) {
         y = ggml_add(ctx, y, b);
@@ -67,25 +62,23 @@ ggml_tensor * linear(ggml_context * ctx, ggml_tensor * x,
 // q, k, v all have ne = [hidden, n_seq, batch]; attention runs per `batch`
 // (= nblocks for cross-attn). head_dim = hidden / n_heads.
 ggml_tensor * qformer_attn(ggml_context * ctx,
-                           ggml_tensor *  q_in,   // [hidden, q_seq, batch]
-                           ggml_tensor *  k_in,   // [hidden, k_seq, batch]
-                           ggml_tensor *  v_in,   // [hidden, k_seq, batch]
+                           ggml_tensor *  q_in,  // [hidden, q_seq, batch]
+                           ggml_tensor *  k_in,  // [hidden, k_seq, batch]
+                           ggml_tensor *  v_in,  // [hidden, k_seq, batch]
                            int            n_heads,
-                           int            head_dim)
-{
+                           int            head_dim) {
     const int64_t hidden = q_in->ne[0];
     const int64_t q_seq  = q_in->ne[1];
     const int64_t k_seq  = k_in->ne[1];
     const int64_t batch  = q_in->ne[2];
     const float   scale  = 1.0f / std::sqrt(static_cast<float>(head_dim));
-    (void)hidden;
+    (void) hidden;
 
     // Reshape into (head_dim, n_heads, seq, batch).
     auto split_heads = [&](ggml_tensor * t, int64_t seq) {
-        ggml_tensor * r = ggml_reshape_4d(ctx, t,
-                                          head_dim, n_heads, seq, batch);
+        ggml_tensor * r = ggml_reshape_4d(ctx, t, head_dim, n_heads, seq, batch);
         // Permute to (head_dim, seq, n_heads, batch): args (0, 2, 1, 3).
-        r = ggml_cont(ctx, ggml_permute(ctx, r, 0, 2, 1, 3));
+        r               = ggml_cont(ctx, ggml_permute(ctx, r, 0, 2, 1, 3));
         return r;
     };
     ggml_tensor * q = split_heads(q_in, q_seq);
@@ -96,7 +89,7 @@ ggml_tensor * qformer_attn(ggml_context * ctx,
     // ggml_mul_mat(k, q) on (head_dim, seq, n_heads, batch) yields
     // (k_seq, q_seq, n_heads, batch).
     ggml_tensor * kq = ggml_mul_mat(ctx, k, q);
-    kq = ggml_scale(ctx, kq, scale);
+    kq               = ggml_scale(ctx, kq, scale);
 
     // Softmax over ne[0] = k_seq.
     ggml_tensor * attn = ggml_soft_max(ctx, kq);
@@ -112,77 +105,74 @@ ggml_tensor * qformer_attn(ggml_context * ctx,
     // n_heads adjacent to head_dim so the reshape interleaves correctly:
     out = ggml_cont(ctx, ggml_permute(ctx, out, 0, 2, 1, 3));
     // out ne = [head_dim, n_heads, q_seq, batch]
-    out = ggml_reshape_3d(ctx, out,
-                          static_cast<int64_t>(head_dim) * n_heads,
-                          q_seq, batch);
+    out = ggml_reshape_3d(ctx, out, static_cast<int64_t>(head_dim) * n_heads, q_seq, batch);
     return out;
 }
 
 // One BLIP-2 Q-Former layer.
 //
 // Granite uses cross_attention_frequency=1 (every layer has cross-attn).
-ggml_tensor * qformer_layer(ggml_context *          ctx,
-                            ggml_tensor *           query,        // [hidden, num_queries, nblocks]
-                            ggml_tensor *           enc_window,   // [hidden_enc, window_size, nblocks]
+ggml_tensor * qformer_layer(ggml_context *           ctx,
+                            ggml_tensor *            query,       // [hidden, num_queries, nblocks]
+                            ggml_tensor *            enc_window,  // [hidden_enc, window_size, nblocks]
                             const GraniteProjBlock & b,
-                            int                     n_heads,
-                            int                     head_dim,
-                            float                   ln_eps)
-{
+                            int                      n_heads,
+                            int                      head_dim,
+                            float                    ln_eps) {
     // -------- Self-attention sublayer --------
     ggml_tensor * sa_in = query;
     ggml_tensor * sa_q  = linear(ctx, sa_in, b.self_attn_q_w, b.self_attn_q_b);
     ggml_tensor * sa_k  = linear(ctx, sa_in, b.self_attn_k_w, b.self_attn_k_b);
     ggml_tensor * sa_v  = linear(ctx, sa_in, b.self_attn_v_w, b.self_attn_v_b);
     ggml_tensor * sa    = qformer_attn(ctx, sa_q, sa_k, sa_v, n_heads, head_dim);
-    sa = linear(ctx, sa, b.self_attn_out_w, b.self_attn_out_b);
-    sa = ggml_add(ctx, sa, sa_in);
-    sa = qformer_layer_norm(ctx, sa, b.norm_self_attn_w, b.norm_self_attn_b, ln_eps);
+    sa                  = linear(ctx, sa, b.self_attn_out_w, b.self_attn_out_b);
+    sa                  = ggml_add(ctx, sa, sa_in);
+    sa                  = qformer_layer_norm(ctx, sa, b.norm_self_attn_w, b.norm_self_attn_b, ln_eps);
 
     // -------- Cross-attention sublayer --------
     ggml_tensor * ca_in = sa;
-    ggml_tensor * ca_q  = linear(ctx, ca_in,      b.cross_attn_q_w, b.cross_attn_q_b);
+    ggml_tensor * ca_q  = linear(ctx, ca_in, b.cross_attn_q_w, b.cross_attn_q_b);
     ggml_tensor * ca_k  = linear(ctx, enc_window, b.cross_attn_k_w, b.cross_attn_k_b);
     ggml_tensor * ca_v  = linear(ctx, enc_window, b.cross_attn_v_w, b.cross_attn_v_b);
     ggml_tensor * ca    = qformer_attn(ctx, ca_q, ca_k, ca_v, n_heads, head_dim);
-    ca = linear(ctx, ca, b.cross_attn_out_w, b.cross_attn_out_b);
-    ca = ggml_add(ctx, ca, ca_in);
-    ca = qformer_layer_norm(ctx, ca, b.norm_cross_attn_w, b.norm_cross_attn_b, ln_eps);
+    ca                  = linear(ctx, ca, b.cross_attn_out_w, b.cross_attn_out_b);
+    ca                  = ggml_add(ctx, ca, ca_in);
+    ca                  = qformer_layer_norm(ctx, ca, b.norm_cross_attn_w, b.norm_cross_attn_b, ln_eps);
 
     // -------- FFN sublayer --------
-    ggml_tensor * ffn_in = ca;
-    ggml_tensor * mid    = linear(ctx, ffn_in, b.ffn_up_w, b.ffn_up_b);
+    ggml_tensor * ffn_in  = ca;
+    ggml_tensor * mid     = linear(ctx, ffn_in, b.ffn_up_w, b.ffn_up_b);
     // PyTorch's `gelu` (the default) is the exact erf form.
-    mid = ggml_gelu_erf(ctx, mid);
+    mid                   = ggml_gelu_erf(ctx, mid);
     ggml_tensor * ffn_out = linear(ctx, mid, b.ffn_down_w, b.ffn_down_b);
-    ffn_out = ggml_add(ctx, ffn_out, ffn_in);
-    ffn_out = qformer_layer_norm(ctx, ffn_out, b.norm_ffn_w, b.norm_ffn_b, ln_eps);
+    ffn_out               = ggml_add(ctx, ffn_out, ffn_in);
+    ffn_out               = qformer_layer_norm(ctx, ffn_out, b.norm_ffn_w, b.norm_ffn_b, ln_eps);
 
     return ffn_out;
 }
 
-} // namespace
+}  // namespace
 
 ProjectorBuild build_projector_graph(ggml_context *         ctx,
                                      const GraniteWeights & weights,
                                      const GraniteHParams & hp,
-                                     int                    T_enc)
-{
-    ProjectorBuild pb {};
-
-    const int     window_size    = hp.window_size;            // 15
-    const int     downsample     = hp.downsample_rate;        // 5
-    const int     num_queries    = window_size / downsample;  // 3
-    const int     n_heads        = hp.prj_n_heads;            // 16
-    const int     prj_hidden     = hp.prj_hidden;             // 1024
-    const int     enc_hidden     = hp.prj_encoder_hidden_size; // 1024 or 2048 (-plus)
-    (void)hp.dec_hidden;             // text_hidden = 2048; consumed via proj.linear shape.
-    const float   ln_eps         = hp.prj_layer_norm_eps;     // 1e-12
+                                     int                    T_enc) {
+    ProjectorBuild pb{};
+
+    const int window_size = hp.window_size;              // 15
+    const int downsample  = hp.downsample_rate;          // 5
+    const int num_queries = window_size / downsample;    // 3
+    const int n_heads     = hp.prj_n_heads;              // 16
+    const int prj_hidden  = hp.prj_hidden;               // 1024
+    const int enc_hidden  = hp.prj_encoder_hidden_size;  // 1024 or 2048 (-plus)
+    (void) hp.dec_hidden;                                // text_hidden = 2048; consumed via proj.linear shape.
+    const float ln_eps = hp.prj_layer_norm_eps;          // 1e-12
 
     if (prj_hidden % n_heads != 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "granite projector: prj_hidden (%d) not divisible by "
-                     "n_heads (%d)", prj_hidden, n_heads);
+                "granite projector: prj_hidden (%d) not divisible by "
+                "n_heads (%d)",
+                prj_hidden, n_heads);
         return pb;
     }
     const int head_dim = prj_hidden / n_heads;  // 64
@@ -198,8 +188,7 @@ ProjectorBuild build_projector_graph(ggml_context *         ctx,
     ggml_set_input(pb.enc_in);
 
     if (pb.t_enc_pad > 0) {
-        pb.enc_pad = ggml_new_tensor_2d(ctx, GGML_TYPE_F32,
-                                        enc_hidden, pb.t_enc_pad);
+        pb.enc_pad = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, enc_hidden, pb.t_enc_pad);
         named(pb.enc_pad, "proj.enc_pad");
         ggml_set_input(pb.enc_pad);
     }
@@ -216,9 +205,7 @@ ProjectorBuild build_projector_graph(ggml_context *         ctx,
     // pos_in_window = i % window_size). The ggml reshape with
     // (hidden_enc, window_size, nblocks) gives ne[1] = window_size as
     // the faster axis, exactly matching this layout.
-    ggml_tensor * enc_window = ggml_reshape_3d(ctx, enc_full,
-                                               enc_hidden, window_size,
-                                               pb.nblocks);
+    ggml_tensor * enc_window = ggml_reshape_3d(ctx, enc_full, enc_hidden, window_size, pb.nblocks);
 
     // Build query tensor.
     // weights.proj_top.query is stored at the GGUF's reference dtype
@@ -234,22 +221,17 @@ ProjectorBuild build_projector_graph(ggml_context *         ctx,
     //   embedding_output = self.layernorm(query_embeds)
     // Applying it after the layers instead silently corrupts the output —
     // the layers would operate on unnormalised queries.
-    query = qformer_layer_norm(ctx, query,
-                               weights.proj_top.qformer_final_norm_w,
-                               weights.proj_top.qformer_final_norm_b,
+    query = qformer_layer_norm(ctx, query, weights.proj_top.qformer_final_norm_w, weights.proj_top.qformer_final_norm_b,
                                ln_eps);
 
     // Broadcast (hidden, num_queries, 1, 1) → (hidden, num_queries, nblocks, 1).
-    query = ggml_repeat_4d(ctx, query,
-                           prj_hidden, num_queries, pb.nblocks, 1);
+    query = ggml_repeat_4d(ctx, query, prj_hidden, num_queries, pb.nblocks, 1);
     // ggml_repeat_4d emits a fresh contiguous tensor; we can pass it
     // directly into subsequent ops.
 
     // Q-Former layers.
     for (int i = 0; i < hp.prj_n_layers; ++i) {
-        query = qformer_layer(ctx, query, enc_window,
-                              weights.proj_blocks[i],
-                              n_heads, head_dim, ln_eps);
+        query = qformer_layer(ctx, query, enc_window, weights.proj_blocks[i], n_heads, head_dim, ln_eps);
     }
 
     // proj.qformer.out = Blip2QFormerModel.last_hidden_state, the encoder
@@ -267,16 +249,14 @@ ProjectorBuild build_projector_graph(ggml_context *         ctx,
     //   flat_idx = block_idx * num_queries + query_idx
     // because num_queries is faster than nblocks. Exactly matches the
     // upstream order.
-    ggml_tensor * tokens = ggml_reshape_2d(ctx, query,
-                                           prj_hidden,
-                                           static_cast<int64_t>(num_queries) * pb.nblocks);
+    ggml_tensor * tokens = ggml_reshape_2d(ctx, query, prj_hidden, static_cast<int64_t>(num_queries) * pb.nblocks);
 
     // Linear lift to text_hidden.
     ggml_tensor * out = ggml_mul_mat(ctx, weights.proj_top.linear_w, tokens);
-    out = ggml_add(ctx, out, weights.proj_top.linear_b);
+    out               = ggml_add(ctx, out, weights.proj_top.linear_b);
     named(out, "proj.out");
-    pb.out               = out;
-    pb.dumps.proj_out    = out;
+    pb.out            = out;
+    pb.dumps.proj_out = out;
     ggml_set_output(out);
     transcribe::debug::mark_tensor_for_dump(out);
 
@@ -297,4 +277,4 @@ ProjectorBuild build_projector_graph(ggml_context *         ctx,
     return pb;
 }
 
-} // namespace transcribe::granite
+}  // namespace transcribe::granite
diff --git a/src/arch/granite/projector.h b/src/arch/granite/projector.h
index a73b9ee5..c5a419f6 100644
--- a/src/arch/granite/projector.h
+++ b/src/arch/granite/projector.h
@@ -6,9 +6,8 @@
 
 #pragma once
 
-#include "weights.h"
-
 #include "ggml.h"
+#include "weights.h"
 
 #include <cstdint>
 #include <vector>
@@ -21,13 +20,13 @@ namespace transcribe::granite {
 
 struct ProjectorBuild {
     // Graph inputs.
-    ggml_tensor * enc_in    = nullptr;  // [hidden_enc, T_enc]
-    ggml_tensor * enc_pad   = nullptr;  // [hidden_enc, pad_n], or nullptr
-                                        // when T_enc is aligned to
-                                        // window_size
+    ggml_tensor * enc_in  = nullptr;  // [hidden_enc, T_enc]
+    ggml_tensor * enc_pad = nullptr;  // [hidden_enc, pad_n], or nullptr
+                                      // when T_enc is aligned to
+                                      // window_size
 
     // Graph output.
-    ggml_tensor * out       = nullptr;  // [text_hidden, n_audio_tokens]
+    ggml_tensor * out = nullptr;  // [text_hidden, n_audio_tokens]
 
     // Dump points.
     struct {
@@ -35,11 +34,11 @@ struct ProjectorBuild {
         ggml_tensor * proj_out    = nullptr;  // == out, named "proj.out"
     } dumps;
 
-    ggml_cgraph * graph        = nullptr;
+    ggml_cgraph * graph = nullptr;
 
-    int nblocks                = 0;
-    int n_audio_tokens         = 0;
-    int t_enc_pad              = 0;   // pad_n = nblocks * window_size - T_enc
+    int nblocks        = 0;
+    int n_audio_tokens = 0;
+    int t_enc_pad      = 0;  // pad_n = nblocks * window_size - T_enc
 };
 
 ProjectorBuild build_projector_graph(ggml_context *         ctx,
@@ -47,4 +46,4 @@ ProjectorBuild build_projector_graph(ggml_context *         ctx,
                                      const GraniteHParams & hp,
                                      int                    T_enc);
 
-} // namespace transcribe::granite
+}  // namespace transcribe::granite
diff --git a/src/arch/granite/weights.cpp b/src/arch/granite/weights.cpp
index 4557e216..b38c583a 100644
--- a/src/arch/granite/weights.cpp
+++ b/src/arch/granite/weights.cpp
@@ -7,12 +7,11 @@
 
 #include "weights.h"
 
-#include "transcribe-meta.h"
-#include "transcribe-weights-util.h"
-#include "transcribe-log.h"
-
 #include "ggml.h"
 #include "gguf.h"
+#include "transcribe-log.h"
+#include "transcribe-meta.h"
+#include "transcribe-weights-util.h"
 
 #include <cstdio>
 
@@ -22,30 +21,63 @@ namespace {
 constexpr const char * kFamilyTag = "granite";
 }
 
-transcribe_status read_granite_hparams(const gguf_context * gguf,
-                                       GraniteHParams &     hp)
-{
+transcribe_status read_granite_hparams(const gguf_context * gguf, GraniteHParams & hp) {
     if (gguf == nullptr) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
 
     // Identity.
-    if (auto st = read_optional_string_kv(
-            gguf, "stt.variant", kFamilyTag, "", hp.variant);
-        st != TRANSCRIBE_OK) return st;
+    if (auto st = read_optional_string_kv(gguf, "stt.variant", kFamilyTag, "", hp.variant); st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Encoder (Conformer).
-    if (auto st = read_required_u32_kv(gguf, "stt.granite.encoder.n_layers", kFamilyTag, hp.enc_n_layers); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.granite.encoder.hidden", kFamilyTag, hp.enc_hidden); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.granite.encoder.n_heads", kFamilyTag, hp.enc_n_heads); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.granite.encoder.head_dim", kFamilyTag, hp.enc_head_dim); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.granite.encoder.input_dim", kFamilyTag, hp.enc_input_dim); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.granite.encoder.output_dim", kFamilyTag, hp.enc_output_dim); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.granite.encoder.feedforward_mult", kFamilyTag, hp.enc_feedforward_mult); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.granite.encoder.conv_kernel_size", kFamilyTag, hp.enc_conv_kernel_size); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.granite.encoder.conv_expansion", kFamilyTag, hp.enc_conv_expansion); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.granite.encoder.max_pos_emb", kFamilyTag, hp.enc_max_pos_emb); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.granite.encoder.context_size", kFamilyTag, hp.enc_context_size); st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_u32_kv(gguf, "stt.granite.encoder.n_layers", kFamilyTag, hp.enc_n_layers);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.granite.encoder.hidden", kFamilyTag, hp.enc_hidden);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.granite.encoder.n_heads", kFamilyTag, hp.enc_n_heads);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.granite.encoder.head_dim", kFamilyTag, hp.enc_head_dim);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.granite.encoder.input_dim", kFamilyTag, hp.enc_input_dim);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.granite.encoder.output_dim", kFamilyTag, hp.enc_output_dim);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st =
+            read_required_u32_kv(gguf, "stt.granite.encoder.feedforward_mult", kFamilyTag, hp.enc_feedforward_mult);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st =
+            read_required_u32_kv(gguf, "stt.granite.encoder.conv_kernel_size", kFamilyTag, hp.enc_conv_kernel_size);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.granite.encoder.conv_expansion", kFamilyTag, hp.enc_conv_expansion);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.granite.encoder.max_pos_emb", kFamilyTag, hp.enc_max_pos_emb);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.granite.encoder.context_size", kFamilyTag, hp.enc_context_size);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // cat_hidden_layers is an optional array. Absent or empty array both
     // mean "no concat". Converter writes the uint32 array via gguf-py;
@@ -54,180 +86,306 @@ transcribe_status read_granite_hparams(const gguf_context * gguf,
     {
         std::vector<int32_t> tmp;
         switch (read_int32_array_kv(gguf, "stt.granite.encoder.cat_hidden_layers", tmp)) {
-            case KvResult::Ok:      hp.enc_cat_hidden_layers = std::move(tmp); break;
-            case KvResult::Absent:  hp.enc_cat_hidden_layers.clear();          break;
+            case KvResult::Ok:
+                hp.enc_cat_hidden_layers = std::move(tmp);
+                break;
+            case KvResult::Absent:
+                hp.enc_cat_hidden_layers.clear();
+                break;
             case KvResult::BadType:
-                log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                             "granite: stt.granite.encoder.cat_hidden_layers has wrong type");
+                log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "granite: stt.granite.encoder.cat_hidden_layers has wrong type");
                 return TRANSCRIBE_ERR_GGUF;
         }
     }
 
     // Projector (BLIP-2 Q-Former).
-    if (auto st = read_required_u32_kv(gguf, "stt.granite.projector.n_layers", kFamilyTag, hp.prj_n_layers); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.granite.projector.hidden", kFamilyTag, hp.prj_hidden); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.granite.projector.intermediate", kFamilyTag, hp.prj_intermediate); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.granite.projector.n_heads", kFamilyTag, hp.prj_n_heads); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.granite.projector.encoder_hidden_size", kFamilyTag, hp.prj_encoder_hidden_size); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.granite.projector.cross_attn_frequency", kFamilyTag, hp.prj_cross_attn_freq); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.granite.projector.hidden_act", kFamilyTag, hp.prj_hidden_act); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf, "stt.granite.projector.layer_norm_eps", kFamilyTag, hp.prj_layer_norm_eps); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.granite.projector.max_pos_emb", kFamilyTag, hp.prj_max_pos_emb); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.granite.projector.position_embedding_type", kFamilyTag, hp.prj_pos_embed_type); st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_u32_kv(gguf, "stt.granite.projector.n_layers", kFamilyTag, hp.prj_n_layers);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.granite.projector.hidden", kFamilyTag, hp.prj_hidden);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.granite.projector.intermediate", kFamilyTag, hp.prj_intermediate);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.granite.projector.n_heads", kFamilyTag, hp.prj_n_heads);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.granite.projector.encoder_hidden_size", kFamilyTag,
+                                       hp.prj_encoder_hidden_size);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.granite.projector.cross_attn_frequency", kFamilyTag,
+                                       hp.prj_cross_attn_freq);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_string_kv(gguf, "stt.granite.projector.hidden_act", kFamilyTag, hp.prj_hidden_act);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.granite.projector.layer_norm_eps", kFamilyTag, hp.prj_layer_norm_eps);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.granite.projector.max_pos_emb", kFamilyTag, hp.prj_max_pos_emb);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_string_kv(gguf, "stt.granite.projector.position_embedding_type", kFamilyTag,
+                                          hp.prj_pos_embed_type);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Text LM (Granite-4).
-    if (auto st = read_required_u32_kv(gguf, "stt.granite.decoder.n_layers", kFamilyTag, hp.dec_n_layers); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.granite.decoder.hidden_size", kFamilyTag, hp.dec_hidden); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.granite.decoder.intermediate_size", kFamilyTag, hp.dec_intermediate); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.granite.decoder.n_heads", kFamilyTag, hp.dec_n_heads); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.granite.decoder.n_kv_heads", kFamilyTag, hp.dec_n_kv_heads); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.granite.decoder.head_dim", kFamilyTag, hp.dec_head_dim); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.granite.decoder.hidden_act", kFamilyTag, hp.dec_hidden_act); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf, "stt.granite.decoder.rms_norm_eps", kFamilyTag, hp.dec_rms_norm_eps); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf, "stt.granite.decoder.rope_theta", kFamilyTag, hp.dec_rope_theta); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.granite.decoder.max_position_embeddings", kFamilyTag, hp.dec_max_position_embeddings); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_bool_kv(gguf, "stt.granite.decoder.tie_word_embeddings", kFamilyTag, false, hp.dec_tie_word_embeddings); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.granite.decoder.vocab_size", kFamilyTag, hp.dec_vocab_size); st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_u32_kv(gguf, "stt.granite.decoder.n_layers", kFamilyTag, hp.dec_n_layers);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.granite.decoder.hidden_size", kFamilyTag, hp.dec_hidden);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.granite.decoder.intermediate_size", kFamilyTag, hp.dec_intermediate);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.granite.decoder.n_heads", kFamilyTag, hp.dec_n_heads);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.granite.decoder.n_kv_heads", kFamilyTag, hp.dec_n_kv_heads);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.granite.decoder.head_dim", kFamilyTag, hp.dec_head_dim);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_string_kv(gguf, "stt.granite.decoder.hidden_act", kFamilyTag, hp.dec_hidden_act);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.granite.decoder.rms_norm_eps", kFamilyTag, hp.dec_rms_norm_eps);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.granite.decoder.rope_theta", kFamilyTag, hp.dec_rope_theta);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.granite.decoder.max_position_embeddings", kFamilyTag,
+                                       hp.dec_max_position_embeddings);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_bool_kv(gguf, "stt.granite.decoder.tie_word_embeddings", kFamilyTag, false,
+                                        hp.dec_tie_word_embeddings);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.granite.decoder.vocab_size", kFamilyTag, hp.dec_vocab_size);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Granite-4 scalar multipliers. All four are required — missing any
     // of them silently degrades accuracy without crashing.
-    if (auto st = read_required_f32_kv(gguf, "stt.granite.decoder.embedding_multiplier", kFamilyTag, hp.dec_embedding_multiplier); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf, "stt.granite.decoder.logits_scaling", kFamilyTag, hp.dec_logits_scaling); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf, "stt.granite.decoder.attention_multiplier", kFamilyTag, hp.dec_attention_multiplier); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf, "stt.granite.decoder.residual_multiplier", kFamilyTag, hp.dec_residual_multiplier); st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_f32_kv(gguf, "stt.granite.decoder.embedding_multiplier", kFamilyTag,
+                                       hp.dec_embedding_multiplier);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.granite.decoder.logits_scaling", kFamilyTag, hp.dec_logits_scaling);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.granite.decoder.attention_multiplier", kFamilyTag,
+                                       hp.dec_attention_multiplier);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.granite.decoder.residual_multiplier", kFamilyTag,
+                                       hp.dec_residual_multiplier);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Audio fusion.
-    if (auto st = read_required_u32_kv(gguf, "stt.granite.audio_token_id", kFamilyTag, hp.audio_token_id); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.granite.downsample_rate", kFamilyTag, hp.downsample_rate); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.granite.window_size", kFamilyTag, hp.window_size); st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_u32_kv(gguf, "stt.granite.audio_token_id", kFamilyTag, hp.audio_token_id);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.granite.downsample_rate", kFamilyTag, hp.downsample_rate);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.granite.window_size", kFamilyTag, hp.window_size);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Frontend (torchaudio MelSpectrogram).
-    if (auto st = read_required_string_kv(gguf, "stt.frontend.type", kFamilyTag, hp.fe_type); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.frontend.num_mels", kFamilyTag, hp.fe_num_mels); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.frontend.sample_rate", kFamilyTag, hp.fe_sample_rate); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.frontend.n_fft", kFamilyTag, hp.fe_n_fft); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.frontend.win_length", kFamilyTag, hp.fe_win_length); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.frontend.hop_length", kFamilyTag, hp.fe_hop_length); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.frontend.window", kFamilyTag, hp.fe_window); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.frontend.normalize", kFamilyTag, hp.fe_normalize); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf, "stt.frontend.dither", kFamilyTag, hp.fe_dither); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf, "stt.frontend.pre_emphasis", kFamilyTag, hp.fe_pre_emphasis); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf, "stt.frontend.f_min", kFamilyTag, hp.fe_f_min); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf, "stt.frontend.f_max", kFamilyTag, hp.fe_f_max); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_string_kv(gguf, "stt.frontend.pad_mode", kFamilyTag, "reflect", hp.fe_pad_mode); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_string_kv(gguf, "stt.frontend.mel_norm", kFamilyTag, "htk", hp.fe_mel_norm); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_bool_kv(gguf, "stt.frontend.center", kFamilyTag, true, hp.fe_center); st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_string_kv(gguf, "stt.frontend.type", kFamilyTag, hp.fe_type); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.num_mels", kFamilyTag, hp.fe_num_mels);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.sample_rate", kFamilyTag, hp.fe_sample_rate);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.n_fft", kFamilyTag, hp.fe_n_fft); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.win_length", kFamilyTag, hp.fe_win_length);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.hop_length", kFamilyTag, hp.fe_hop_length);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_string_kv(gguf, "stt.frontend.window", kFamilyTag, hp.fe_window); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_string_kv(gguf, "stt.frontend.normalize", kFamilyTag, hp.fe_normalize);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.frontend.dither", kFamilyTag, hp.fe_dither); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.frontend.pre_emphasis", kFamilyTag, hp.fe_pre_emphasis);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.frontend.f_min", kFamilyTag, hp.fe_f_min); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.frontend.f_max", kFamilyTag, hp.fe_f_max); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_string_kv(gguf, "stt.frontend.pad_mode", kFamilyTag, "reflect", hp.fe_pad_mode);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_string_kv(gguf, "stt.frontend.mel_norm", kFamilyTag, "htk", hp.fe_mel_norm);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_bool_kv(gguf, "stt.frontend.center", kFamilyTag, true, hp.fe_center);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Cross-field invariants.
-    if (hp.enc_n_layers <= 0 || hp.enc_hidden <= 0 || hp.enc_n_heads <= 0 ||
-        hp.enc_head_dim <= 0 || hp.enc_input_dim <= 0 || hp.enc_output_dim <= 0 ||
-        hp.enc_feedforward_mult <= 0 || hp.enc_conv_kernel_size <= 0 ||
-        hp.enc_conv_expansion <= 0 || hp.enc_max_pos_emb <= 0 ||
-        hp.enc_context_size <= 0)
-    {
+    if (hp.enc_n_layers <= 0 || hp.enc_hidden <= 0 || hp.enc_n_heads <= 0 || hp.enc_head_dim <= 0 ||
+        hp.enc_input_dim <= 0 || hp.enc_output_dim <= 0 || hp.enc_feedforward_mult <= 0 ||
+        hp.enc_conv_kernel_size <= 0 || hp.enc_conv_expansion <= 0 || hp.enc_max_pos_emb <= 0 ||
+        hp.enc_context_size <= 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "granite: encoder hparams must be positive");
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.enc_n_heads * hp.enc_head_dim != hp.enc_hidden) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "granite: encoder n_heads * head_dim (%d * %d) "
-                     "!= hidden (%d)",
-                     hp.enc_n_heads, hp.enc_head_dim, hp.enc_hidden);
+                "granite: encoder n_heads * head_dim (%d * %d) "
+                "!= hidden (%d)",
+                hp.enc_n_heads, hp.enc_head_dim, hp.enc_hidden);
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.enc_context_size > hp.enc_max_pos_emb) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "granite: context_size (%d) > max_pos_emb (%d)",
-                     hp.enc_context_size, hp.enc_max_pos_emb);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "granite: context_size (%d) > max_pos_emb (%d)", hp.enc_context_size,
+                hp.enc_max_pos_emb);
         return TRANSCRIBE_ERR_GGUF;
     }
     // cat_hidden_layers entries must reference real layers and the
     // expanded projector input dim must match prj_encoder_hidden_size.
     {
-        const int32_t expected_kv_dim = hp.enc_hidden *
-            (static_cast<int32_t>(hp.enc_cat_hidden_layers.size()) + 1);
+        const int32_t expected_kv_dim = hp.enc_hidden * (static_cast<int32_t>(hp.enc_cat_hidden_layers.size()) + 1);
         if (expected_kv_dim != hp.prj_encoder_hidden_size) {
             log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "granite: prj.encoder_hidden_size (%d) does not match "
-                         "hidden*(1+|cat_hidden_layers|) = %d * (1 + %d) = %d",
-                         hp.prj_encoder_hidden_size, hp.enc_hidden,
-                         static_cast<int>(hp.enc_cat_hidden_layers.size()),
-                         expected_kv_dim);
+                    "granite: prj.encoder_hidden_size (%d) does not match "
+                    "hidden*(1+|cat_hidden_layers|) = %d * (1 + %d) = %d",
+                    hp.prj_encoder_hidden_size, hp.enc_hidden, static_cast<int>(hp.enc_cat_hidden_layers.size()),
+                    expected_kv_dim);
             return TRANSCRIBE_ERR_GGUF;
         }
         for (int32_t idx : hp.enc_cat_hidden_layers) {
             if (idx < 0 || idx >= hp.enc_n_layers) {
                 log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                             "granite: cat_hidden_layers entry %d out of range "
-                             "[0, %d)", idx, hp.enc_n_layers);
+                        "granite: cat_hidden_layers entry %d out of range "
+                        "[0, %d)",
+                        idx, hp.enc_n_layers);
                 return TRANSCRIBE_ERR_GGUF;
             }
         }
     }
-    if (hp.prj_n_layers <= 0 || hp.prj_hidden <= 0 ||
-        hp.prj_intermediate <= 0 || hp.prj_n_heads <= 0 ||
-        hp.prj_encoder_hidden_size <= 0)
-    {
+    if (hp.prj_n_layers <= 0 || hp.prj_hidden <= 0 || hp.prj_intermediate <= 0 || hp.prj_n_heads <= 0 ||
+        hp.prj_encoder_hidden_size <= 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "granite: projector hparams must be positive");
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.prj_hidden % hp.prj_n_heads != 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "granite: projector hidden (%d) not divisible by n_heads (%d)",
-                     hp.prj_hidden, hp.prj_n_heads);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "granite: projector hidden (%d) not divisible by n_heads (%d)",
+                hp.prj_hidden, hp.prj_n_heads);
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.prj_hidden_act != "gelu") {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "granite: unsupported projector hidden_act \"%s\" "
-                     "(only gelu)", hp.prj_hidden_act.c_str());
+                "granite: unsupported projector hidden_act \"%s\" "
+                "(only gelu)",
+                hp.prj_hidden_act.c_str());
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.prj_pos_embed_type != "absolute") {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "granite: unsupported projector position_embedding_type "
-                     "\"%s\" (only absolute)", hp.prj_pos_embed_type.c_str());
+                "granite: unsupported projector position_embedding_type "
+                "\"%s\" (only absolute)",
+                hp.prj_pos_embed_type.c_str());
         return TRANSCRIBE_ERR_GGUF;
     }
-    if (hp.dec_n_layers <= 0 || hp.dec_hidden <= 0 || hp.dec_n_heads <= 0 ||
-        hp.dec_n_kv_heads <= 0 || hp.dec_head_dim <= 0 || hp.dec_intermediate <= 0)
-    {
+    if (hp.dec_n_layers <= 0 || hp.dec_hidden <= 0 || hp.dec_n_heads <= 0 || hp.dec_n_kv_heads <= 0 ||
+        hp.dec_head_dim <= 0 || hp.dec_intermediate <= 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "granite: decoder hparams must be positive");
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.dec_n_heads % hp.dec_n_kv_heads != 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "granite: dec n_heads (%d) not divisible by n_kv_heads (%d)",
-                     hp.dec_n_heads, hp.dec_n_kv_heads);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "granite: dec n_heads (%d) not divisible by n_kv_heads (%d)",
+                hp.dec_n_heads, hp.dec_n_kv_heads);
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.dec_n_heads * hp.dec_head_dim != hp.dec_hidden) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "granite: dec n_heads * head_dim (%d * %d) != hidden (%d)",
-                     hp.dec_n_heads, hp.dec_head_dim, hp.dec_hidden);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "granite: dec n_heads * head_dim (%d * %d) != hidden (%d)", hp.dec_n_heads,
+                hp.dec_head_dim, hp.dec_hidden);
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.dec_hidden_act != "silu" && hp.dec_hidden_act != "swish") {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "granite: unsupported decoder hidden_act \"%s\" "
-                     "(only silu/swish)", hp.dec_hidden_act.c_str());
+                "granite: unsupported decoder hidden_act \"%s\" "
+                "(only silu/swish)",
+                hp.dec_hidden_act.c_str());
         return TRANSCRIBE_ERR_GGUF;
     }
-    if (hp.dec_embedding_multiplier <= 0.0f ||
-        hp.dec_logits_scaling       <= 0.0f ||
-        hp.dec_attention_multiplier <= 0.0f ||
-        hp.dec_residual_multiplier  <= 0.0f)
-    {
+    if (hp.dec_embedding_multiplier <= 0.0f || hp.dec_logits_scaling <= 0.0f || hp.dec_attention_multiplier <= 0.0f ||
+        hp.dec_residual_multiplier <= 0.0f) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "granite: decoder multipliers must be > 0 "
-                     "(emb=%g, logits=%g, attn=%g, residual=%g)",
-                     hp.dec_embedding_multiplier, hp.dec_logits_scaling,
-                     hp.dec_attention_multiplier, hp.dec_residual_multiplier);
+                "granite: decoder multipliers must be > 0 "
+                "(emb=%g, logits=%g, attn=%g, residual=%g)",
+                hp.dec_embedding_multiplier, hp.dec_logits_scaling, hp.dec_attention_multiplier,
+                hp.dec_residual_multiplier);
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.fe_type != "mel") {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "granite: unsupported frontend type \"%s\"",
-                     hp.fe_type.c_str());
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "granite: unsupported frontend type \"%s\"", hp.fe_type.c_str());
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.fe_normalize != "per_utterance") {
@@ -236,14 +394,16 @@ transcribe_status read_granite_hparams(const gguf_context * gguf,
         // produces a bit-identical result under "per_utterance" mode.
         // Other modes would mean the converter changed; fail loudly.
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "granite: unsupported frontend normalize \"%s\" "
-                     "(only \"per_utterance\")", hp.fe_normalize.c_str());
+                "granite: unsupported frontend normalize \"%s\" "
+                "(only \"per_utterance\")",
+                hp.fe_normalize.c_str());
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.fe_mel_norm != "htk") {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "granite: unsupported frontend mel_norm \"%s\" "
-                     "(only \"htk\")", hp.fe_mel_norm.c_str());
+                "granite: unsupported frontend mel_norm \"%s\" "
+                "(only \"htk\")",
+                hp.fe_mel_norm.c_str());
         return TRANSCRIBE_ERR_GGUF;
     }
     // Audio injection precondition: projector lifts to LM hidden, so
@@ -260,41 +420,36 @@ namespace {
 using transcribe::weights::lname;
 constexpr const char * kTag = kFamilyTag;
 
-#define GET_F32(slot, name, ...) \
-    do { \
-        ggml_tensor * _t = transcribe::weights::find_tensor( \
-            ctx_meta, (name), \
-            {GGML_TYPE_F32}, {__VA_ARGS__}, kTag); \
-        if (_t == nullptr) return TRANSCRIBE_ERR_GGUF; \
-        (slot) = _t; \
+#define GET_F32(slot, name, ...)                                                                          \
+    do {                                                                                                  \
+        ggml_tensor * _t =                                                                                \
+            transcribe::weights::find_tensor(ctx_meta, (name), { GGML_TYPE_F32 }, { __VA_ARGS__ }, kTag); \
+        if (_t == nullptr)                                                                                \
+            return TRANSCRIBE_ERR_GGUF;                                                                   \
+        (slot) = _t;                                                                                      \
     } while (0)
 
-#define GET_CONV(slot, name, ...) \
-    do { \
-        ggml_tensor * _t = transcribe::weights::find_tensor( \
-            ctx_meta, (name), \
-            {TRANSCRIBE_QUANT_CONV_TYPES}, \
-            {__VA_ARGS__}, kTag); \
-        if (_t == nullptr) return TRANSCRIBE_ERR_GGUF; \
-        (slot) = _t; \
+#define GET_CONV(slot, name, ...)                                                                              \
+    do {                                                                                                       \
+        ggml_tensor * _t = transcribe::weights::find_tensor(ctx_meta, (name), { TRANSCRIBE_QUANT_CONV_TYPES }, \
+                                                            { __VA_ARGS__ }, kTag);                            \
+        if (_t == nullptr)                                                                                     \
+            return TRANSCRIBE_ERR_GGUF;                                                                        \
+        (slot) = _t;                                                                                           \
     } while (0)
 
-#define GET_LIN(slot, name, ...) \
-    do { \
-        ggml_tensor * _t = transcribe::weights::find_tensor( \
-            ctx_meta, (name), \
-            {TRANSCRIBE_QUANT_LINEAR_TYPES}, \
-            {__VA_ARGS__}, kTag); \
-        if (_t == nullptr) return TRANSCRIBE_ERR_GGUF; \
-        (slot) = _t; \
+#define GET_LIN(slot, name, ...)                                                                                 \
+    do {                                                                                                         \
+        ggml_tensor * _t = transcribe::weights::find_tensor(ctx_meta, (name), { TRANSCRIBE_QUANT_LINEAR_TYPES }, \
+                                                            { __VA_ARGS__ }, kTag);                              \
+        if (_t == nullptr)                                                                                       \
+            return TRANSCRIBE_ERR_GGUF;                                                                          \
+        (slot) = _t;                                                                                             \
     } while (0)
 
-} // namespace
+}  // namespace
 
-transcribe_status build_granite_weights(ggml_context *         ctx_meta,
-                                        const GraniteHParams & hp,
-                                        GraniteWeights &       weights)
-{
+transcribe_status build_granite_weights(ggml_context * ctx_meta, const GraniteHParams & hp, GraniteWeights & weights) {
     if (ctx_meta == nullptr) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
@@ -305,16 +460,16 @@ transcribe_status build_granite_weights(ggml_context *         ctx_meta,
     const int64_t enc_out      = hp.enc_output_dim;
     const int64_t enc_n_heads  = hp.enc_n_heads;
     const int64_t enc_head_dim = hp.enc_head_dim;
-    const int64_t enc_inner    = enc_n_heads * enc_head_dim;   // typically == enc_h
+    const int64_t enc_inner    = enc_n_heads * enc_head_dim;  // typically == enc_h
     const int64_t enc_ffn      = enc_h * hp.enc_feedforward_mult;
     const int64_t conv_inner   = enc_h * hp.enc_conv_expansion;
-    const int64_t conv_up_out  = conv_inner * 2;               // pre-GLU
+    const int64_t conv_up_out  = conv_inner * 2;  // pre-GLU
     const int64_t conv_k       = hp.enc_conv_kernel_size;
     const int64_t rel_pos_len  = 2 * hp.enc_max_pos_emb + 1;
 
     const int64_t prj_h        = hp.prj_hidden;
     const int64_t prj_im       = hp.prj_intermediate;
-    const int64_t prj_kv_in    = hp.prj_encoder_hidden_size;   // 1024 or 2048
+    const int64_t prj_kv_in    = hp.prj_encoder_hidden_size;  // 1024 or 2048
     const int64_t prj_n_layers = hp.prj_n_layers;
     // num_queries (3 on granite) is not in KV — it's the ne[1] of the
     // query tensor. Read it implicitly via find_tensor's ne[] match.
@@ -325,16 +480,16 @@ transcribe_status build_granite_weights(ggml_context *         ctx_meta,
     const int64_t dec_nkv   = hp.dec_n_kv_heads;
     const int64_t dec_hd    = hp.dec_head_dim;
     const int64_t dec_im    = hp.dec_intermediate;
-    const int64_t q_out     = dec_nh  * dec_hd;
+    const int64_t q_out     = dec_nh * dec_hd;
     const int64_t kv_out    = dec_nkv * dec_hd;
 
     // Encoder: top-level.
-    GET_LIN(weights.enc_top.input_linear_w, "enc.input_linear.weight", enc_in,  enc_h);
-    GET_F32(weights.enc_top.input_linear_b, "enc.input_linear.bias",   enc_h);
-    GET_LIN(weights.enc_top.ctc_proj_w,     "enc.ctc_proj.weight",     enc_h,   enc_out);
-    GET_F32(weights.enc_top.ctc_proj_b,     "enc.ctc_proj.bias",       enc_out);
-    GET_LIN(weights.enc_top.ctc_bypass_w,   "enc.ctc_bypass.weight",   enc_out, enc_h);
-    GET_F32(weights.enc_top.ctc_bypass_b,   "enc.ctc_bypass.bias",     enc_h);
+    GET_LIN(weights.enc_top.input_linear_w, "enc.input_linear.weight", enc_in, enc_h);
+    GET_F32(weights.enc_top.input_linear_b, "enc.input_linear.bias", enc_h);
+    GET_LIN(weights.enc_top.ctc_proj_w, "enc.ctc_proj.weight", enc_h, enc_out);
+    GET_F32(weights.enc_top.ctc_proj_b, "enc.ctc_proj.bias", enc_out);
+    GET_LIN(weights.enc_top.ctc_bypass_w, "enc.ctc_bypass.weight", enc_out, enc_h);
+    GET_F32(weights.enc_top.ctc_bypass_b, "enc.ctc_bypass.bias", enc_h);
 
     // Encoder: per-block.
     weights.enc_blocks.assign(hp.enc_n_layers, GraniteEncBlock{});
@@ -343,61 +498,55 @@ transcribe_status build_granite_weights(ggml_context *         ctx_meta,
 
         // FF1 (macaron half).
         GET_F32(b.norm_ff1_w, lname("enc.blocks.%d.norm_ff1.weight", i), enc_h);
-        GET_F32(b.norm_ff1_b, lname("enc.blocks.%d.norm_ff1.bias",   i), enc_h);
-        GET_LIN(b.ff1_up_w,   lname("enc.blocks.%d.ff1.up.weight",   i), enc_h,   enc_ffn);
-        GET_F32(b.ff1_up_b,   lname("enc.blocks.%d.ff1.up.bias",     i), enc_ffn);
+        GET_F32(b.norm_ff1_b, lname("enc.blocks.%d.norm_ff1.bias", i), enc_h);
+        GET_LIN(b.ff1_up_w, lname("enc.blocks.%d.ff1.up.weight", i), enc_h, enc_ffn);
+        GET_F32(b.ff1_up_b, lname("enc.blocks.%d.ff1.up.bias", i), enc_ffn);
         GET_LIN(b.ff1_down_w, lname("enc.blocks.%d.ff1.down.weight", i), enc_ffn, enc_h);
-        GET_F32(b.ff1_down_b, lname("enc.blocks.%d.ff1.down.bias",   i), enc_h);
+        GET_F32(b.ff1_down_b, lname("enc.blocks.%d.ff1.down.bias", i), enc_h);
 
         // Block-local Shaw self-attention.
         GET_F32(b.norm_attn_w, lname("enc.blocks.%d.norm_attn.weight", i), enc_h);
-        GET_F32(b.norm_attn_b, lname("enc.blocks.%d.norm_attn.bias",   i), enc_h);
+        GET_F32(b.norm_attn_b, lname("enc.blocks.%d.norm_attn.bias", i), enc_h);
         // attn.q : [enc_h, inner_dim]. No upstream bias.
-        GET_LIN(b.attn_q_w,    lname("enc.blocks.%d.attn.q.weight",    i), enc_h, enc_inner);
+        GET_LIN(b.attn_q_w, lname("enc.blocks.%d.attn.q.weight", i), enc_h, enc_inner);
         // attn.kv fused output dim is 2*inner_dim. No bias.
-        GET_LIN(b.attn_kv_w,   lname("enc.blocks.%d.attn.kv.weight",   i), enc_h, 2 * enc_inner);
+        GET_LIN(b.attn_kv_w, lname("enc.blocks.%d.attn.kv.weight", i), enc_h, 2 * enc_inner);
         // attn.out has bias.
-        GET_LIN(b.attn_out_w,  lname("enc.blocks.%d.attn.out.weight",  i), enc_inner, enc_h);
-        GET_F32(b.attn_out_b,  lname("enc.blocks.%d.attn.out.bias",    i), enc_h);
+        GET_LIN(b.attn_out_w, lname("enc.blocks.%d.attn.out.weight", i), enc_inner, enc_h);
+        GET_F32(b.attn_out_b, lname("enc.blocks.%d.attn.out.bias", i), enc_h);
         // Shaw rel-pos embedding table. find_tensor accepts any linear
         // dtype here (BF16/F16/F32) — the loader will keep whatever the
         // converter emitted.
-        GET_LIN(b.attn_rel_pos_emb, lname("enc.blocks.%d.attn.rel_pos_emb.weight", i),
-                enc_head_dim, rel_pos_len);
+        GET_LIN(b.attn_rel_pos_emb, lname("enc.blocks.%d.attn.rel_pos_emb.weight", i), enc_head_dim, rel_pos_len);
 
         // Conv module (LN -> pointwise expand -> GLU -> depthwise -> BN -> SiLU -> pointwise contract).
         GET_F32(b.norm_conv_w, lname("enc.blocks.%d.norm_conv.weight", i), enc_h);
-        GET_F32(b.norm_conv_b, lname("enc.blocks.%d.norm_conv.bias",   i), enc_h);
+        GET_F32(b.norm_conv_b, lname("enc.blocks.%d.norm_conv.bias", i), enc_h);
         // Conv1d kernel layout (k, in/groups, out_channels). pointwise k=1.
-        GET_CONV(b.conv_pointwise1_w, lname("enc.blocks.%d.conv.pointwise1.weight", i),
-                 1, enc_h, conv_up_out);
-        GET_F32(b.conv_pointwise1_b,  lname("enc.blocks.%d.conv.pointwise1.bias",   i),
-                conv_up_out);
+        GET_CONV(b.conv_pointwise1_w, lname("enc.blocks.%d.conv.pointwise1.weight", i), 1, enc_h, conv_up_out);
+        GET_F32(b.conv_pointwise1_b, lname("enc.blocks.%d.conv.pointwise1.bias", i), conv_up_out);
         // Depthwise: groups = in_channels = conv_inner.
-        GET_CONV(b.conv_depthwise_w,  lname("enc.blocks.%d.conv.depthwise.weight",  i),
-                 conv_k, 1, conv_inner);
+        GET_CONV(b.conv_depthwise_w, lname("enc.blocks.%d.conv.depthwise.weight", i), conv_k, 1, conv_inner);
         // BatchNorm1d fields are F32 (the converter routes anything
         // matching .bn. into the F32 bucket).
-        GET_F32(b.conv_bn_w,    lname("enc.blocks.%d.conv.bn.weight",       i), conv_inner);
-        GET_F32(b.conv_bn_b,    lname("enc.blocks.%d.conv.bn.bias",         i), conv_inner);
+        GET_F32(b.conv_bn_w, lname("enc.blocks.%d.conv.bn.weight", i), conv_inner);
+        GET_F32(b.conv_bn_b, lname("enc.blocks.%d.conv.bn.bias", i), conv_inner);
         GET_F32(b.conv_bn_mean, lname("enc.blocks.%d.conv.bn.running_mean", i), conv_inner);
-        GET_F32(b.conv_bn_var,  lname("enc.blocks.%d.conv.bn.running_var",  i), conv_inner);
-        GET_CONV(b.conv_pointwise2_w, lname("enc.blocks.%d.conv.pointwise2.weight", i),
-                 1, conv_inner, enc_h);
-        GET_F32(b.conv_pointwise2_b,  lname("enc.blocks.%d.conv.pointwise2.bias",   i),
-                enc_h);
+        GET_F32(b.conv_bn_var, lname("enc.blocks.%d.conv.bn.running_var", i), conv_inner);
+        GET_CONV(b.conv_pointwise2_w, lname("enc.blocks.%d.conv.pointwise2.weight", i), 1, conv_inner, enc_h);
+        GET_F32(b.conv_pointwise2_b, lname("enc.blocks.%d.conv.pointwise2.bias", i), enc_h);
 
         // FF2 (macaron half).
         GET_F32(b.norm_ff2_w, lname("enc.blocks.%d.norm_ff2.weight", i), enc_h);
-        GET_F32(b.norm_ff2_b, lname("enc.blocks.%d.norm_ff2.bias",   i), enc_h);
-        GET_LIN(b.ff2_up_w,   lname("enc.blocks.%d.ff2.up.weight",   i), enc_h,   enc_ffn);
-        GET_F32(b.ff2_up_b,   lname("enc.blocks.%d.ff2.up.bias",     i), enc_ffn);
+        GET_F32(b.norm_ff2_b, lname("enc.blocks.%d.norm_ff2.bias", i), enc_h);
+        GET_LIN(b.ff2_up_w, lname("enc.blocks.%d.ff2.up.weight", i), enc_h, enc_ffn);
+        GET_F32(b.ff2_up_b, lname("enc.blocks.%d.ff2.up.bias", i), enc_ffn);
         GET_LIN(b.ff2_down_w, lname("enc.blocks.%d.ff2.down.weight", i), enc_ffn, enc_h);
-        GET_F32(b.ff2_down_b, lname("enc.blocks.%d.ff2.down.bias",   i), enc_h);
+        GET_F32(b.ff2_down_b, lname("enc.blocks.%d.ff2.down.bias", i), enc_h);
 
         // Post-block LN.
         GET_F32(b.norm_post_w, lname("enc.blocks.%d.norm_post.weight", i), enc_h);
-        GET_F32(b.norm_post_b, lname("enc.blocks.%d.norm_post.bias",   i), enc_h);
+        GET_F32(b.norm_post_b, lname("enc.blocks.%d.norm_post.bias", i), enc_h);
     }
 
     // Projector: top-level.
@@ -411,13 +560,11 @@ transcribe_status build_granite_weights(ggml_context *         ctx_meta,
     // hardcode 3 here and add an explicit check below if a future
     // variant changes the count. The query tensor is a learned linear
     // embedding; we accept LINEAR_TYPES dtypes.
-    GET_LIN(weights.proj_top.query,    "proj.query",    prj_h, 3, 1);
+    GET_LIN(weights.proj_top.query, "proj.query", prj_h, 3, 1);
     GET_LIN(weights.proj_top.linear_w, "proj.linear.weight", prj_h, dec_h);
-    GET_F32(weights.proj_top.linear_b, "proj.linear.bias",   dec_h);
-    GET_F32(weights.proj_top.qformer_final_norm_w,
-            "proj.qformer.final_norm.weight", prj_h);
-    GET_F32(weights.proj_top.qformer_final_norm_b,
-            "proj.qformer.final_norm.bias",   prj_h);
+    GET_F32(weights.proj_top.linear_b, "proj.linear.bias", dec_h);
+    GET_F32(weights.proj_top.qformer_final_norm_w, "proj.qformer.final_norm.weight", prj_h);
+    GET_F32(weights.proj_top.qformer_final_norm_b, "proj.qformer.final_norm.bias", prj_h);
 
     // Projector: per-Q-Former-layer.
     weights.proj_blocks.assign(prj_n_layers, GraniteProjBlock{});
@@ -427,36 +574,36 @@ transcribe_status build_granite_weights(ggml_context *         ctx_meta,
         // Self-attention: Q/K/V/Out all map prj_h -> prj_h, every linear
         // has bias.
         GET_LIN(b.self_attn_q_w, lname("proj.qformer.blocks.%d.self_attn.q.weight", i), prj_h, prj_h);
-        GET_F32(b.self_attn_q_b, lname("proj.qformer.blocks.%d.self_attn.q.bias",   i), prj_h);
+        GET_F32(b.self_attn_q_b, lname("proj.qformer.blocks.%d.self_attn.q.bias", i), prj_h);
         GET_LIN(b.self_attn_k_w, lname("proj.qformer.blocks.%d.self_attn.k.weight", i), prj_h, prj_h);
-        GET_F32(b.self_attn_k_b, lname("proj.qformer.blocks.%d.self_attn.k.bias",   i), prj_h);
+        GET_F32(b.self_attn_k_b, lname("proj.qformer.blocks.%d.self_attn.k.bias", i), prj_h);
         GET_LIN(b.self_attn_v_w, lname("proj.qformer.blocks.%d.self_attn.v.weight", i), prj_h, prj_h);
-        GET_F32(b.self_attn_v_b, lname("proj.qformer.blocks.%d.self_attn.v.bias",   i), prj_h);
+        GET_F32(b.self_attn_v_b, lname("proj.qformer.blocks.%d.self_attn.v.bias", i), prj_h);
         GET_LIN(b.self_attn_out_w, lname("proj.qformer.blocks.%d.self_attn.out.weight", i), prj_h, prj_h);
-        GET_F32(b.self_attn_out_b, lname("proj.qformer.blocks.%d.self_attn.out.bias",   i), prj_h);
+        GET_F32(b.self_attn_out_b, lname("proj.qformer.blocks.%d.self_attn.out.bias", i), prj_h);
         GET_F32(b.norm_self_attn_w, lname("proj.qformer.blocks.%d.norm_self_attn.weight", i), prj_h);
-        GET_F32(b.norm_self_attn_b, lname("proj.qformer.blocks.%d.norm_self_attn.bias",   i), prj_h);
+        GET_F32(b.norm_self_attn_b, lname("proj.qformer.blocks.%d.norm_self_attn.bias", i), prj_h);
 
         // Cross-attention: Q is prj_h->prj_h; K/V are prj_kv_in->prj_h
         // (prj_kv_in == encoder hidden for 1b/2b, doubled for -plus).
-        GET_LIN(b.cross_attn_q_w, lname("proj.qformer.blocks.%d.cross_attn.q.weight", i), prj_h,     prj_h);
-        GET_F32(b.cross_attn_q_b, lname("proj.qformer.blocks.%d.cross_attn.q.bias",   i), prj_h);
+        GET_LIN(b.cross_attn_q_w, lname("proj.qformer.blocks.%d.cross_attn.q.weight", i), prj_h, prj_h);
+        GET_F32(b.cross_attn_q_b, lname("proj.qformer.blocks.%d.cross_attn.q.bias", i), prj_h);
         GET_LIN(b.cross_attn_k_w, lname("proj.qformer.blocks.%d.cross_attn.k.weight", i), prj_kv_in, prj_h);
-        GET_F32(b.cross_attn_k_b, lname("proj.qformer.blocks.%d.cross_attn.k.bias",   i), prj_h);
+        GET_F32(b.cross_attn_k_b, lname("proj.qformer.blocks.%d.cross_attn.k.bias", i), prj_h);
         GET_LIN(b.cross_attn_v_w, lname("proj.qformer.blocks.%d.cross_attn.v.weight", i), prj_kv_in, prj_h);
-        GET_F32(b.cross_attn_v_b, lname("proj.qformer.blocks.%d.cross_attn.v.bias",   i), prj_h);
+        GET_F32(b.cross_attn_v_b, lname("proj.qformer.blocks.%d.cross_attn.v.bias", i), prj_h);
         GET_LIN(b.cross_attn_out_w, lname("proj.qformer.blocks.%d.cross_attn.out.weight", i), prj_h, prj_h);
-        GET_F32(b.cross_attn_out_b, lname("proj.qformer.blocks.%d.cross_attn.out.bias",   i), prj_h);
+        GET_F32(b.cross_attn_out_b, lname("proj.qformer.blocks.%d.cross_attn.out.bias", i), prj_h);
         GET_F32(b.norm_cross_attn_w, lname("proj.qformer.blocks.%d.norm_cross_attn.weight", i), prj_h);
-        GET_F32(b.norm_cross_attn_b, lname("proj.qformer.blocks.%d.norm_cross_attn.bias",   i), prj_h);
+        GET_F32(b.norm_cross_attn_b, lname("proj.qformer.blocks.%d.norm_cross_attn.bias", i), prj_h);
 
         // FFN.
-        GET_LIN(b.ffn_up_w,   lname("proj.qformer.blocks.%d.ffn.up.weight",   i), prj_h,  prj_im);
-        GET_F32(b.ffn_up_b,   lname("proj.qformer.blocks.%d.ffn.up.bias",     i), prj_im);
+        GET_LIN(b.ffn_up_w, lname("proj.qformer.blocks.%d.ffn.up.weight", i), prj_h, prj_im);
+        GET_F32(b.ffn_up_b, lname("proj.qformer.blocks.%d.ffn.up.bias", i), prj_im);
         GET_LIN(b.ffn_down_w, lname("proj.qformer.blocks.%d.ffn.down.weight", i), prj_im, prj_h);
-        GET_F32(b.ffn_down_b, lname("proj.qformer.blocks.%d.ffn.down.bias",   i), prj_h);
+        GET_F32(b.ffn_down_b, lname("proj.qformer.blocks.%d.ffn.down.bias", i), prj_h);
         GET_F32(b.norm_ffn_w, lname("proj.qformer.blocks.%d.norm_ffn.weight", i), prj_h);
-        GET_F32(b.norm_ffn_b, lname("proj.qformer.blocks.%d.norm_ffn.bias",   i), prj_h);
+        GET_F32(b.norm_ffn_b, lname("proj.qformer.blocks.%d.norm_ffn.bias", i), prj_h);
     }
 
     // Text LM: embed.
@@ -467,18 +614,17 @@ transcribe_status build_granite_weights(ggml_context *         ctx_meta,
     for (int i = 0; i < hp.dec_n_layers; ++i) {
         auto & b = weights.dec_blocks[i];
         GET_F32(b.norm_attn_w, lname("dec.blocks.%d.norm_attn.weight", i), dec_h);
-        GET_F32(b.norm_ffn_w,  lname("dec.blocks.%d.norm_ffn.weight",  i), dec_h);
-        GET_LIN(b.attn_q_w,    lname("dec.blocks.%d.attn.q.weight",    i), dec_h, q_out);
-        GET_LIN(b.attn_k_w,    lname("dec.blocks.%d.attn.k.weight",    i), dec_h, kv_out);
-        GET_LIN(b.attn_v_w,    lname("dec.blocks.%d.attn.v.weight",    i), dec_h, kv_out);
-        GET_LIN(b.attn_o_w,    lname("dec.blocks.%d.attn.o.weight",    i), q_out, dec_h);
-        GET_LIN(b.ffn_gate_w,  lname("dec.blocks.%d.ffn.gate.weight",  i), dec_h, dec_im);
-        GET_LIN(b.ffn_up_w,    lname("dec.blocks.%d.ffn.up.weight",    i), dec_h, dec_im);
-        GET_LIN(b.ffn_down_w,  lname("dec.blocks.%d.ffn.down.weight",  i), dec_im, dec_h);
+        GET_F32(b.norm_ffn_w, lname("dec.blocks.%d.norm_ffn.weight", i), dec_h);
+        GET_LIN(b.attn_q_w, lname("dec.blocks.%d.attn.q.weight", i), dec_h, q_out);
+        GET_LIN(b.attn_k_w, lname("dec.blocks.%d.attn.k.weight", i), dec_h, kv_out);
+        GET_LIN(b.attn_v_w, lname("dec.blocks.%d.attn.v.weight", i), dec_h, kv_out);
+        GET_LIN(b.attn_o_w, lname("dec.blocks.%d.attn.o.weight", i), q_out, dec_h);
+        GET_LIN(b.ffn_gate_w, lname("dec.blocks.%d.ffn.gate.weight", i), dec_h, dec_im);
+        GET_LIN(b.ffn_up_w, lname("dec.blocks.%d.ffn.up.weight", i), dec_h, dec_im);
+        GET_LIN(b.ffn_down_w, lname("dec.blocks.%d.ffn.down.weight", i), dec_im, dec_h);
 
         if (b.ffn_gate_w->type != b.ffn_up_w->type) {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "granite: ffn gate/up dtype mismatch at dec layer %d", i);
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "granite: ffn gate/up dtype mismatch at dec layer %d", i);
             return TRANSCRIBE_ERR_GGUF;
         }
     }
@@ -496,4 +642,4 @@ transcribe_status build_granite_weights(ggml_context *         ctx_meta,
     return TRANSCRIBE_OK;
 }
 
-} // namespace transcribe::granite
+}  // namespace transcribe::granite
diff --git a/src/arch/granite/weights.h b/src/arch/granite/weights.h
index c1addae8..80ddfece 100644
--- a/src/arch/granite/weights.h
+++ b/src/arch/granite/weights.h
@@ -73,30 +73,30 @@ struct GraniteHParams {
     std::vector<int32_t> enc_cat_hidden_layers;
 
     // Projector (BLIP-2 Q-Former).
-    int32_t prj_n_layers            = 0;  // 2
-    int32_t prj_hidden              = 0;  // 1024
-    int32_t prj_intermediate        = 0;  // 4096
-    int32_t prj_n_heads             = 0;  // 16
-    int32_t prj_encoder_hidden_size = 0;  // 1024 or 2048 (varies on -plus)
-    int32_t prj_cross_attn_freq     = 0;  // 1 (every layer has cross-attn)
-    std::string prj_hidden_act;            // "gelu"
-    float   prj_layer_norm_eps      = 0.0f;
-    int32_t prj_max_pos_emb         = 0;  // 2048 (Q-Former absolute pos emb)
-    std::string prj_pos_embed_type;        // "absolute"
+    int32_t     prj_n_layers            = 0;  // 2
+    int32_t     prj_hidden              = 0;  // 1024
+    int32_t     prj_intermediate        = 0;  // 4096
+    int32_t     prj_n_heads             = 0;  // 16
+    int32_t     prj_encoder_hidden_size = 0;  // 1024 or 2048 (varies on -plus)
+    int32_t     prj_cross_attn_freq     = 0;  // 1 (every layer has cross-attn)
+    std::string prj_hidden_act;               // "gelu"
+    float       prj_layer_norm_eps = 0.0f;
+    int32_t     prj_max_pos_emb    = 0;       // 2048 (Q-Former absolute pos emb)
+    std::string prj_pos_embed_type;           // "absolute"
 
     // Text LM (Granite-4 causal LM).
-    int32_t dec_n_layers     = 0;  // 40
-    int32_t dec_hidden       = 0;  // 2048
-    int32_t dec_intermediate = 0;  // 4096
-    int32_t dec_n_heads      = 0;  // 16
-    int32_t dec_n_kv_heads   = 0;  // 4 (GQA 16/4)
-    int32_t dec_head_dim     = 0;  // 128
-    std::string dec_hidden_act;    // "silu"
-    float   dec_rms_norm_eps = 0.0f;
-    float   dec_rope_theta   = 0.0f;
-    int32_t dec_max_position_embeddings = 0;  // 4096
-    bool    dec_tie_word_embeddings     = false;  // true on -plus only
-    int32_t dec_vocab_size              = 0;  // 100353
+    int32_t     dec_n_layers     = 0;  // 40
+    int32_t     dec_hidden       = 0;  // 2048
+    int32_t     dec_intermediate = 0;  // 4096
+    int32_t     dec_n_heads      = 0;  // 16
+    int32_t     dec_n_kv_heads   = 0;  // 4 (GQA 16/4)
+    int32_t     dec_head_dim     = 0;  // 128
+    std::string dec_hidden_act;        // "silu"
+    float       dec_rms_norm_eps            = 0.0f;
+    float       dec_rope_theta              = 0.0f;
+    int32_t     dec_max_position_embeddings = 0;      // 4096
+    bool        dec_tie_word_embeddings     = false;  // true on -plus only
+    int32_t     dec_vocab_size              = 0;      // 100353
 
     // Granite-4 scalar multipliers. Each one is silently load-bearing —
     // missing any of them degrades accuracy without crashing.
@@ -111,32 +111,31 @@ struct GraniteHParams {
     int32_t window_size     = 0;  // 15 (encoder frames per Q-Former window)
 
     // Resolved token ids (filled from tokenizer KV at load).
-    int32_t bos_token_id = -1;   // 100257
-    int32_t eos_token_id = -1;   // 100257 (same as bos)
-    int32_t pad_token_id = -1;   // 100256
-    int32_t vocab_size   = 0;    // 100353
+    int32_t bos_token_id = -1;  // 100257
+    int32_t eos_token_id = -1;  // 100257 (same as bos)
+    int32_t pad_token_id = -1;  // 100256
+    int32_t vocab_size   = 0;   // 100353
 
     // Frontend (torchaudio MelSpectrogram). htk-norm mel, no log, no
     // per-utterance norm, power=2 spectrogram.
     std::string fe_type;             // "mel"
-    int32_t     fe_num_mels      = 0;  // 80
-    int32_t     fe_sample_rate   = 0;  // 16000
-    int32_t     fe_n_fft         = 0;  // 512
-    int32_t     fe_win_length    = 0;  // 400
-    int32_t     fe_hop_length    = 0;  // 160
-    std::string fe_window;             // "hann_periodic"
-    std::string fe_normalize;          // "none"
-    float       fe_dither        = 0.0f;
-    float       fe_pre_emphasis  = 0.0f;
-    float       fe_f_min         = 0.0f;
-    float       fe_f_max         = 0.0f;
-    std::string fe_pad_mode;           // "reflect"
-    bool        fe_center        = true;
-    std::string fe_mel_norm;           // "htk"
+    int32_t     fe_num_mels    = 0;  // 80
+    int32_t     fe_sample_rate = 0;  // 16000
+    int32_t     fe_n_fft       = 0;  // 512
+    int32_t     fe_win_length  = 0;  // 400
+    int32_t     fe_hop_length  = 0;  // 160
+    std::string fe_window;           // "hann_periodic"
+    std::string fe_normalize;        // "none"
+    float       fe_dither       = 0.0f;
+    float       fe_pre_emphasis = 0.0f;
+    float       fe_f_min        = 0.0f;
+    float       fe_f_max        = 0.0f;
+    std::string fe_pad_mode;  // "reflect"
+    bool        fe_center = true;
+    std::string fe_mel_norm;  // "htk"
 };
 
-transcribe_status read_granite_hparams(const gguf_context * gguf,
-                                       GraniteHParams &     hp);
+transcribe_status read_granite_hparams(const gguf_context * gguf, GraniteHParams & hp);
 
 // Weight slots - encoder (Conformer)
 
@@ -160,52 +159,52 @@ struct GraniteEncTop {
 struct GraniteEncBlock {
     // FF1 (first half macaron). LN gamma/beta + up/down projections,
     // both with biases. SiLU between.
-    ggml_tensor * norm_ff1_w   = nullptr;  // [hidden]
-    ggml_tensor * norm_ff1_b   = nullptr;
-    ggml_tensor * ff1_up_w     = nullptr;  // [hidden, hidden*ffn_mult]
-    ggml_tensor * ff1_up_b     = nullptr;  // [hidden*ffn_mult]
-    ggml_tensor * ff1_down_w   = nullptr;  // [hidden*ffn_mult, hidden]
-    ggml_tensor * ff1_down_b   = nullptr;  // [hidden]
+    ggml_tensor * norm_ff1_w = nullptr;  // [hidden]
+    ggml_tensor * norm_ff1_b = nullptr;
+    ggml_tensor * ff1_up_w   = nullptr;  // [hidden, hidden*ffn_mult]
+    ggml_tensor * ff1_up_b   = nullptr;  // [hidden*ffn_mult]
+    ggml_tensor * ff1_down_w = nullptr;  // [hidden*ffn_mult, hidden]
+    ggml_tensor * ff1_down_b = nullptr;  // [hidden]
 
     // Block-local Shaw self-attention.
-    ggml_tensor * norm_attn_w  = nullptr;  // [hidden]
-    ggml_tensor * norm_attn_b  = nullptr;
-    ggml_tensor * attn_q_w     = nullptr;  // [hidden, inner_dim]
-    ggml_tensor * attn_kv_w    = nullptr;  // [hidden, 2*inner_dim]  (fused K|V)
-    ggml_tensor * attn_out_w   = nullptr;  // [inner_dim, hidden]
-    ggml_tensor * attn_out_b   = nullptr;  // [hidden]
+    ggml_tensor * norm_attn_w      = nullptr;  // [hidden]
+    ggml_tensor * norm_attn_b      = nullptr;
+    ggml_tensor * attn_q_w         = nullptr;  // [hidden, inner_dim]
+    ggml_tensor * attn_kv_w        = nullptr;  // [hidden, 2*inner_dim]  (fused K|V)
+    ggml_tensor * attn_out_w       = nullptr;  // [inner_dim, hidden]
+    ggml_tensor * attn_out_b       = nullptr;  // [hidden]
     // Shaw relative-position table: [head_dim, 2*max_pos_emb+1].
     // Looked up by clamped (k - q + max_pos_emb) and added to QK^T.
     ggml_tensor * attn_rel_pos_emb = nullptr;  // [head_dim, 2*max_pos_emb+1]
 
     // Conv module (see granite_conv_module in encoder.cpp).
-    ggml_tensor * norm_conv_w        = nullptr;  // [hidden]
-    ggml_tensor * norm_conv_b        = nullptr;
-    ggml_tensor * conv_pointwise1_w  = nullptr;  // [1, hidden, 2*inner_dim]
-    ggml_tensor * conv_pointwise1_b  = nullptr;  // [2*inner_dim]
-    ggml_tensor * conv_depthwise_w   = nullptr;  // [k, 1, inner_dim]
-    ggml_tensor * conv_bn_w          = nullptr;  // [inner_dim]  (gamma)
-    ggml_tensor * conv_bn_b          = nullptr;  // [inner_dim]  (beta)
-    ggml_tensor * conv_bn_mean       = nullptr;  // [inner_dim]  (running mean)
-    ggml_tensor * conv_bn_var        = nullptr;  // [inner_dim]  (running var)
-    ggml_tensor * conv_pointwise2_w  = nullptr;  // [1, inner_dim, hidden]
-    ggml_tensor * conv_pointwise2_b  = nullptr;  // [hidden]
+    ggml_tensor * norm_conv_w         = nullptr;  // [hidden]
+    ggml_tensor * norm_conv_b         = nullptr;
+    ggml_tensor * conv_pointwise1_w   = nullptr;  // [1, hidden, 2*inner_dim]
+    ggml_tensor * conv_pointwise1_b   = nullptr;  // [2*inner_dim]
+    ggml_tensor * conv_depthwise_w    = nullptr;  // [k, 1, inner_dim]
+    ggml_tensor * conv_bn_w           = nullptr;  // [inner_dim]  (gamma)
+    ggml_tensor * conv_bn_b           = nullptr;  // [inner_dim]  (beta)
+    ggml_tensor * conv_bn_mean        = nullptr;  // [inner_dim]  (running mean)
+    ggml_tensor * conv_bn_var         = nullptr;  // [inner_dim]  (running var)
+    ggml_tensor * conv_pointwise2_w   = nullptr;  // [1, inner_dim, hidden]
+    ggml_tensor * conv_pointwise2_b   = nullptr;  // [hidden]
     // Fused BatchNorm scale/bias precomputed at load (model.cpp
     // fuse_batch_norm); the raw tensors above only feed the fusion step.
     ggml_tensor * conv_bn_fused_scale = nullptr;  // [inner_dim]
     ggml_tensor * conv_bn_fused_bias  = nullptr;  // [inner_dim]
 
     // FF2 (second half macaron).
-    ggml_tensor * norm_ff2_w   = nullptr;
-    ggml_tensor * norm_ff2_b   = nullptr;
-    ggml_tensor * ff2_up_w     = nullptr;
-    ggml_tensor * ff2_up_b     = nullptr;
-    ggml_tensor * ff2_down_w   = nullptr;
-    ggml_tensor * ff2_down_b   = nullptr;
+    ggml_tensor * norm_ff2_w = nullptr;
+    ggml_tensor * norm_ff2_b = nullptr;
+    ggml_tensor * ff2_up_w   = nullptr;
+    ggml_tensor * ff2_up_b   = nullptr;
+    ggml_tensor * ff2_down_w = nullptr;
+    ggml_tensor * ff2_down_b = nullptr;
 
     // Post-block LayerNorm.
-    ggml_tensor * norm_post_w  = nullptr;
-    ggml_tensor * norm_post_b  = nullptr;
+    ggml_tensor * norm_post_w = nullptr;
+    ggml_tensor * norm_post_b = nullptr;
 };
 
 // Weight slots - projector (BLIP-2 Q-Former)
@@ -219,9 +218,9 @@ struct GraniteEncBlock {
 //          applied to the queries BEFORE the layer stack, not after it.
 //          See projector.cpp (qformer_layer_norm at graph entry).
 struct GraniteProjTop {
-    ggml_tensor * query           = nullptr;  // [hidden, num_queries, 1]
-    ggml_tensor * linear_w        = nullptr;  // [hidden, lm_hidden]
-    ggml_tensor * linear_b        = nullptr;  // [lm_hidden]
+    ggml_tensor * query                = nullptr;  // [hidden, num_queries, 1]
+    ggml_tensor * linear_w             = nullptr;  // [hidden, lm_hidden]
+    ggml_tensor * linear_b             = nullptr;  // [lm_hidden]
     ggml_tensor * qformer_final_norm_w = nullptr;  // [hidden]
     ggml_tensor * qformer_final_norm_b = nullptr;
 };
@@ -232,36 +231,36 @@ struct GraniteProjTop {
 // for the -plus variant.
 struct GraniteProjBlock {
     // Self-attention (Q/K/V all hidden -> hidden).
-    ggml_tensor * self_attn_q_w   = nullptr;
-    ggml_tensor * self_attn_q_b   = nullptr;
-    ggml_tensor * self_attn_k_w   = nullptr;
-    ggml_tensor * self_attn_k_b   = nullptr;
-    ggml_tensor * self_attn_v_w   = nullptr;
-    ggml_tensor * self_attn_v_b   = nullptr;
-    ggml_tensor * self_attn_out_w = nullptr;
-    ggml_tensor * self_attn_out_b = nullptr;
+    ggml_tensor * self_attn_q_w    = nullptr;
+    ggml_tensor * self_attn_q_b    = nullptr;
+    ggml_tensor * self_attn_k_w    = nullptr;
+    ggml_tensor * self_attn_k_b    = nullptr;
+    ggml_tensor * self_attn_v_w    = nullptr;
+    ggml_tensor * self_attn_v_b    = nullptr;
+    ggml_tensor * self_attn_out_w  = nullptr;
+    ggml_tensor * self_attn_out_b  = nullptr;
     ggml_tensor * norm_self_attn_w = nullptr;
     ggml_tensor * norm_self_attn_b = nullptr;
 
     // Cross-attention. Q from query stream; K/V from encoder slice.
-    ggml_tensor * cross_attn_q_w   = nullptr;  // [prj_hidden,        prj_hidden]
-    ggml_tensor * cross_attn_q_b   = nullptr;
-    ggml_tensor * cross_attn_k_w   = nullptr;  // [encoder_hidden,    prj_hidden]
-    ggml_tensor * cross_attn_k_b   = nullptr;
-    ggml_tensor * cross_attn_v_w   = nullptr;  // [encoder_hidden,    prj_hidden]
-    ggml_tensor * cross_attn_v_b   = nullptr;
-    ggml_tensor * cross_attn_out_w = nullptr;  // [prj_hidden,        prj_hidden]
-    ggml_tensor * cross_attn_out_b = nullptr;
+    ggml_tensor * cross_attn_q_w    = nullptr;  // [prj_hidden,        prj_hidden]
+    ggml_tensor * cross_attn_q_b    = nullptr;
+    ggml_tensor * cross_attn_k_w    = nullptr;  // [encoder_hidden,    prj_hidden]
+    ggml_tensor * cross_attn_k_b    = nullptr;
+    ggml_tensor * cross_attn_v_w    = nullptr;  // [encoder_hidden,    prj_hidden]
+    ggml_tensor * cross_attn_v_b    = nullptr;
+    ggml_tensor * cross_attn_out_w  = nullptr;  // [prj_hidden,        prj_hidden]
+    ggml_tensor * cross_attn_out_b  = nullptr;
     ggml_tensor * norm_cross_attn_w = nullptr;
     ggml_tensor * norm_cross_attn_b = nullptr;
 
     // FFN (intermediate_query / output_query collapse).
-    ggml_tensor * ffn_up_w    = nullptr;  // [hidden, intermediate]
-    ggml_tensor * ffn_up_b    = nullptr;
-    ggml_tensor * ffn_down_w  = nullptr;  // [intermediate, hidden]
-    ggml_tensor * ffn_down_b  = nullptr;
-    ggml_tensor * norm_ffn_w  = nullptr;
-    ggml_tensor * norm_ffn_b  = nullptr;
+    ggml_tensor * ffn_up_w   = nullptr;  // [hidden, intermediate]
+    ggml_tensor * ffn_up_b   = nullptr;
+    ggml_tensor * ffn_down_w = nullptr;  // [intermediate, hidden]
+    ggml_tensor * ffn_down_b = nullptr;
+    ggml_tensor * norm_ffn_w = nullptr;
+    ggml_tensor * norm_ffn_b = nullptr;
 };
 
 // Weight slots - Granite-4 LM
@@ -271,45 +270,43 @@ struct GraniteDecEmbed {
 };
 
 struct GraniteDecBlock {
-    ggml_tensor * norm_attn_w = nullptr;  // input_layernorm (RMSNorm, no bias)
-    ggml_tensor * norm_ffn_w  = nullptr;  // post_attention_layernorm
+    ggml_tensor * norm_attn_w   = nullptr;  // input_layernorm (RMSNorm, no bias)
+    ggml_tensor * norm_ffn_w    = nullptr;  // post_attention_layernorm
     // GQA projections; no biases on Granite-4.
-    ggml_tensor * attn_q_w    = nullptr;  // [hidden, n_heads * head_dim]
-    ggml_tensor * attn_k_w    = nullptr;  // [hidden, n_kv_heads * head_dim]
-    ggml_tensor * attn_v_w    = nullptr;  // [hidden, n_kv_heads * head_dim]
-    ggml_tensor * attn_o_w    = nullptr;  // [n_heads * head_dim, hidden]
+    ggml_tensor * attn_q_w      = nullptr;  // [hidden, n_heads * head_dim]
+    ggml_tensor * attn_k_w      = nullptr;  // [hidden, n_kv_heads * head_dim]
+    ggml_tensor * attn_v_w      = nullptr;  // [hidden, n_kv_heads * head_dim]
+    ggml_tensor * attn_o_w      = nullptr;  // [n_heads * head_dim, hidden]
     // SwiGLU MLP.
-    ggml_tensor * ffn_gate_w  = nullptr;  // [hidden, intermediate]
-    ggml_tensor * ffn_up_w    = nullptr;  // [hidden, intermediate]
-    ggml_tensor * ffn_down_w  = nullptr;  // [intermediate, hidden]
+    ggml_tensor * ffn_gate_w    = nullptr;  // [hidden, intermediate]
+    ggml_tensor * ffn_up_w      = nullptr;  // [hidden, intermediate]
+    ggml_tensor * ffn_down_w    = nullptr;  // [intermediate, hidden]
     // Optional gate/up pack: [hidden, 2*intermediate]. Allocated by
     // causal_lm::pack_gate_up at load time.
     ggml_tensor * ffn_gate_up_w = nullptr;
 };
 
 struct GraniteDecFinal {
-    ggml_tensor * norm_w   = nullptr;   // RMSNorm before lm_head
+    ggml_tensor * norm_w   = nullptr;  // RMSNorm before lm_head
     // lm_head, only present when tie_word_embeddings=false (1b / 2b
     // variants). When tied (plus), the graph reuses dec_embed.token_w.
-    ggml_tensor * output_w = nullptr;   // [hidden, vocab] or nullptr
+    ggml_tensor * output_w = nullptr;  // [hidden, vocab] or nullptr
 };
 
 // Aggregated weights
 
 struct GraniteWeights {
-    GraniteEncTop                   enc_top;
-    std::vector<GraniteEncBlock>    enc_blocks;
+    GraniteEncTop                enc_top;
+    std::vector<GraniteEncBlock> enc_blocks;
 
-    GraniteProjTop                  proj_top;
-    std::vector<GraniteProjBlock>   proj_blocks;
+    GraniteProjTop                proj_top;
+    std::vector<GraniteProjBlock> proj_blocks;
 
-    GraniteDecEmbed                 dec_embed;
-    std::vector<GraniteDecBlock>    dec_blocks;
-    GraniteDecFinal                 dec_final;
+    GraniteDecEmbed              dec_embed;
+    std::vector<GraniteDecBlock> dec_blocks;
+    GraniteDecFinal              dec_final;
 };
 
-transcribe_status build_granite_weights(ggml_context *         ctx_meta,
-                                        const GraniteHParams & hp,
-                                        GraniteWeights &       weights);
+transcribe_status build_granite_weights(ggml_context * ctx_meta, const GraniteHParams & hp, GraniteWeights & weights);
 
-} // namespace transcribe::granite
+}  // namespace transcribe::granite
diff --git a/src/arch/granite_nar/capabilities.cpp b/src/arch/granite_nar/capabilities.cpp
index 26480b65..6a9518b6 100644
--- a/src/arch/granite_nar/capabilities.cpp
+++ b/src/arch/granite_nar/capabilities.cpp
@@ -19,4 +19,4 @@ void apply_family_invariants(transcribe_model & model) {
     transcribe::set_feature(&model, TRANSCRIBE_FEATURE_CANCELLATION, true);
 }
 
-} // namespace transcribe::granite_nar
+}  // namespace transcribe::granite_nar
diff --git a/src/arch/granite_nar/decoder.cpp b/src/arch/granite_nar/decoder.cpp
index a823247e..80f2c4a9 100644
--- a/src/arch/granite_nar/decoder.cpp
+++ b/src/arch/granite_nar/decoder.cpp
@@ -7,12 +7,11 @@
 
 #include "decoder.h"
 
+#include "ggml.h"
 #include "granite_nar.h"
 #include "transcribe-debug.h"
 #include "transcribe-log.h"
 
-#include "ggml.h"
-
 #include <algorithm>
 #include <cmath>
 #include <cstdio>
@@ -24,13 +23,13 @@ namespace transcribe::granite_nar {
 namespace {
 
 ggml_tensor * named(ggml_tensor * t, const char * name) {
-    if (t != nullptr && name != nullptr) ggml_set_name(t, name);
+    if (t != nullptr && name != nullptr) {
+        ggml_set_name(t, name);
+    }
     return t;
 }
 
-ggml_tensor * rms_norm(ggml_context * ctx, ggml_tensor * x,
-                       ggml_tensor * weight, float eps)
-{
+ggml_tensor * rms_norm(ggml_context * ctx, ggml_tensor * x, ggml_tensor * weight, float eps) {
     return ggml_mul(ctx, ggml_rms_norm(ctx, x, eps), weight);
 }
 
@@ -46,7 +45,7 @@ struct BlockParams {
 };
 
 BlockParams to_params(const GraniteNarHParams & hp) {
-    BlockParams p {};
+    BlockParams p{};
     p.n_heads      = hp.dec_n_heads;
     p.n_kv_heads   = hp.dec_n_kv_heads;
     p.head_dim     = hp.dec_head_dim;
@@ -60,41 +59,34 @@ BlockParams to_params(const GraniteNarHParams & hp) {
 
 // One bidirectional decoder block.
 // x: [hidden, T_total]. positions: [T_total] i32.
-ggml_tensor * block_bidi(ggml_context *            ctx,
-                         ggml_tensor *             x,
+ggml_tensor * block_bidi(ggml_context *             ctx,
+                         ggml_tensor *              x,
                          const GraniteNarDecBlock & view,
                          const BlockParams &        params,
                          int                        T_total,
-                         ggml_tensor *              positions)
-{
+                         ggml_tensor *              positions) {
     const int64_t n_heads    = params.n_heads;
     const int64_t n_kv_heads = params.n_kv_heads;
     const int64_t n_groups   = n_heads / n_kv_heads;
     const int64_t head_dim   = params.head_dim;
-    const int64_t q_dim      = n_heads    * head_dim;
-    (void)q_dim;
+    const int64_t q_dim      = n_heads * head_dim;
+    (void) q_dim;
     const float rms_eps    = params.rms_eps;
     const float rope_theta = params.rope_theta;
     const float scale_attn = params.attn_scale;
 
     ggml_tensor * x_norm = rms_norm(ctx, x, view.norm_attn_w, rms_eps);
-    ggml_tensor * Q = ggml_mul_mat(ctx, view.attn_q_w, x_norm);
-    ggml_tensor * K = ggml_mul_mat(ctx, view.attn_k_w, x_norm);
-    ggml_tensor * V = ggml_mul_mat(ctx, view.attn_v_w, x_norm);
+    ggml_tensor * Q      = ggml_mul_mat(ctx, view.attn_q_w, x_norm);
+    ggml_tensor * K      = ggml_mul_mat(ctx, view.attn_k_w, x_norm);
+    ggml_tensor * V      = ggml_mul_mat(ctx, view.attn_v_w, x_norm);
 
-    Q = ggml_reshape_4d(ctx, Q, head_dim, n_heads,    T_total, 1);
+    Q = ggml_reshape_4d(ctx, Q, head_dim, n_heads, T_total, 1);
     K = ggml_reshape_4d(ctx, K, head_dim, n_kv_heads, T_total, 1);
     V = ggml_reshape_4d(ctx, V, head_dim, n_kv_heads, T_total, 1);
 
-    Q = ggml_rope_ext(ctx, Q, positions, nullptr,
-                      static_cast<int>(head_dim),
-                      GGML_ROPE_TYPE_NEOX,
-                      params.max_position,
+    Q = ggml_rope_ext(ctx, Q, positions, nullptr, static_cast<int>(head_dim), GGML_ROPE_TYPE_NEOX, params.max_position,
                       rope_theta, 1.0f, 0.0f, 1.0f, 32.0f, 1.0f);
-    K = ggml_rope_ext(ctx, K, positions, nullptr,
-                      static_cast<int>(head_dim),
-                      GGML_ROPE_TYPE_NEOX,
-                      params.max_position,
+    K = ggml_rope_ext(ctx, K, positions, nullptr, static_cast<int>(head_dim), GGML_ROPE_TYPE_NEOX, params.max_position,
                       rope_theta, 1.0f, 0.0f, 1.0f, 32.0f, 1.0f);
 
     // Permute to [head_dim, T_total, n_kv_heads] (effective layout for
@@ -110,31 +102,27 @@ ggml_tensor * block_bidi(ggml_context *            ctx,
         K_full = K_att;
         V_full = V_att;
     } else {
-        ggml_tensor * K_4d = ggml_reshape_4d(ctx, K_att, head_dim, T_total, 1, n_kv_heads);
-        ggml_tensor * V_4d = ggml_reshape_4d(ctx, V_att, head_dim, T_total, 1, n_kv_heads);
-        ggml_tensor * K_tpl = ggml_new_tensor_4d(ctx, K_att->type,
-                                                 head_dim, T_total, n_groups, n_kv_heads);
-        ggml_tensor * V_tpl = ggml_new_tensor_4d(ctx, V_att->type,
-                                                 head_dim, T_total, n_groups, n_kv_heads);
+        ggml_tensor * K_4d  = ggml_reshape_4d(ctx, K_att, head_dim, T_total, 1, n_kv_heads);
+        ggml_tensor * V_4d  = ggml_reshape_4d(ctx, V_att, head_dim, T_total, 1, n_kv_heads);
+        ggml_tensor * K_tpl = ggml_new_tensor_4d(ctx, K_att->type, head_dim, T_total, n_groups, n_kv_heads);
+        ggml_tensor * V_tpl = ggml_new_tensor_4d(ctx, V_att->type, head_dim, T_total, n_groups, n_kv_heads);
         ggml_tensor * K_rep = ggml_repeat(ctx, K_4d, K_tpl);
         ggml_tensor * V_rep = ggml_repeat(ctx, V_4d, V_tpl);
-        K_full = ggml_reshape_3d(ctx, K_rep, head_dim, T_total, n_heads);
-        V_full = ggml_reshape_3d(ctx, V_rep, head_dim, T_total, n_heads);
+        K_full              = ggml_reshape_3d(ctx, K_rep, head_dim, T_total, n_heads);
+        V_full              = ggml_reshape_3d(ctx, V_rep, head_dim, T_total, n_heads);
     }
 
     // scores = (K^T Q) * scale_attn. ggml_mul_mat(K, Q) yields
     // [T_total_k, T_total_q, n_heads].
-    ggml_tensor * kq = ggml_mul_mat(ctx, K_full, Q_att);
+    ggml_tensor * kq      = ggml_mul_mat(ctx, K_full, Q_att);
     // No mask (bidirectional). Use soft_max_ext with mask=nullptr for the
     // scaling, then softmax.
-    ggml_tensor * kq_soft = ggml_soft_max_ext(ctx, kq, /*mask=*/nullptr,
-                                              scale_attn, /*max_bias=*/0.0f);
+    ggml_tensor * kq_soft = ggml_soft_max_ext(ctx, kq, /*mask=*/nullptr, scale_attn, /*max_bias=*/0.0f);
 
     ggml_tensor * V_t = ggml_cont(ctx, ggml_permute(ctx, V_full, 1, 0, 2, 3));
-    ggml_tensor * o = ggml_mul_mat(ctx, V_t, kq_soft);
-    o = ggml_cont(ctx, ggml_permute(ctx, o, 0, 2, 1, 3));
-    o = ggml_reshape_2d(ctx, o,
-                        static_cast<int64_t>(n_heads) * head_dim, T_total);
+    ggml_tensor * o   = ggml_mul_mat(ctx, V_t, kq_soft);
+    o                 = ggml_cont(ctx, ggml_permute(ctx, o, 0, 2, 1, 3));
+    o                 = ggml_reshape_2d(ctx, o, static_cast<int64_t>(n_heads) * head_dim, T_total);
 
     o = ggml_mul_mat(ctx, view.attn_o_w, o);
     o = ggml_scale(ctx, o, params.residual_mul);
@@ -142,32 +130,30 @@ ggml_tensor * block_bidi(ggml_context *            ctx,
 
     // MLP sub-layer (SwiGLU).
     ggml_tensor * f_norm = rms_norm(ctx, x, view.norm_ffn_w, rms_eps);
-    ggml_tensor * gate = ggml_mul_mat(ctx, view.ffn_gate_w, f_norm);
-    ggml_tensor * up   = ggml_mul_mat(ctx, view.ffn_up_w,   f_norm);
-    ggml_tensor * ff   = ggml_mul(ctx, ggml_silu(ctx, gate), up);
-    ff = ggml_mul_mat(ctx, view.ffn_down_w, ff);
-    ff = ggml_scale(ctx, ff, params.residual_mul);
-    x = ggml_add(ctx, x, ff);
+    ggml_tensor * gate   = ggml_mul_mat(ctx, view.ffn_gate_w, f_norm);
+    ggml_tensor * up     = ggml_mul_mat(ctx, view.ffn_up_w, f_norm);
+    ggml_tensor * ff     = ggml_mul(ctx, ggml_silu(ctx, gate), up);
+    ff                   = ggml_mul_mat(ctx, view.ffn_down_w, ff);
+    ff                   = ggml_scale(ctx, ff, params.residual_mul);
+    x                    = ggml_add(ctx, x, ff);
     return x;
 }
 
-} // namespace
+}  // namespace
 
 ForwardBuild build_forward_graph(ggml_context *            ctx,
                                  const GraniteNarWeights & weights,
                                  const GraniteNarHParams & hp,
                                  int                       n_audio_tokens,
-                                 int                       n_text)
-{
-    ForwardBuild fb {};
+                                 int                       n_text) {
+    ForwardBuild fb{};
     fb.n_audio_tokens = n_audio_tokens;
     fb.n_text         = n_text;
     fb.T_total        = n_audio_tokens + n_text;
 
     if (ctx == nullptr || n_audio_tokens <= 0 || n_text <= 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "granite_nar decoder: invalid (n_audio=%d, n_text=%d)",
-                     n_audio_tokens, n_text);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "granite_nar decoder: invalid (n_audio=%d, n_text=%d)", n_audio_tokens,
+                n_text);
         return fb;
     }
 
@@ -175,7 +161,7 @@ ForwardBuild build_forward_graph(ggml_context *            ctx,
     const int     n_layer = hp.dec_n_layers;
     const float   rms_eps = hp.dec_rms_norm_eps;
     const float   emb_mul = hp.dec_embedding_multiplier;
-    const auto params = to_params(hp);
+    const auto    params  = to_params(hp);
 
     // Inputs.
     fb.audio_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, hidden, n_audio_tokens);
@@ -201,8 +187,7 @@ ForwardBuild build_forward_graph(ggml_context *            ctx,
     // text embeds via lookup. ggml_get_rows returns the embed table dtype
     // (BF16 here); cast to F32 so ggml_concat with the F32 audio_in is
     // legal (concat requires matching dtypes).
-    ggml_tensor * text_emb = ggml_get_rows(
-        ctx, weights.dec_embed.token_w, fb.text_ids_in);
+    ggml_tensor * text_emb = ggml_get_rows(ctx, weights.dec_embed.token_w, fb.text_ids_in);
     if (text_emb->type != GGML_TYPE_F32) {
         text_emb = ggml_cast(ctx, text_emb, GGML_TYPE_F32);
     }
@@ -223,8 +208,7 @@ ForwardBuild build_forward_graph(ggml_context *            ctx,
 
     // Block stack.
     for (int il = 0; il < n_layer; ++il) {
-        x = block_bidi(ctx, x, weights.dec_blocks[il],
-                       params, fb.T_total, fb.positions_in);
+        x = block_bidi(ctx, x, weights.dec_blocks[il], params, fb.T_total, fb.positions_in);
     }
 
     // Final RMSNorm.
@@ -232,45 +216,39 @@ ForwardBuild build_forward_graph(ggml_context *            ctx,
 
     // Slice text portion.
     // text_x = x[:, n_audio_tokens:]
-    ggml_tensor * text_x = ggml_view_2d(
-        ctx, x,
-        hidden, n_text,
-        ggml_element_size(x) * hidden,
-        ggml_element_size(x) * hidden *
-            static_cast<size_t>(n_audio_tokens));
-    text_x = ggml_cont(ctx, text_x);
+    ggml_tensor * text_x = ggml_view_2d(ctx, x, hidden, n_text, ggml_element_size(x) * hidden,
+                                        ggml_element_size(x) * hidden * static_cast<size_t>(n_audio_tokens));
+    text_x               = ggml_cont(ctx, text_x);
 
     // LM head (tied to token_embd). The Granite-4 head divides by
     // logits_scaling; we mirror it so dec.text_logits aligns numerically with
     // the reference dump. Argmax is scale-invariant, so the transcript is
     // unchanged by this division.
-    ggml_tensor * logits = ggml_mul_mat(
-        ctx, weights.dec_embed.token_w, text_x);
+    ggml_tensor * logits = ggml_mul_mat(ctx, weights.dec_embed.token_w, text_x);
     if (hp.dec_logits_scaling > 0.0f && hp.dec_logits_scaling != 1.0f) {
         logits = ggml_scale(ctx, logits, 1.0f / hp.dec_logits_scaling);
     }
     // ne = [vocab, n_text]
     named(logits, "dec.text_logits");
-    fb.out = logits;
+    fb.out               = logits;
     fb.dumps.text_logits = logits;
     ggml_set_output(logits);
     transcribe::debug::mark_tensor_for_dump(logits);
 
     ggml_build_forward_expand(gf, fb.out);
-    if (fb.dumps.flat_embeds)  ggml_build_forward_expand(gf, fb.dumps.flat_embeds);
+    if (fb.dumps.flat_embeds) {
+        ggml_build_forward_expand(gf, fb.dumps.flat_embeds);
+    }
 
     return fb;
 }
 
-void add_insertion_slots(const std::vector<int32_t> & hyp_ids,
-                         int32_t                      eos_id,
-                         std::vector<int32_t> &       out)
-{
+void add_insertion_slots(const std::vector<int32_t> & hyp_ids, int32_t eos_id, std::vector<int32_t> & out) {
     // Reference: total_len = max(2 * n + 1, 8). EOS is inserted between
     // and around every CTC token (positions 0, 2, 4, ...); CTC tokens
     // occupy odd positions. Length floored at 8 to give the bidirectional
     // editor a minimum context to operate over.
-    const int n = static_cast<int>(hyp_ids.size());
+    const int n         = static_cast<int>(hyp_ids.size());
     const int total_len = std::max(2 * n + 1, 8);
     out.assign(total_len, eos_id);
     for (int i = 0; i < n; ++i) {
@@ -282,22 +260,29 @@ void argmax_collapse_drop_eos(const std::vector<float> & text_logits,
                               int                        vocab,
                               int                        n_text,
                               int32_t                    eos_id,
-                              std::vector<int32_t> &     out_ids)
-{
+                              std::vector<int32_t> &     out_ids) {
     out_ids.clear();
     int32_t prev = -1;
     for (int i = 0; i < n_text; ++i) {
-        const float * row = text_logits.data() + static_cast<size_t>(i) * vocab;
-        int32_t best = 0;
-        float   best_v = row[0];
+        const float * row    = text_logits.data() + static_cast<size_t>(i) * vocab;
+        int32_t       best   = 0;
+        float         best_v = row[0];
         for (int v = 1; v < vocab; ++v) {
-            if (row[v] > best_v) { best_v = row[v]; best = v; }
+            if (row[v] > best_v) {
+                best_v = row[v];
+                best   = v;
+            }
+        }
+        if (best == eos_id) {
+            prev = best;
+            continue;
+        }
+        if (best == prev) {
+            continue;
         }
-        if (best == eos_id) { prev = best; continue; }
-        if (best == prev) continue;
         out_ids.push_back(best);
         prev = best;
     }
 }
 
-} // namespace transcribe::granite_nar
+}  // namespace transcribe::granite_nar
diff --git a/src/arch/granite_nar/decoder.h b/src/arch/granite_nar/decoder.h
index 70b3795c..174baa14 100644
--- a/src/arch/granite_nar/decoder.h
+++ b/src/arch/granite_nar/decoder.h
@@ -26,9 +26,8 @@
 
 #pragma once
 
-#include "weights.h"
-
 #include "ggml.h"
+#include "weights.h"
 
 #include <cstdint>
 
@@ -39,9 +38,9 @@ struct ggml_tensor;
 namespace transcribe::granite_nar {
 
 struct DecoderDumps {
-    ggml_tensor * flat_embeds  = nullptr;  // [hidden, T_total] post-scatter,
-                                           //  pre-embedding_multiplier
-    ggml_tensor * text_logits  = nullptr;  // [vocab, n_text] over text part only
+    ggml_tensor * flat_embeds = nullptr;  // [hidden, T_total] post-scatter,
+                                          //  pre-embedding_multiplier
+    ggml_tensor * text_logits = nullptr;  // [vocab, n_text] over text part only
 };
 
 struct ForwardBuild {
@@ -52,10 +51,10 @@ struct ForwardBuild {
     ggml_tensor * positions_in = nullptr;  // [T_total] i32 RoPE positions
 
     // Output (lm_head sliced over the text portion).
-    ggml_tensor * out          = nullptr;  // [vocab, n_text]
+    ggml_tensor * out = nullptr;  // [vocab, n_text]
 
-    DecoderDumps  dumps {};
-    ggml_cgraph * graph        = nullptr;
+    DecoderDumps  dumps{};
+    ggml_cgraph * graph = nullptr;
 
     int n_audio_tokens = 0;
     int n_text         = 0;
@@ -72,9 +71,7 @@ ForwardBuild build_forward_graph(ggml_context *            ctx,
 
 // Host-side helper: insert eos_id between every adjacent pair (and at
 // the head/tail) of `hyp_ids`. Length grows from n to 2n + 1.
-void add_insertion_slots(const std::vector<int32_t> & hyp_ids,
-                         int32_t                      eos_id,
-                         std::vector<int32_t> &       out);
+void add_insertion_slots(const std::vector<int32_t> & hyp_ids, int32_t eos_id, std::vector<int32_t> & out);
 
 // Host-side argmax+collapse decoder: walks the text-portion logits row
 // by row, picks the argmax per row, collapses consecutive duplicates,
@@ -85,4 +82,4 @@ void argmax_collapse_drop_eos(const std::vector<float> & text_logits,
                               int32_t                    eos_id,
                               std::vector<int32_t> &     out_ids);
 
-} // namespace transcribe::granite_nar
+}  // namespace transcribe::granite_nar
diff --git a/src/arch/granite_nar/encoder.cpp b/src/arch/granite_nar/encoder.cpp
index f20272f8..04b7ff02 100644
--- a/src/arch/granite_nar/encoder.cpp
+++ b/src/arch/granite_nar/encoder.cpp
@@ -16,16 +16,14 @@
 
 #include "encoder.h"
 
-#include "granite_nar.h"
-#include "weights.h"
-
 #include "conformer/conformer.h"
+#include "ggml.h"
 #include "granite_conformer/shaw_attn.h"
+#include "granite_nar.h"
 #include "transcribe-debug.h"
-#include "transcribe-mel.h"
 #include "transcribe-log.h"
-
-#include "ggml.h"
+#include "transcribe-mel.h"
+#include "weights.h"
 
 #include <algorithm>
 #include <cmath>
@@ -41,52 +39,48 @@ namespace {
 constexpr float kLayerNormEps = 1e-5f;
 
 ggml_tensor * named(ggml_tensor * t, const char * name) {
-    if (t != nullptr && name != nullptr) ggml_set_name(t, name);
+    if (t != nullptr && name != nullptr) {
+        ggml_set_name(t, name);
+    }
     return t;
 }
 
-ggml_tensor * layer_norm(ggml_context * ctx, ggml_tensor * x,
-                         ggml_tensor * gamma, ggml_tensor * beta)
-{
+ggml_tensor * layer_norm(ggml_context * ctx, ggml_tensor * x, ggml_tensor * gamma, ggml_tensor * beta) {
     ggml_tensor * y = ggml_norm(ctx, x, kLayerNormEps);
-    y = ggml_mul(ctx, y, gamma);
-    if (beta != nullptr) y = ggml_add(ctx, y, beta);
+    y               = ggml_mul(ctx, y, gamma);
+    if (beta != nullptr) {
+        y = ggml_add(ctx, y, beta);
+    }
     return y;
 }
 
-ggml_tensor * linear(ggml_context * ctx, ggml_tensor * x,
-                     ggml_tensor * w, ggml_tensor * b)
-{
+ggml_tensor * linear(ggml_context * ctx, ggml_tensor * x, ggml_tensor * w, ggml_tensor * b) {
     ggml_tensor * y = ggml_mul_mat(ctx, w, x);
-    if (b != nullptr) y = ggml_add(ctx, y, b);
+    if (b != nullptr) {
+        y = ggml_add(ctx, y, b);
+    }
     return y;
 }
 
-} // namespace
+}  // namespace
 
 // Host-side mel + 2-frame stack.
 
-transcribe_status compute_mel_encoder_input(
-    const transcribe::MelFrontend & mel,
-    const float *                   pcm,
-    int                             n_samples,
-    int                             n_threads,
-    std::vector<float> &            out_mel,
-    int &                           out_t_enc)
-{
+transcribe_status compute_mel_encoder_input(const transcribe::MelFrontend & mel,
+                                            const float *                   pcm,
+                                            int                             n_samples,
+                                            int                             n_threads,
+                                            std::vector<float> &            out_mel,
+                                            int &                           out_t_enc) {
     if (pcm == nullptr || n_samples <= 0) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
 
     std::vector<float> raw;
-    int n_mels = 0;
-    int n_frames = 0;
-    if (const transcribe_status st = mel.compute(pcm,
-                                                 static_cast<size_t>(n_samples),
-                                                 raw, n_mels, n_frames,
-                                                 n_threads);
-        st != TRANSCRIBE_OK)
-    {
+    int                n_mels   = 0;
+    int                n_frames = 0;
+    if (const transcribe_status st = mel.compute(pcm, static_cast<size_t>(n_samples), raw, n_mels, n_frames, n_threads);
+        st != TRANSCRIBE_OK) {
         return st;
     }
 
@@ -100,9 +94,8 @@ transcribe_status compute_mel_encoder_input(
 
     const int stride = static_cast<int>(raw.size() / static_cast<size_t>(n_mels));
     if (stride <= 0 || stride < n_frames) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "granite_nar: mel buffer stride (%d) < expected frames (%d)",
-                     stride, n_frames);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "granite_nar: mel buffer stride (%d) < expected frames (%d)", stride,
+                n_frames);
         return TRANSCRIBE_ERR_GGUF;
     }
 
@@ -111,7 +104,7 @@ transcribe_status compute_mel_encoder_input(
     for (int t = 0; t < t_enc; ++t) {
         float * dst = out_mel.data() + static_cast<size_t>(t) * input_dim;
         for (int m = 0; m < n_mels; ++m) {
-            dst[m]          = raw[static_cast<size_t>(m) * stride + 2 * t    ];
+            dst[m]          = raw[static_cast<size_t>(m) * stride + 2 * t];
             dst[m + n_mels] = raw[static_cast<size_t>(m) * stride + 2 * t + 1];
         }
     }
@@ -121,23 +114,24 @@ transcribe_status compute_mel_encoder_input(
 
 // Shaw bookkeeping (matches AR granite).
 
-std::vector<int32_t> precompute_attention_dists(int context_size, int max_pos_emb)
-{
+std::vector<int32_t> precompute_attention_dists(int context_size, int max_pos_emb) {
     std::vector<int32_t> dists(static_cast<size_t>(context_size) * context_size);
     for (int c = 0; c < context_size; ++c) {
         for (int r = 0; r < context_size; ++r) {
             int d = c - r;
-            if (d < -context_size) d = -context_size;
-            if (d >  context_size) d =  context_size;
-            dists[static_cast<size_t>(c) * context_size + r] =
-                static_cast<int32_t>(d + max_pos_emb);
+            if (d < -context_size) {
+                d = -context_size;
+            }
+            if (d > context_size) {
+                d = context_size;
+            }
+            dists[static_cast<size_t>(c) * context_size + r] = static_cast<int32_t>(d + max_pos_emb);
         }
     }
     return dists;
 }
 
-std::vector<float> precompute_last_block_mask(int context_size, int t_enc_remainder)
-{
+std::vector<float> precompute_last_block_mask(int context_size, int t_enc_remainder) {
     std::vector<float> mask(static_cast<size_t>(context_size) * context_size, 0.0f);
     if (t_enc_remainder <= 0 || t_enc_remainder >= context_size) {
         return mask;
@@ -156,21 +150,13 @@ std::vector<float> precompute_last_block_mask(int context_size, int t_enc_remain
 
 namespace {
 
-ggml_tensor * macaron(ggml_context * ctx, ggml_tensor * x,
-                      const GraniteNarEncBlock & b, bool is_ff1)
-{
+ggml_tensor * macaron(ggml_context * ctx, ggml_tensor * x, const GraniteNarEncBlock & b, bool is_ff1) {
     if (is_ff1) {
-        return transcribe::conformer::macaron_ff_residual(
-            ctx, x,
-            b.norm_ff1_w, b.norm_ff1_b,
-            b.ff1_up_w,   b.ff1_up_b,
-            b.ff1_down_w, b.ff1_down_b);
-    }
-    return transcribe::conformer::macaron_ff_residual(
-        ctx, x,
-        b.norm_ff2_w, b.norm_ff2_b,
-        b.ff2_up_w,   b.ff2_up_b,
-        b.ff2_down_w, b.ff2_down_b);
+        return transcribe::conformer::macaron_ff_residual(ctx, x, b.norm_ff1_w, b.norm_ff1_b, b.ff1_up_w, b.ff1_up_b,
+                                                          b.ff1_down_w, b.ff1_down_b);
+    }
+    return transcribe::conformer::macaron_ff_residual(ctx, x, b.norm_ff2_w, b.norm_ff2_b, b.ff2_up_w, b.ff2_up_b,
+                                                      b.ff2_down_w, b.ff2_down_b);
 }
 
 ggml_tensor * conv_module(ggml_context *             ctx,
@@ -179,53 +165,44 @@ ggml_tensor * conv_module(ggml_context *             ctx,
                           ggml_tensor *              bn_fused_scale,
                           ggml_tensor *              bn_fused_bias,
                           int                        conv_kernel,
-                          int                        inner_dim)
-{
+                          int                        inner_dim) {
     const int64_t d_model = x->ne[0];
     const int64_t T       = x->ne[1];
 
     x = layer_norm(ctx, x, b.norm_conv_w, b.norm_conv_b);
     {
-        ggml_tensor * pw1 = ggml_reshape_2d(ctx, b.conv_pointwise1_w,
-                                            d_model, 2 * inner_dim);
-        x = ggml_mul_mat(ctx, pw1, x);
-        x = ggml_add(ctx, x, b.conv_pointwise1_b);
+        ggml_tensor * pw1 = ggml_reshape_2d(ctx, b.conv_pointwise1_w, d_model, 2 * inner_dim);
+        x                 = ggml_mul_mat(ctx, pw1, x);
+        x                 = ggml_add(ctx, x, b.conv_pointwise1_b);
     }
     {
-        ggml_tensor * gate  = ggml_view_2d(ctx, x, inner_dim, T,
-                                           x->nb[1], 0);
-        ggml_tensor * value = ggml_view_2d(ctx, x, inner_dim, T,
-                                           x->nb[1],
-                                           inner_dim * ggml_element_size(x));
-        x = ggml_mul(ctx, gate, ggml_sigmoid(ctx, value));
-    }
-    x = ggml_cont(ctx, ggml_permute(ctx, x, 1, 0, 2, 3));
+        ggml_tensor * gate  = ggml_view_2d(ctx, x, inner_dim, T, x->nb[1], 0);
+        ggml_tensor * value = ggml_view_2d(ctx, x, inner_dim, T, x->nb[1], inner_dim * ggml_element_size(x));
+        x                   = ggml_mul(ctx, gate, ggml_sigmoid(ctx, value));
+    }
+    x                 = ggml_cont(ctx, ggml_permute(ctx, x, 1, 0, 2, 3));
     const int padding = (conv_kernel - 1) / 2;
-    x = transcribe::conformer::conv_1d_dw_f32(
-        ctx, b.conv_depthwise_w, x,
-        /*stride=*/1, /*padding=*/padding, /*dilation=*/1);
-    x = transcribe::conformer::fused_batch_norm(ctx, x,
-                                                bn_fused_scale, bn_fused_bias);
-    x = ggml_silu(ctx, x);
-    x = ggml_cont(ctx, ggml_permute(ctx, x, 1, 0, 2, 3));
+    x                 = transcribe::conformer::conv_1d_dw_f32(ctx, b.conv_depthwise_w, x,
+                                                              /*stride=*/1, /*padding=*/padding, /*dilation=*/1);
+    x                 = transcribe::conformer::fused_batch_norm(ctx, x, bn_fused_scale, bn_fused_bias);
+    x                 = ggml_silu(ctx, x);
+    x                 = ggml_cont(ctx, ggml_permute(ctx, x, 1, 0, 2, 3));
     {
-        ggml_tensor * pw2 = ggml_reshape_2d(ctx, b.conv_pointwise2_w,
-                                            inner_dim, d_model);
-        x = ggml_mul_mat(ctx, pw2, x);
-        x = ggml_add(ctx, x, b.conv_pointwise2_b);
+        ggml_tensor * pw2 = ggml_reshape_2d(ctx, b.conv_pointwise2_w, inner_dim, d_model);
+        x                 = ggml_mul_mat(ctx, pw2, x);
+        x                 = ggml_add(ctx, x, b.conv_pointwise2_b);
     }
     return x;
 }
 
-} // namespace
+}  // namespace
 
 EncoderBuild build_encoder_graph(ggml_context *            ctx,
                                  const GraniteNarWeights & weights,
                                  const GraniteNarHParams & hp,
                                  int                       T_enc,
-                                 bool                      /*use_flash*/)
-{
-    EncoderBuild eb {};
+                                 bool /*use_flash*/) {
+    EncoderBuild eb{};
     eb.n_blocks_local = (T_enc + hp.enc_context_size - 1) / hp.enc_context_size;
     const int T_pad   = eb.n_blocks_local * hp.enc_context_size;
     eb.last_block_rem = T_enc - (eb.n_blocks_local - 1) * hp.enc_context_size;
@@ -233,38 +210,32 @@ EncoderBuild build_encoder_graph(ggml_context *            ctx,
     const int64_t d_model   = hp.enc_hidden;
     const int64_t input_dim = hp.enc_input_dim;
     const int64_t inner_dim = static_cast<int64_t>(hp.enc_hidden) * hp.enc_conv_expansion;
-    const int conv_k        = hp.enc_conv_kernel_size;
-    const int n_heads       = hp.enc_n_heads;
-    const int head_dim      = hp.enc_head_dim;
-    const int ctx_size      = hp.enc_context_size;
-    const int n_layers      = hp.enc_n_layers;
+    const int     conv_k    = hp.enc_conv_kernel_size;
+    const int     n_heads   = hp.enc_n_heads;
+    const int     head_dim  = hp.enc_head_dim;
+    const int     ctx_size  = hp.enc_context_size;
+    const int     n_layers  = hp.enc_n_layers;
 
     eb.mel_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, input_dim, T_enc);
     named(eb.mel_in, "enc.mel_in");
     ggml_set_input(eb.mel_in);
 
-    eb.attention_dists = ggml_new_tensor_1d(ctx, GGML_TYPE_I32,
-                                            static_cast<int64_t>(ctx_size) * ctx_size);
+    eb.attention_dists = ggml_new_tensor_1d(ctx, GGML_TYPE_I32, static_cast<int64_t>(ctx_size) * ctx_size);
     named(eb.attention_dists, "enc.attention_dists");
     ggml_set_input(eb.attention_dists);
 
-    eb.last_block_mask = ggml_new_tensor_3d(ctx, GGML_TYPE_F32,
-                                            ctx_size, ctx_size,
-                                            eb.n_blocks_local);
+    eb.last_block_mask = ggml_new_tensor_3d(ctx, GGML_TYPE_F32, ctx_size, ctx_size, eb.n_blocks_local);
     named(eb.last_block_mask, "enc.last_block_mask");
     ggml_set_input(eb.last_block_mask);
 
     if (T_pad > T_enc) {
-        eb.zero_pad = ggml_new_tensor_2d(ctx, GGML_TYPE_F32,
-                                         d_model, T_pad - T_enc);
+        eb.zero_pad = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, d_model, T_pad - T_enc);
         named(eb.zero_pad, "enc.zero_pad");
         ggml_set_input(eb.zero_pad);
     }
 
     // Input linear (160 -> 1024).
-    ggml_tensor * x = linear(ctx, eb.mel_in,
-                             weights.enc_top.input_linear_w,
-                             weights.enc_top.input_linear_b);
+    ggml_tensor * x = linear(ctx, eb.mel_in, weights.enc_top.input_linear_w, weights.enc_top.input_linear_b);
     named(x, "enc.input_linear.out");
     eb.dumps.input_linear_out = x;
     transcribe::debug::mark_tensor_for_dump(x);
@@ -280,9 +251,13 @@ EncoderBuild build_encoder_graph(ggml_context *            ctx,
     std::vector<int> capture_idx;
     capture_idx.reserve(hp.enc_layer_indices.size());
     for (int32_t li : hp.enc_layer_indices) {
-        if (li > 0)       capture_idx.push_back(li - 1);
-        else if (li < 0)  capture_idx.push_back(n_layers + li);
-        else              capture_idx.push_back(0);
+        if (li > 0) {
+            capture_idx.push_back(li - 1);
+        } else if (li < 0) {
+            capture_idx.push_back(n_layers + li);
+        } else {
+            capture_idx.push_back(0);
+        }
     }
 
     std::vector<ggml_tensor *> captures(capture_idx.size(), nullptr);
@@ -298,18 +273,15 @@ EncoderBuild build_encoder_graph(ggml_context *            ctx,
             transcribe::debug::mark_tensor_for_dump(x);
         }
 
-        const transcribe::granite_conformer::ShawAttnWeights shaw_w {
-            b.norm_attn_w, b.norm_attn_b,
-            b.attn_q_w, b.attn_kv_w, b.attn_rel_pos_emb,
-            b.attn_out_w, b.attn_out_b,
+        const transcribe::granite_conformer::ShawAttnWeights shaw_w{
+            b.norm_attn_w, b.norm_attn_b, b.attn_q_w, b.attn_kv_w, b.attn_rel_pos_emb, b.attn_out_w, b.attn_out_b,
         };
         ggml_tensor * attn_out = transcribe::granite_conformer::shaw_block_attn(
-            ctx, x,
-            eb.zero_pad, eb.attention_dists, eb.last_block_mask,
-            shaw_w,
-            n_heads, head_dim, ctx_size, eb.n_blocks_local, T_enc,
-            kLayerNormEps);
-        if (attn_out == nullptr) return eb;
+            ctx, x, eb.zero_pad, eb.attention_dists, eb.last_block_mask, shaw_w, n_heads, head_dim, ctx_size,
+            eb.n_blocks_local, T_enc, kLayerNormEps);
+        if (attn_out == nullptr) {
+            return eb;
+        }
         x = ggml_add(ctx, x, attn_out);
         if (i == 0) {
             named(x, "enc.block.0.post_attn");
@@ -317,10 +289,8 @@ EncoderBuild build_encoder_graph(ggml_context *            ctx,
             transcribe::debug::mark_tensor_for_dump(x);
         }
 
-        ggml_tensor * conv_out = conv_module(
-            ctx, x, b,
-            b.conv_bn_fused_scale, b.conv_bn_fused_bias,
-            conv_k, static_cast<int>(inner_dim));
+        ggml_tensor * conv_out =
+            conv_module(ctx, x, b, b.conv_bn_fused_scale, b.conv_bn_fused_bias, conv_k, static_cast<int>(inner_dim));
         x = ggml_add(ctx, x, conv_out);
         if (i == 0) {
             named(x, "enc.block.0.post_conv");
@@ -368,32 +338,31 @@ EncoderBuild build_encoder_graph(ggml_context *            ctx,
         // it for `importance = 1 - blank_prob_mid` per the reference.
         if ((i + 1) == bypass_after) {
             ggml_tensor * cl = ggml_mul_mat(ctx, weights.enc_top.ctc_proj_w, x);
-            cl = ggml_add(ctx, cl, weights.enc_top.ctc_proj_b);
+            cl               = ggml_add(ctx, cl, weights.enc_top.ctc_proj_b);
             // This is mid_logits in the reference modeling code:
             //   mid_logits = encoder.out(dropout(hidden))  at self_conditioning_layer
             // — the only place the char-CTC head is invoked by the model
             // forward. Dump it here as `enc.ctc_logits` so the C++ and ref
             // dumps capture the same semantic tensor.
             named(cl, "enc.ctc_logits");
-            eb.ctc_logits = cl;
+            eb.ctc_logits       = cl;
             eb.dumps.ctc_logits = cl;
             ggml_set_output(cl);
             transcribe::debug::mark_tensor_for_dump(cl);
-            ggml_tensor * cs = ggml_soft_max(ctx, cl);
+            ggml_tensor * cs         = ggml_soft_max(ctx, cl);
             // Slice the blank-token probability (channel 0). cs ne =
             // [n_ctc_vocab, T_enc]; view a [1, T_enc] window at offset 0
             // and reshape to [T_enc]. Element 0 of ne[0] is the blank.
-            ggml_tensor * blank_prob = ggml_view_2d(
-                ctx, cs, 1, T_enc, cs->nb[1], 0);
-            blank_prob = ggml_cont(ctx, blank_prob);
-            blank_prob = ggml_reshape_1d(ctx, blank_prob, T_enc);
+            ggml_tensor * blank_prob = ggml_view_2d(ctx, cs, 1, T_enc, cs->nb[1], 0);
+            blank_prob               = ggml_cont(ctx, blank_prob);
+            blank_prob               = ggml_reshape_1d(ctx, blank_prob, T_enc);
             named(blank_prob, "enc.mid_blank_probs");
             eb.mid_blank_probs = blank_prob;
             ggml_set_output(blank_prob);
 
             ggml_tensor * bypass = ggml_mul_mat(ctx, weights.enc_top.ctc_bypass_w, cs);
-            bypass = ggml_add(ctx, bypass, weights.enc_top.ctc_bypass_b);
-            x = ggml_add(ctx, x, bypass);
+            bypass               = ggml_add(ctx, bypass, weights.enc_top.ctc_bypass_b);
+            x                    = ggml_add(ctx, x, bypass);
         }
 
         // Multi-layer capture (matches reference's all_hidden_states
@@ -430,13 +399,15 @@ EncoderBuild build_encoder_graph(ggml_context *            ctx,
     ggml_tensor * cat = nullptr;
     for (size_t k = 0; k < captures.size(); ++k) {
         if (captures[k] == nullptr) {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "granite_nar encoder: missing capture for layer index %d",
-                         (int)hp.enc_layer_indices[k]);
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "granite_nar encoder: missing capture for layer index %d",
+                    (int) hp.enc_layer_indices[k]);
             return eb;
         }
-        if (cat == nullptr) cat = captures[k];
-        else cat = ggml_concat(ctx, cat, captures[k], /*dim=*/0);
+        if (cat == nullptr) {
+            cat = captures[k];
+        } else {
+            cat = ggml_concat(ctx, cat, captures[k], /*dim=*/0);
+        }
     }
     named(cat, "enc.cat_out");
     eb.cat_out = cat;
@@ -449,40 +420,59 @@ EncoderBuild build_encoder_graph(ggml_context *            ctx,
     }
     ggml_build_forward_expand(eb.graph, eb.cat_out);
     ggml_build_forward_expand(eb.graph, eb.ctc_logits);
-    if (eb.ctc_bpe_logits)  ggml_build_forward_expand(eb.graph, eb.ctc_bpe_logits);
-    if (eb.mid_blank_probs) ggml_build_forward_expand(eb.graph, eb.mid_blank_probs);
-    if (eb.dumps.input_linear_out) ggml_build_forward_expand(eb.graph, eb.dumps.input_linear_out);
-    if (eb.dumps.block_0_out)      ggml_build_forward_expand(eb.graph, eb.dumps.block_0_out);
-    if (eb.dumps.block_0_post_ff1)  ggml_build_forward_expand(eb.graph, eb.dumps.block_0_post_ff1);
-    if (eb.dumps.block_0_post_attn) ggml_build_forward_expand(eb.graph, eb.dumps.block_0_post_attn);
-    if (eb.dumps.block_0_post_conv) ggml_build_forward_expand(eb.graph, eb.dumps.block_0_post_conv);
-    if (eb.dumps.block_0_post_ff2)  ggml_build_forward_expand(eb.graph, eb.dumps.block_0_post_ff2);
-    if (eb.dumps.block_mid_pre)    ggml_build_forward_expand(eb.graph, eb.dumps.block_mid_pre);
-    if (eb.dumps.block_mid_post)   ggml_build_forward_expand(eb.graph, eb.dumps.block_mid_post);
-    if (eb.dumps.block_last_out)   ggml_build_forward_expand(eb.graph, eb.dumps.block_last_out);
+    if (eb.ctc_bpe_logits) {
+        ggml_build_forward_expand(eb.graph, eb.ctc_bpe_logits);
+    }
+    if (eb.mid_blank_probs) {
+        ggml_build_forward_expand(eb.graph, eb.mid_blank_probs);
+    }
+    if (eb.dumps.input_linear_out) {
+        ggml_build_forward_expand(eb.graph, eb.dumps.input_linear_out);
+    }
+    if (eb.dumps.block_0_out) {
+        ggml_build_forward_expand(eb.graph, eb.dumps.block_0_out);
+    }
+    if (eb.dumps.block_0_post_ff1) {
+        ggml_build_forward_expand(eb.graph, eb.dumps.block_0_post_ff1);
+    }
+    if (eb.dumps.block_0_post_attn) {
+        ggml_build_forward_expand(eb.graph, eb.dumps.block_0_post_attn);
+    }
+    if (eb.dumps.block_0_post_conv) {
+        ggml_build_forward_expand(eb.graph, eb.dumps.block_0_post_conv);
+    }
+    if (eb.dumps.block_0_post_ff2) {
+        ggml_build_forward_expand(eb.graph, eb.dumps.block_0_post_ff2);
+    }
+    if (eb.dumps.block_mid_pre) {
+        ggml_build_forward_expand(eb.graph, eb.dumps.block_mid_pre);
+    }
+    if (eb.dumps.block_mid_post) {
+        ggml_build_forward_expand(eb.graph, eb.dumps.block_mid_post);
+    }
+    if (eb.dumps.block_last_out) {
+        ggml_build_forward_expand(eb.graph, eb.dumps.block_last_out);
+    }
 
     return eb;
 }
 
 // Host-side BPE CTC pool + greedy decode.
 
-void compute_bpe_ctc_initial_hypothesis(
-    const std::vector<float> & importance_non_blank,
-    const std::vector<float> & ctc_bpe_logits,
-    int                        n_bpe_vocab,
-    int                        T_enc,
-    int                        pool_window,
-    int                        blank_id,
-    std::vector<int32_t> &     out_token_ids)
-{
+void compute_bpe_ctc_initial_hypothesis(const std::vector<float> & importance_non_blank,
+                                        const std::vector<float> & ctc_bpe_logits,
+                                        int                        n_bpe_vocab,
+                                        int                        T_enc,
+                                        int                        pool_window,
+                                        int                        blank_id,
+                                        std::vector<int32_t> &     out_token_ids) {
     out_token_ids.clear();
     if (T_enc <= 0 || pool_window <= 0 || n_bpe_vocab <= 0) {
         return;
     }
     if (static_cast<int>(importance_non_blank.size()) < T_enc) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "granite_nar BPE CTC: importance has %zu entries, need >= %d",
-                     importance_non_blank.size(), T_enc);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "granite_nar BPE CTC: importance has %zu entries, need >= %d",
+                importance_non_blank.size(), T_enc);
         return;
     }
     const std::vector<float> & non_blank = importance_non_blank;
@@ -491,23 +481,26 @@ void compute_bpe_ctc_initial_hypothesis(
     // total non-blank posterior is non-zero contribute. Within a window
     // we form a weighted sum of the BPE logits, weighted by per-frame
     // non_blank_prob, normalised by the sum of weights.
-    const int n_windows = (T_enc + pool_window - 1) / pool_window;
+    const int          n_windows = (T_enc + pool_window - 1) / pool_window;
     std::vector<float> pooled(static_cast<size_t>(n_windows) * n_bpe_vocab, 0.0f);
     std::vector<int>   valid(n_windows, 0);
     for (int w = 0; w < n_windows; ++w) {
-        const int t0 = w * pool_window;
-        const int t1 = std::min(t0 + pool_window, T_enc);
-        float total = 0.0f;
-        for (int t = t0; t < t1; ++t) total += non_blank[t];
+        const int t0    = w * pool_window;
+        const int t1    = std::min(t0 + pool_window, T_enc);
+        float     total = 0.0f;
+        for (int t = t0; t < t1; ++t) {
+            total += non_blank[t];
+        }
         if (total <= 1e-9f) {
             continue;  // all-blank window — emit a blank, which collapse drops
         }
         float * dst = pooled.data() + static_cast<size_t>(w) * n_bpe_vocab;
         for (int t = t0; t < t1; ++t) {
-            const float wt = non_blank[t] / total;
-            const float * row = ctc_bpe_logits.data() +
-                                static_cast<size_t>(t) * n_bpe_vocab;
-            for (int v = 0; v < n_bpe_vocab; ++v) dst[v] += wt * row[v];
+            const float   wt  = non_blank[t] / total;
+            const float * row = ctc_bpe_logits.data() + static_cast<size_t>(t) * n_bpe_vocab;
+            for (int v = 0; v < n_bpe_vocab; ++v) {
+                dst[v] += wt * row[v];
+            }
         }
         valid[w] = 1;
     }
@@ -519,10 +512,13 @@ void compute_bpe_ctc_initial_hypothesis(
     for (int w = 0; w < n_windows; ++w) {
         int argmax = blank_id;
         if (valid[w]) {
-            const float * dst = pooled.data() + static_cast<size_t>(w) * n_bpe_vocab;
-            float best = dst[0];
+            const float * dst  = pooled.data() + static_cast<size_t>(w) * n_bpe_vocab;
+            float         best = dst[0];
             for (int v = 1; v < n_bpe_vocab; ++v) {
-                if (dst[v] > best) { best = dst[v]; argmax = v; }
+                if (dst[v] > best) {
+                    best   = dst[v];
+                    argmax = v;
+                }
             }
         }
         if (argmax != blank_id && argmax != prev) {
@@ -539,4 +535,4 @@ void compute_bpe_ctc_initial_hypothesis(
     }
 }
 
-} // namespace transcribe::granite_nar
+}  // namespace transcribe::granite_nar
diff --git a/src/arch/granite_nar/encoder.h b/src/arch/granite_nar/encoder.h
index 36e29b53..a553180b 100644
--- a/src/arch/granite_nar/encoder.h
+++ b/src/arch/granite_nar/encoder.h
@@ -22,9 +22,8 @@
 
 #pragma once
 
-#include "weights.h"
-
 #include "ggml.h"
+#include "weights.h"
 
 #include <cstdint>
 #include <vector>
@@ -33,48 +32,49 @@ struct ggml_context;
 struct ggml_tensor;
 struct ggml_cgraph;
 
-namespace transcribe { class MelFrontend; }
+namespace transcribe {
+class MelFrontend;
+}
 
 namespace transcribe::granite_nar {
 
 // Host-side mel + 2-frame stack. Reuses the AR granite implementation.
-transcribe_status compute_mel_encoder_input(
-    const transcribe::MelFrontend & mel,
-    const float *                   pcm,
-    int                             n_samples,
-    int                             n_threads,
-    std::vector<float> &            out_mel,
-    int &                           out_t_enc);
+transcribe_status compute_mel_encoder_input(const transcribe::MelFrontend & mel,
+                                            const float *                   pcm,
+                                            int                             n_samples,
+                                            int                             n_threads,
+                                            std::vector<float> &            out_mel,
+                                            int &                           out_t_enc);
 
 struct EncoderBuild {
     // Graph inputs (caller uploads at compute time).
-    ggml_tensor * mel_in           = nullptr;  // [input_dim, T_enc]
-    ggml_tensor * attention_dists  = nullptr;  // [ctx*ctx] i32
-    ggml_tensor * last_block_mask  = nullptr;  // [ctx, ctx, n_blocks_local]
-    ggml_tensor * zero_pad         = nullptr;  // optional [hidden, T_pad-T_enc]
+    ggml_tensor * mel_in          = nullptr;  // [input_dim, T_enc]
+    ggml_tensor * attention_dists = nullptr;  // [ctx*ctx] i32
+    ggml_tensor * last_block_mask = nullptr;  // [ctx, ctx, n_blocks_local]
+    ggml_tensor * zero_pad        = nullptr;  // optional [hidden, T_pad-T_enc]
 
     // Outputs.
-    ggml_tensor * cat_out          = nullptr;  // [num_enc_layers * hidden, T_enc]
-                                               //  the projector input
-    ggml_tensor * ctc_logits       = nullptr;  // [enc_out_dim=348, T_enc]
-    ggml_tensor * ctc_bpe_logits   = nullptr;  // [bpe_output_dim, T_enc]
-                                               //  raw frame-level (no pool)
-    ggml_tensor * mid_blank_probs  = nullptr;  // [T_enc] — softmax(mid_ctc)[blank].
-                                               //  Used host-side as the BPE pool's
-                                               //  importance weight (importance =
-                                               //  1 - blank_prob_mid).
-
-    ggml_cgraph * graph            = nullptr;
+    ggml_tensor * cat_out         = nullptr;  // [num_enc_layers * hidden, T_enc]
+                                              //  the projector input
+    ggml_tensor * ctc_logits      = nullptr;  // [enc_out_dim=348, T_enc]
+    ggml_tensor * ctc_bpe_logits  = nullptr;  // [bpe_output_dim, T_enc]
+                                              //  raw frame-level (no pool)
+    ggml_tensor * mid_blank_probs = nullptr;  // [T_enc] — softmax(mid_ctc)[blank].
+                                              //  Used host-side as the BPE pool's
+                                              //  importance weight (importance =
+                                              //  1 - blank_prob_mid).
+
+    ggml_cgraph * graph = nullptr;
 
     struct Dumps {
-        ggml_tensor * input_linear_out = nullptr;
-        ggml_tensor * block_0_out      = nullptr;
-        ggml_tensor * block_mid_pre    = nullptr;  // block (N/2 - 1) post-LN
-                                                   // (== `enc.block.7.out`)
-        ggml_tensor * block_mid_post   = nullptr;  // block (N/2)   post-LN
-                                                   // (== `enc.block.8.out`)
-        ggml_tensor * block_last_out   = nullptr;  // block (N-1)
-        ggml_tensor * ctc_logits       = nullptr;  // == ctc_logits, named
+        ggml_tensor * input_linear_out  = nullptr;
+        ggml_tensor * block_0_out       = nullptr;
+        ggml_tensor * block_mid_pre     = nullptr;  // block (N/2 - 1) post-LN
+                                                    // (== `enc.block.7.out`)
+        ggml_tensor * block_mid_post    = nullptr;  // block (N/2)   post-LN
+                                                    // (== `enc.block.8.out`)
+        ggml_tensor * block_last_out    = nullptr;  // block (N-1)
+        ggml_tensor * ctc_logits        = nullptr;  // == ctc_logits, named
         // Block-0 sub-step taps.
         ggml_tensor * block_0_post_ff1  = nullptr;
         ggml_tensor * block_0_post_attn = nullptr;
@@ -123,13 +123,12 @@ std::vector<float>   precompute_last_block_mask(int context_size, int t_enc_rema
 // window are weighted by the (softmaxed) CTC non-blank posterior, then a
 // greedy argmax + collapse-repeats + drop-blanks yields the hypothesis. See
 // the implementation in encoder.cpp.
-void compute_bpe_ctc_initial_hypothesis(
-    const std::vector<float> & importance_non_blank,
-    const std::vector<float> & ctc_bpe_logits,
-    int                        n_bpe_vocab,
-    int                        T_enc,
-    int                        pool_window,
-    int                        blank_id,
-    std::vector<int32_t> &     out_token_ids);
-
-} // namespace transcribe::granite_nar
+void compute_bpe_ctc_initial_hypothesis(const std::vector<float> & importance_non_blank,
+                                        const std::vector<float> & ctc_bpe_logits,
+                                        int                        n_bpe_vocab,
+                                        int                        T_enc,
+                                        int                        pool_window,
+                                        int                        blank_id,
+                                        std::vector<int32_t> &     out_token_ids);
+
+}  // namespace transcribe::granite_nar
diff --git a/src/arch/granite_nar/granite_nar.h b/src/arch/granite_nar/granite_nar.h
index cb055b11..c5ab20a0 100644
--- a/src/arch/granite_nar/granite_nar.h
+++ b/src/arch/granite_nar/granite_nar.h
@@ -10,16 +10,15 @@
 
 #pragma once
 
+#include "ggml-backend.h"
+#include "ggml.h"
 #include "transcribe-backend.h"
-#include "transcribe-session.h"
 #include "transcribe-mel.h"
 #include "transcribe-model.h"
+#include "transcribe-session.h"
 #include "transcribe-tokenizer.h"
 #include "weights.h"
 
-#include "ggml.h"
-#include "ggml-backend.h"
-
 #include <cstdint>
 #include <optional>
 #include <string>
@@ -36,10 +35,10 @@ namespace transcribe::granite_nar {
 void apply_family_invariants(transcribe_model & model);
 
 struct GraniteNarModel final : public transcribe_model {
-    Tokenizer        tok;
+    Tokenizer         tok;
     GraniteNarHParams hparams;
     GraniteNarWeights weights;
-    ggml_context *   ctx_meta = nullptr;
+    ggml_context *    ctx_meta = nullptr;
 
     transcribe::BackendPlan plan;
     ggml_backend_buffer_t   backend_buffer = nullptr;
@@ -62,14 +61,13 @@ struct GraniteNarSession final : public transcribe_session {
 
     // Encoder output buffered between encode and projector/LM.
     std::vector<float> mel_buf;
-    std::vector<float> enc_cat_host;      // [T_enc, num_encoder_layers * enc_hidden]
-    std::vector<float> ctc_logits_host;   // [T_enc, output_dim]
-    std::vector<float> ctc_bpe_logits_host; // [N_valid, bpe_output_dim] flat
-    std::vector<float> proj_out_host;     // [n_audio_tokens, llm_dim]
+    std::vector<float> enc_cat_host;         // [T_enc, num_encoder_layers * enc_hidden]
+    std::vector<float> ctc_logits_host;      // [T_enc, output_dim]
+    std::vector<float> ctc_bpe_logits_host;  // [N_valid, bpe_output_dim] flat
+    std::vector<float> proj_out_host;        // [n_audio_tokens, llm_dim]
     int32_t            t_enc          = 0;
     int32_t            n_audio_tokens = 0;
 
-
     bool encoder_use_flash = false;
     bool decoder_use_flash = false;  // bidirectional path doesn't use flash-attn KV cache
 
@@ -77,4 +75,4 @@ struct GraniteNarSession final : public transcribe_session {
     ~GraniteNarSession() override;
 };
 
-} // namespace transcribe::granite_nar
+}  // namespace transcribe::granite_nar
diff --git a/src/arch/granite_nar/model.cpp b/src/arch/granite_nar/model.cpp
index 7f0efc07..48699d8f 100644
--- a/src/arch/granite_nar/model.cpp
+++ b/src/arch/granite_nar/model.cpp
@@ -17,13 +17,13 @@
 //     concatenated to the front of inputs_embeds) -> text_logits ->
 //     argmax + collapse + drop EOS -> final transcript.
 
-#include "granite_nar.h"
-
 #include "decoder.h"
 #include "encoder.h"
+#include "ggml-backend.h"
+#include "ggml.h"
+#include "gguf.h"
+#include "granite_nar.h"
 #include "projector.h"
-#include "weights.h"
-
 #include "transcribe-arch.h"
 #include "transcribe-batch-util.h"
 #include "transcribe-debug.h"
@@ -33,10 +33,7 @@
 #include "transcribe-log.h"
 #include "transcribe-mel.h"
 #include "transcribe-meta.h"
-
-#include "ggml.h"
-#include "ggml-backend.h"
-#include "gguf.h"
+#include "weights.h"
 
 #include <algorithm>
 #include <cmath>
@@ -52,7 +49,7 @@ namespace transcribe::granite_nar {
 
 extern const Arch arch;
 
-static_assert(std::is_base_of_v<transcribe_model,   GraniteNarModel>);
+static_assert(std::is_base_of_v<transcribe_model, GraniteNarModel>);
 static_assert(std::is_base_of_v<transcribe_session, GraniteNarSession>);
 
 GraniteNarSession::~GraniteNarSession() {
@@ -83,9 +80,7 @@ GraniteNarModel::~GraniteNarModel() {
         ggml_backend_buffer_free(backend_buffer);
         backend_buffer = nullptr;
     }
-    for (auto it = plan.scheduler_list.rbegin();
-         it != plan.scheduler_list.rend(); ++it)
-    {
+    for (auto it = plan.scheduler_list.rbegin(); it != plan.scheduler_list.rend(); ++it) {
         ggml_backend_free(*it);
     }
     plan.scheduler_list.clear();
@@ -96,7 +91,7 @@ GraniteNarModel::~GraniteNarModel() {
 namespace {
 
 constexpr const char k_default_variant[] = "granite-speech-nar";
-constexpr float kBnEps = 1e-5f;
+constexpr float      kBnEps              = 1e-5f;
 
 // Input-length contract (see docs/input-limits.md). granite_nar is a
 // hard-context-cap family: the bidirectional editor runs a SINGLE forward
@@ -144,8 +139,7 @@ int granite_nar_num_queries(const GraniteNarHParams & hp) {
 // prompt + generation reserve.
 int64_t granite_nar_max_audio_ms(const GraniteNarHParams & hp) {
     const int num_queries = granite_nar_num_queries(hp);
-    if (num_queries <= 0 || hp.prj_block_size <= 0 ||
-        hp.fe_hop_length <= 0 || hp.fe_sample_rate <= 0 ||
+    if (num_queries <= 0 || hp.prj_block_size <= 0 || hp.fe_hop_length <= 0 || hp.fe_sample_rate <= 0 ||
         hp.dec_max_pos_emb <= 0) {
         return 0;
     }
@@ -164,36 +158,34 @@ int64_t granite_nar_max_audio_ms(const GraniteNarHParams & hp) {
 
 transcribe_status fuse_batch_norm(GraniteNarModel & m) {
     const size_t n_blocks = m.weights.enc_blocks.size();
-    if (n_blocks == 0) return TRANSCRIBE_OK;
+    if (n_blocks == 0) {
+        return TRANSCRIBE_OK;
+    }
 
-    const int64_t inner = static_cast<int64_t>(m.hparams.enc_hidden) *
-                          m.hparams.enc_conv_expansion;
-    const size_t tensor_bytes = static_cast<size_t>(inner) * sizeof(float);
+    const int64_t inner        = static_cast<int64_t>(m.hparams.enc_hidden) * m.hparams.enc_conv_expansion;
+    const size_t  tensor_bytes = static_cast<size_t>(inner) * sizeof(float);
 
-    const size_t ctx_size = n_blocks * 2 * ggml_tensor_overhead() + 256;
-    ggml_init_params params = { ctx_size, nullptr, /*no_alloc=*/true };
-    m.bn_fused_ctx = ggml_init(params);
+    const size_t     ctx_size = n_blocks * 2 * ggml_tensor_overhead() + 256;
+    ggml_init_params params   = { ctx_size, nullptr, /*no_alloc=*/true };
+    m.bn_fused_ctx            = ggml_init(params);
     if (m.bn_fused_ctx == nullptr) {
         transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "granite_nar: BatchNorm-fusion context allocation failed — "
-            "out of memory.");
+                            "granite_nar: BatchNorm-fusion context allocation failed — "
+                            "out of memory.");
         return TRANSCRIBE_ERR_OOM;
     }
 
     for (size_t i = 0; i < n_blocks; ++i) {
-        auto & b = m.weights.enc_blocks[i];
-        b.conv_bn_fused_scale = ggml_new_tensor_1d(m.bn_fused_ctx,
-                                                   GGML_TYPE_F32, inner);
-        b.conv_bn_fused_bias  = ggml_new_tensor_1d(m.bn_fused_ctx,
-                                                   GGML_TYPE_F32, inner);
+        auto & b              = m.weights.enc_blocks[i];
+        b.conv_bn_fused_scale = ggml_new_tensor_1d(m.bn_fused_ctx, GGML_TYPE_F32, inner);
+        b.conv_bn_fused_bias  = ggml_new_tensor_1d(m.bn_fused_ctx, GGML_TYPE_F32, inner);
     }
 
-    m.bn_fused_buffer = ggml_backend_alloc_ctx_tensors(
-        m.bn_fused_ctx, m.plan.scheduler_list.back());
+    m.bn_fused_buffer = ggml_backend_alloc_ctx_tensors(m.bn_fused_ctx, m.plan.scheduler_list.back());
     if (m.bn_fused_buffer == nullptr) {
         transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "granite_nar: BatchNorm-fusion buffer allocation failed — "
-            "out of memory.");
+                            "granite_nar: BatchNorm-fusion buffer allocation failed — "
+                            "out of memory.");
         return TRANSCRIBE_ERR_OOM;
     }
 
@@ -201,31 +193,25 @@ transcribe_status fuse_batch_norm(GraniteNarModel & m) {
     std::vector<float> fused_s(inner), fused_b(inner);
     for (size_t i = 0; i < n_blocks; ++i) {
         auto & b = m.weights.enc_blocks[i];
-        ggml_backend_tensor_get(b.conv_bn_w,    bn_w.data(), 0, tensor_bytes);
-        ggml_backend_tensor_get(b.conv_bn_b,    bn_b.data(), 0, tensor_bytes);
-        ggml_backend_tensor_get(b.conv_bn_mean, rm.data(),   0, tensor_bytes);
-        ggml_backend_tensor_get(b.conv_bn_var,  rv.data(),   0, tensor_bytes);
+        ggml_backend_tensor_get(b.conv_bn_w, bn_w.data(), 0, tensor_bytes);
+        ggml_backend_tensor_get(b.conv_bn_b, bn_b.data(), 0, tensor_bytes);
+        ggml_backend_tensor_get(b.conv_bn_mean, rm.data(), 0, tensor_bytes);
+        ggml_backend_tensor_get(b.conv_bn_var, rv.data(), 0, tensor_bytes);
         for (int64_t c = 0; c < inner; ++c) {
             const float s = bn_w[c] / std::sqrt(rv[c] + kBnEps);
-            fused_s[c] = s;
-            fused_b[c] = bn_b[c] - rm[c] * s;
+            fused_s[c]    = s;
+            fused_b[c]    = bn_b[c] - rm[c] * s;
         }
-        ggml_backend_tensor_set(b.conv_bn_fused_scale, fused_s.data(),
-                                0, tensor_bytes);
-        ggml_backend_tensor_set(b.conv_bn_fused_bias,  fused_b.data(),
-                                0, tensor_bytes);
+        ggml_backend_tensor_set(b.conv_bn_fused_scale, fused_s.data(), 0, tensor_bytes);
+        ggml_backend_tensor_set(b.conv_bn_fused_bias, fused_b.data(), 0, tensor_bytes);
     }
     return TRANSCRIBE_OK;
 }
 
-transcribe_status load(
-    Loader &                         loader,
-    const transcribe_model_load_params *  params,
-    transcribe_model **              out_model)
-{
+transcribe_status load(Loader & loader, const transcribe_model_load_params * params, transcribe_model ** out_model) {
     const int64_t t_load_start = ggml_time_us();
 
-    auto m = std::make_unique<GraniteNarModel>();
+    auto m       = std::make_unique<GraniteNarModel>();
     m->arch      = &arch;
     m->t_load_us = 0;
     m->variant   = loader.variant().empty() ? k_default_variant : loader.variant();
@@ -235,16 +221,20 @@ transcribe_status load(
     m->caps.n_languages = 0;
     m->caps.languages   = nullptr;
 
-    if (const transcribe_status st = read_capability_kv(loader.gguf(), m->caps);
-        st != TRANSCRIBE_OK) return st;
-    if (const transcribe_status st = read_languages_kv(loader.gguf(), *m);
-        st != TRANSCRIBE_OK) return st;
+    if (const transcribe_status st = read_capability_kv(loader.gguf(), m->caps); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (const transcribe_status st = read_languages_kv(loader.gguf(), *m); st != TRANSCRIBE_OK) {
+        return st;
+    }
 
-    if (const transcribe_status st = m->tok.load(loader.gguf());
-        st != TRANSCRIBE_OK) return st;
+    if (const transcribe_status st = m->tok.load(loader.gguf()); st != TRANSCRIBE_OK) {
+        return st;
+    }
 
-    if (const transcribe_status st = read_granite_nar_hparams(loader.gguf(), m->hparams);
-        st != TRANSCRIBE_OK) return st;
+    if (const transcribe_status st = read_granite_nar_hparams(loader.gguf(), m->hparams); st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     m->hparams.dec_bos_id = m->tok.bos_id();
     m->hparams.dec_eos_id = m->tok.eos_id();
@@ -254,9 +244,8 @@ transcribe_status load(
         return TRANSCRIBE_ERR_GGUF;
     }
     if (m->tok.n_tokens() != m->hparams.dec_vocab_size) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "granite_nar: tokenizer vocab (%d) != dec_vocab_size (%d)",
-                     m->tok.n_tokens(), m->hparams.dec_vocab_size);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "granite_nar: tokenizer vocab (%d) != dec_vocab_size (%d)",
+                m->tok.n_tokens(), m->hparams.dec_vocab_size);
         return TRANSCRIBE_ERR_GGUF;
     }
 
@@ -277,23 +266,20 @@ transcribe_status load(
     // basis stays unset (zero model_max_ctx => the query reports "unbounded").
     {
         const int num_queries = granite_nar_num_queries(m->hparams);
-        if (num_queries > 0 && m->hparams.prj_block_size > 0 &&
-            m->hparams.fe_hop_length > 0 && m->hparams.fe_sample_rate > 0 &&
-            m->hparams.dec_max_pos_emb > 0) {
-            m->limits.has_context_cap = true;
-            m->limits.model_max_ctx   = m->hparams.dec_max_pos_emb;
-            m->limits.prompt_overhead = 0;             // text reserved via gen_reserve
-            m->limits.gen_reserve     = k_text_budget;  // match granite_nar_max_audio_ms
+        if (num_queries > 0 && m->hparams.prj_block_size > 0 && m->hparams.fe_hop_length > 0 &&
+            m->hparams.fe_sample_rate > 0 && m->hparams.dec_max_pos_emb > 0) {
+            m->limits.has_context_cap    = true;
+            m->limits.model_max_ctx      = m->hparams.dec_max_pos_emb;
+            m->limits.prompt_overhead    = 0;              // text reserved via gen_reserve
+            m->limits.gen_reserve        = k_text_budget;  // match granite_nar_max_audio_ms
             // ms per audio token: granite_nar emits num_queries tokens per
             // prj_block_size encoder frames; t_enc = mel_frames/2;
             // mel_frames = ms*sr/(hop*1000). Inverting
             // granite_nar_max_audio_ms's forward rate gives ms-per-audio-token.
-            m->limits.ms_per_audio_token =
-                (static_cast<double>(m->hparams.prj_block_size) / num_queries) *
-                2.0 * m->hparams.fe_hop_length * 1000.0 / m->hparams.fe_sample_rate;
+            m->limits.ms_per_audio_token = (static_cast<double>(m->hparams.prj_block_size) / num_queries) * 2.0 *
+                                           m->hparams.fe_hop_length * 1000.0 / m->hparams.fe_sample_rate;
             m->limits.kv_elems_per_ctx_token =
-                (int64_t) m->hparams.dec_n_kv_heads *
-                m->hparams.dec_head_dim * m->hparams.dec_n_layers * 2;
+                (int64_t) m->hparams.dec_n_kv_heads * m->hparams.dec_head_dim * m->hparams.dec_n_layers * 2;
         }
     }
 
@@ -303,7 +289,7 @@ transcribe_status load(
     // upstream WhisperFeatureExtractor doesn't expose them; we hardcode
     // the equivalent defaults here).
     {
-        transcribe::MelConfig cfg {};
+        transcribe::MelConfig cfg{};
         cfg.sample_rate  = m->hparams.fe_sample_rate;
         cfg.num_mels     = m->hparams.fe_num_mels;
         cfg.n_fft        = m->hparams.fe_n_fft;
@@ -318,22 +304,16 @@ transcribe_status load(
 
         // Frontend buffers baked by the converter.
         {
-            using R = transcribe::load_common::ReadF32Result;
-            const size_t fb_elems =
-                static_cast<size_t>(cfg.num_mels) *
-                static_cast<size_t>(cfg.n_fft / 2 + 1);
-            const auto fb_rc = transcribe::load_common::read_f32_tensor_checked(
-                loader.gguf(), loader.path(),
-                "frontend.mel_filterbank", fb_elems,
-                "granite_nar", cfg.filterbank);
+            using R               = transcribe::load_common::ReadF32Result;
+            const size_t fb_elems = static_cast<size_t>(cfg.num_mels) * static_cast<size_t>(cfg.n_fft / 2 + 1);
+            const auto   fb_rc    = transcribe::load_common::read_f32_tensor_checked(
+                loader.gguf(), loader.path(), "frontend.mel_filterbank", fb_elems, "granite_nar", cfg.filterbank);
             if (fb_rc != R::Ok && fb_rc != R::Absent) {
                 return TRANSCRIBE_ERR_GGUF;
             }
             const size_t win_elems = static_cast<size_t>(cfg.win_length);
-            const auto win_rc = transcribe::load_common::read_f32_tensor_checked(
-                loader.gguf(), loader.path(),
-                "frontend.window", win_elems,
-                "granite_nar", cfg.window);
+            const auto   win_rc    = transcribe::load_common::read_f32_tensor_checked(
+                loader.gguf(), loader.path(), "frontend.window", win_elems, "granite_nar", cfg.window);
             if (win_rc != R::Ok && win_rc != R::Absent) {
                 return TRANSCRIBE_ERR_GGUF;
             }
@@ -343,49 +323,43 @@ transcribe_status load(
     }
 
     // Tensor catalog.
-    gguf_init_params init_params {};
+    gguf_init_params init_params{};
     init_params.no_alloc = true;
     init_params.ctx      = &m->ctx_meta;
 
-    gguf_context * gguf_data = gguf_init_from_file(loader.path().c_str(),
-                                                   init_params);
-    if (gguf_data == nullptr) return TRANSCRIBE_ERR_GGUF;
+    gguf_context * gguf_data = gguf_init_from_file(loader.path().c_str(), init_params);
+    if (gguf_data == nullptr) {
+        return TRANSCRIBE_ERR_GGUF;
+    }
 
-    if (const transcribe_status st = build_granite_nar_weights(
-            m->ctx_meta, m->hparams, m->weights);
-        st != TRANSCRIBE_OK)
-    {
+    if (const transcribe_status st = build_granite_nar_weights(m->ctx_meta, m->hparams, m->weights);
+        st != TRANSCRIBE_OK) {
         gguf_free(gguf_data);
         return st;
     }
 
-    const transcribe_backend_request backend_req =
-        (params != nullptr) ? params->backend : TRANSCRIBE_BACKEND_AUTO;
+    const transcribe_backend_request backend_req = (params != nullptr) ? params->backend : TRANSCRIBE_BACKEND_AUTO;
     if (const transcribe_status st = transcribe::load_common::init_backends(
             backend_req, (params != nullptr) ? params->gpu_device : 0, "granite_nar", m->plan);
-        st != TRANSCRIBE_OK)
-    {
+        st != TRANSCRIBE_OK) {
         gguf_free(gguf_data);
         return st;
     }
-    m->backend = ggml_backend_name(m->plan.primary);
+    m->backend         = ggml_backend_name(m->plan.primary);
     m->primary_backend = m->plan.primary;
 
-    ggml_backend_buffer_t weights_buffer =
-        ggml_backend_alloc_ctx_tensors(m->ctx_meta, m->plan.primary);
+    ggml_backend_buffer_t weights_buffer = ggml_backend_alloc_ctx_tensors(m->ctx_meta, m->plan.primary);
     if (weights_buffer == nullptr) {
         gguf_free(gguf_data);
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "granite_nar: alloc_ctx_tensors failed");
         return TRANSCRIBE_ERR_GGUF;
     }
     m->backend_buffer = weights_buffer;
-    ggml_backend_buffer_set_usage(weights_buffer,
-                                  GGML_BACKEND_BUFFER_USAGE_WEIGHTS);
+    ggml_backend_buffer_set_usage(weights_buffer, GGML_BACKEND_BUFFER_USAGE_WEIGHTS);
 
-    if (const transcribe_status st = transcribe::load_common::stream_tensor_data(
-            loader.path(), gguf_data, m->ctx_meta, "granite_nar");
-        st != TRANSCRIBE_OK)
-    {
+    if (const transcribe_status st =
+            transcribe::load_common::stream_tensor_data(loader.path(), gguf_data, m->ctx_meta, "granite_nar");
+        st != TRANSCRIBE_OK) {
         gguf_free(gguf_data);
         return st;
     }
@@ -396,26 +370,25 @@ transcribe_status load(
     }
 
     m->t_load_us = ggml_time_us() - t_load_start;
-    *out_model = m.release();
+    *out_model   = m.release();
     return TRANSCRIBE_OK;
 }
 
-transcribe_status init_context(
-    transcribe_model *                model,
-    const transcribe_session_params * params,
-    transcribe_session **             out_ctx)
-{
-    if (model->arch != &arch) return TRANSCRIBE_ERR_INVALID_ARG;
-
-    auto cc = std::make_unique<GraniteNarSession>();
-    cc->model     = model;
-    cc->n_threads = params->n_threads;
-    cc->kv_type   = params->kv_type;
-    cc->n_ctx     = transcribe_session_params_n_ctx(params);
+transcribe_status init_context(transcribe_model *                model,
+                               const transcribe_session_params * params,
+                               transcribe_session **             out_ctx) {
+    if (model->arch != &arch) {
+        return TRANSCRIBE_ERR_INVALID_ARG;
+    }
+
+    auto cc               = std::make_unique<GraniteNarSession>();
+    cc->model             = model;
+    cc->n_threads         = params->n_threads;
+    cc->kv_type           = params->kv_type;
+    cc->n_ctx             = transcribe_session_params_n_ctx(params);
     cc->encoder_use_flash = false;
     cc->decoder_use_flash = false;  // bidirectional path doesn't use KV cache
-    transcribe::flash::apply_env_overrides(cc->encoder_use_flash,
-                                           cc->decoder_use_flash);
+    transcribe::flash::apply_env_overrides(cc->encoder_use_flash, cc->decoder_use_flash);
 
     *out_ctx = cc.release();
     return TRANSCRIBE_OK;
@@ -427,15 +400,13 @@ void apply_thread_count(ggml_backend_sched_t sched, int n_threads) {
     transcribe::configure_sched_n_threads(sched, n_threads);
 }
 
-} // namespace
+}  // namespace
 
-transcribe_status run(
-    transcribe_session *      ctx_base,
-    const float *             pcm,
-    int                       n_samples,
-    const transcribe_run_params * params)
-{
-    (void)params;  // NLE has no language / task knobs
+transcribe_status run(transcribe_session *          ctx_base,
+                      const float *                 pcm,
+                      int                           n_samples,
+                      const transcribe_run_params * params) {
+    (void) params;  // NLE has no language / task knobs
 
     if (ctx_base == nullptr || pcm == nullptr || n_samples <= 0) {
         return TRANSCRIBE_ERR_INVALID_ARG;
@@ -452,25 +423,20 @@ transcribe_status run(
 
     // Mel + 2-frame stack.
     const int64_t t_mel_start = ggml_time_us();
-    int t_enc = 0;
-    if (const transcribe_status mst = compute_mel_encoder_input(
-            *cm->mel, pcm, n_samples, cc->n_threads, cc->mel_buf, t_enc);
-        mst != TRANSCRIBE_OK)
-    {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "granite_nar run: mel/stack failed (%s)",
-                     transcribe_status_string(mst));
+    int           t_enc       = 0;
+    if (const transcribe_status mst =
+            compute_mel_encoder_input(*cm->mel, pcm, n_samples, cc->n_threads, cc->mel_buf, t_enc);
+        mst != TRANSCRIBE_OK) {
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "granite_nar run: mel/stack failed (%s)", transcribe_status_string(mst));
         return mst;
     }
-    cc->t_enc = t_enc;
+    cc->t_enc    = t_enc;
     cc->t_mel_us = ggml_time_us() - t_mel_start;
 
     if (transcribe::debug::enabled()) {
         const long long shape[2] = { t_enc, cm->hparams.enc_input_dim };
-        transcribe::debug::dump_host_f32(
-            "enc.mel.in", cc->mel_buf.data(),
-            static_cast<long long>(cc->mel_buf.size()),
-            shape, 2, "encoder");
+        transcribe::debug::dump_host_f32("enc.mel.in", cc->mel_buf.data(), static_cast<long long>(cc->mel_buf.size()),
+                                         shape, 2, "encoder");
     }
 
     // Reset compute state.
@@ -479,32 +445,28 @@ transcribe_status run(
         cc->compute_ctx = nullptr;
     }
     {
-        ggml_init_params ip {};
-        ip.mem_size   = 32 * 1024 * 1024;
-        ip.mem_buffer = nullptr;
-        ip.no_alloc   = true;
+        ggml_init_params ip{};
+        ip.mem_size     = 32 * 1024 * 1024;
+        ip.mem_buffer   = nullptr;
+        ip.no_alloc     = true;
         cc->compute_ctx = ggml_init(ip);
         if (cc->compute_ctx == nullptr) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "granite_nar run: compute context allocation failed — "
-                "out of memory.");
+                                "granite_nar run: compute context allocation failed — "
+                                "out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
     }
 
     // Encoder graph.
-    EncoderBuild eb = build_encoder_graph(cc->compute_ctx, cm->weights,
-                                          cm->hparams, t_enc,
-                                          cc->encoder_use_flash);
+    EncoderBuild eb = build_encoder_graph(cc->compute_ctx, cm->weights, cm->hparams, t_enc, cc->encoder_use_flash);
     if (eb.graph == nullptr || eb.cat_out == nullptr) {
         return TRANSCRIBE_ERR_GGUF;
     }
 
     if (cc->sched == nullptr) {
-        cc->sched = ggml_backend_sched_new(
-            cm->plan.scheduler_list.data(), nullptr,
-            static_cast<int>(cm->plan.scheduler_list.size()),
-            32768, false, true);
+        cc->sched = ggml_backend_sched_new(cm->plan.scheduler_list.data(), nullptr,
+                                           static_cast<int>(cm->plan.scheduler_list.size()), 32768, false, true);
         if (cc->sched == nullptr) {
             log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "granite_nar run: sched_new failed");
             return TRANSCRIBE_ERR_GGUF;
@@ -513,82 +475,74 @@ transcribe_status run(
     ggml_backend_sched_reset(cc->sched);
     if (!ggml_backend_sched_alloc_graph(cc->sched, eb.graph)) {
         transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "granite_nar run: encoder graph allocation failed — out of memory.");
+                            "granite_nar run: encoder graph allocation failed — out of memory.");
         return TRANSCRIBE_ERR_OOM;
     }
 
     // Upload encoder inputs.
-    ggml_backend_tensor_set(eb.mel_in, cc->mel_buf.data(), 0,
-                            cc->mel_buf.size() * sizeof(float));
+    ggml_backend_tensor_set(eb.mel_in, cc->mel_buf.data(), 0, cc->mel_buf.size() * sizeof(float));
     {
-        std::vector<int32_t> dists = precompute_attention_dists(
-            cm->hparams.enc_context_size, cm->hparams.enc_max_pos_emb);
-        ggml_backend_tensor_set(eb.attention_dists, dists.data(), 0,
-                                dists.size() * sizeof(int32_t));
+        std::vector<int32_t> dists =
+            precompute_attention_dists(cm->hparams.enc_context_size, cm->hparams.enc_max_pos_emb);
+        ggml_backend_tensor_set(eb.attention_dists, dists.data(), 0, dists.size() * sizeof(int32_t));
     }
     {
-        const int ctx_size = cm->hparams.enc_context_size;
-        const size_t plane = static_cast<size_t>(ctx_size) * ctx_size;
+        const int          ctx_size = cm->hparams.enc_context_size;
+        const size_t       plane    = static_cast<size_t>(ctx_size) * ctx_size;
         std::vector<float> mask(plane * eb.n_blocks_local, 0.0f);
-        const int rem = eb.last_block_rem;
+        const int          rem = eb.last_block_rem;
         if (rem > 0 && rem < ctx_size) {
             std::vector<float> last = precompute_last_block_mask(ctx_size, rem);
-            std::memcpy(mask.data() + plane * (eb.n_blocks_local - 1),
-                        last.data(), plane * sizeof(float));
+            std::memcpy(mask.data() + plane * (eb.n_blocks_local - 1), last.data(), plane * sizeof(float));
         }
-        ggml_backend_tensor_set(eb.last_block_mask, mask.data(), 0,
-                                mask.size() * sizeof(float));
+        ggml_backend_tensor_set(eb.last_block_mask, mask.data(), 0, mask.size() * sizeof(float));
     }
     if (eb.zero_pad != nullptr) {
-        const size_t n_elems = static_cast<size_t>(eb.zero_pad->ne[0]) *
-                               eb.zero_pad->ne[1];
+        const size_t       n_elems = static_cast<size_t>(eb.zero_pad->ne[0]) * eb.zero_pad->ne[1];
         std::vector<float> zeros(n_elems, 0.0f);
-        ggml_backend_tensor_set(eb.zero_pad, zeros.data(), 0,
-                                zeros.size() * sizeof(float));
+        ggml_backend_tensor_set(eb.zero_pad, zeros.data(), 0, zeros.size() * sizeof(float));
     }
 
     apply_thread_count(cc->sched, cc->n_threads);
 
     const int64_t t_enc_start = ggml_time_us();
-    if (const ggml_status gs =
-            ggml_backend_sched_graph_compute(cc->sched, eb.graph);
-        gs != GGML_STATUS_SUCCESS)
-    {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "granite_nar run: encoder compute failed (%d)",
-                     static_cast<int>(gs));
+    if (const ggml_status gs = ggml_backend_sched_graph_compute(cc->sched, eb.graph); gs != GGML_STATUS_SUCCESS) {
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "granite_nar run: encoder compute failed (%d)", static_cast<int>(gs));
         return TRANSCRIBE_ERR_GGUF;
     }
     cc->t_encode_us = ggml_time_us() - t_enc_start;
 
     auto try_dump = [](const char * name, ggml_tensor * t, const char * stage) {
-        if (t != nullptr) transcribe::debug::dump_tensor(name, t, stage);
+        if (t != nullptr) {
+            transcribe::debug::dump_tensor(name, t, stage);
+        }
     };
     try_dump("enc.input_linear.out", eb.dumps.input_linear_out, "encoder");
-    try_dump("enc.block.0.post_ff1",  eb.dumps.block_0_post_ff1,  "encoder");
+    try_dump("enc.block.0.post_ff1", eb.dumps.block_0_post_ff1, "encoder");
     try_dump("enc.block.0.post_attn", eb.dumps.block_0_post_attn, "encoder");
     try_dump("enc.block.0.post_conv", eb.dumps.block_0_post_conv, "encoder");
-    try_dump("enc.block.0.post_ff2",  eb.dumps.block_0_post_ff2,  "encoder");
-    try_dump("enc.block.0.out",      eb.dumps.block_0_out,      "encoder");
-    if (eb.dumps.block_mid_pre)  try_dump(eb.dumps.block_mid_pre->name,
-                                          eb.dumps.block_mid_pre,  "encoder");
-    if (eb.dumps.block_mid_post) try_dump(eb.dumps.block_mid_post->name,
-                                          eb.dumps.block_mid_post, "encoder");
-    if (eb.dumps.block_last_out) try_dump(eb.dumps.block_last_out->name,
-                                          eb.dumps.block_last_out, "encoder");
+    try_dump("enc.block.0.post_ff2", eb.dumps.block_0_post_ff2, "encoder");
+    try_dump("enc.block.0.out", eb.dumps.block_0_out, "encoder");
+    if (eb.dumps.block_mid_pre) {
+        try_dump(eb.dumps.block_mid_pre->name, eb.dumps.block_mid_pre, "encoder");
+    }
+    if (eb.dumps.block_mid_post) {
+        try_dump(eb.dumps.block_mid_post->name, eb.dumps.block_mid_post, "encoder");
+    }
+    if (eb.dumps.block_last_out) {
+        try_dump(eb.dumps.block_last_out->name, eb.dumps.block_last_out, "encoder");
+    }
     try_dump("enc.ctc_logits", eb.dumps.ctc_logits, "encoder");
 
     // Read encoder outputs to host.
     const int64_t cat_h = eb.cat_out->ne[0];
     const int64_t cat_T = eb.cat_out->ne[1];
     cc->enc_cat_host.resize(static_cast<size_t>(cat_h) * cat_T);
-    ggml_backend_tensor_get(eb.cat_out, cc->enc_cat_host.data(), 0,
-                            cc->enc_cat_host.size() * sizeof(float));
+    ggml_backend_tensor_get(eb.cat_out, cc->enc_cat_host.data(), 0, cc->enc_cat_host.size() * sizeof(float));
 
     const int n_ctc_vocab = static_cast<int>(eb.ctc_logits->ne[0]);
     cc->ctc_logits_host.resize(static_cast<size_t>(n_ctc_vocab) * cat_T);
-    ggml_backend_tensor_get(eb.ctc_logits, cc->ctc_logits_host.data(), 0,
-                            cc->ctc_logits_host.size() * sizeof(float));
+    ggml_backend_tensor_get(eb.ctc_logits, cc->ctc_logits_host.data(), 0, cc->ctc_logits_host.size() * sizeof(float));
 
     int n_bpe_vocab = 0;
     if (eb.ctc_bpe_logits != nullptr) {
@@ -601,8 +555,7 @@ transcribe_status run(
     std::vector<float> mid_non_blank;
     if (eb.mid_blank_probs != nullptr) {
         std::vector<float> mid_blank(t_enc);
-        ggml_backend_tensor_get(eb.mid_blank_probs, mid_blank.data(), 0,
-                                mid_blank.size() * sizeof(float));
+        ggml_backend_tensor_get(eb.mid_blank_probs, mid_blank.data(), 0, mid_blank.size() * sizeof(float));
         mid_non_blank.resize(t_enc);
         for (int i = 0; i < t_enc; ++i) {
             mid_non_blank[i] = 1.0f - mid_blank[i];
@@ -616,27 +569,24 @@ transcribe_status run(
     // inner). No transpose needed: the host-side BPE pool reads
     //   ctc_bpe_logits_host[t * V + v]
     // and gets the v-th logit at frame t correctly.
-    (void)n_ctc_vocab;
+    (void) n_ctc_vocab;
 
     // Initial BPE hypothesis.
     std::vector<int32_t> hyp_ids;
     if (n_bpe_vocab > 0 && !mid_non_blank.empty()) {
-        compute_bpe_ctc_initial_hypothesis(
-            mid_non_blank,
-            cc->ctc_bpe_logits_host, n_bpe_vocab,
-            t_enc, cm->hparams.enc_bpe_pool_window,
-            /*blank_id=*/cm->hparams.enc_bpe_blank_id, hyp_ids);
+        compute_bpe_ctc_initial_hypothesis(mid_non_blank, cc->ctc_bpe_logits_host, n_bpe_vocab, t_enc,
+                                           cm->hparams.enc_bpe_pool_window,
+                                           /*blank_id=*/cm->hparams.enc_bpe_blank_id, hyp_ids);
     }
     if (hyp_ids.empty()) {
         // No tokens — emit empty transcript and return.
         cc->full_text.clear();
         cc->result_kind = TRANSCRIBE_TIMESTAMPS_NONE;
         cc->has_result  = true;
-        transcribe_session::SegmentEntry seg {};
+        transcribe_session::SegmentEntry seg{};
         seg.text  = cc->full_text;
         seg.t0_ms = 0;
-        seg.t1_ms = static_cast<int64_t>(n_samples) * 1000
-                  / static_cast<int64_t>(cm->hparams.fe_sample_rate);
+        seg.t1_ms = static_cast<int64_t>(n_samples) * 1000 / static_cast<int64_t>(cm->hparams.fe_sample_rate);
         cc->segments.push_back(std::move(seg));
         return TRANSCRIBE_OK;
     }
@@ -644,19 +594,18 @@ transcribe_status run(
     // Projector graph.
     ggml_context * proj_ctx = nullptr;
     {
-        ggml_init_params ip {};
-        ip.mem_size   = 16 * 1024 * 1024;
-        ip.no_alloc   = true;
-        proj_ctx = ggml_init(ip);
+        ggml_init_params ip{};
+        ip.mem_size = 16 * 1024 * 1024;
+        ip.no_alloc = true;
+        proj_ctx    = ggml_init(ip);
         if (proj_ctx == nullptr) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "granite_nar run: projector compute context allocation failed "
-                "— out of memory.");
+                                "granite_nar run: projector compute context allocation failed "
+                                "— out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
     }
-    ProjectorBuild pb = build_projector_graph(proj_ctx, cm->weights,
-                                              cm->hparams, t_enc);
+    ProjectorBuild pb = build_projector_graph(proj_ctx, cm->weights, cm->hparams, t_enc);
     if (pb.graph == nullptr || pb.out == nullptr) {
         ggml_free(proj_ctx);
         return TRANSCRIBE_ERR_GGUF;
@@ -665,8 +614,8 @@ transcribe_status run(
     ggml_backend_sched_reset(cc->sched);
     if (!ggml_backend_sched_alloc_graph(cc->sched, pb.graph)) {
         transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "granite_nar run: projector graph allocation failed — "
-            "out of memory.");
+                            "granite_nar run: projector graph allocation failed — "
+                            "out of memory.");
         ggml_free(proj_ctx);
         return TRANSCRIBE_ERR_OOM;
     }
@@ -674,45 +623,35 @@ transcribe_status run(
     // The encoder output sits as [cat_h, T_enc] in ggml ne order on the
     // host (i.e., enc_cat_host is feature-major in row-major bytes).
     // ggml expects the same layout for pb.enc_in — pass directly.
-    ggml_backend_tensor_set(pb.enc_in, cc->enc_cat_host.data(), 0,
-                            cc->enc_cat_host.size() * sizeof(float));
+    ggml_backend_tensor_set(pb.enc_in, cc->enc_cat_host.data(), 0, cc->enc_cat_host.size() * sizeof(float));
     if (pb.enc_pad != nullptr) {
-        const size_t pad_n = static_cast<size_t>(pb.enc_pad->ne[0]) *
-                             pb.enc_pad->ne[1];
+        const size_t       pad_n = static_cast<size_t>(pb.enc_pad->ne[0]) * pb.enc_pad->ne[1];
         std::vector<float> zeros(pad_n, 0.0f);
-        ggml_backend_tensor_set(pb.enc_pad, zeros.data(), 0,
-                                zeros.size() * sizeof(float));
+        ggml_backend_tensor_set(pb.enc_pad, zeros.data(), 0, zeros.size() * sizeof(float));
     }
 
-    if (const ggml_status gs =
-            ggml_backend_sched_graph_compute(cc->sched, pb.graph);
-        gs != GGML_STATUS_SUCCESS)
-    {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "granite_nar run: projector compute failed (%d)",
-                     static_cast<int>(gs));
+    if (const ggml_status gs = ggml_backend_sched_graph_compute(cc->sched, pb.graph); gs != GGML_STATUS_SUCCESS) {
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "granite_nar run: projector compute failed (%d)", static_cast<int>(gs));
         ggml_free(proj_ctx);
         return TRANSCRIBE_ERR_GGUF;
     }
 
     try_dump("proj.qformer.out", pb.dumps.qformer_out, "projector");
-    try_dump("proj.out",         pb.dumps.proj_out,    "projector");
+    try_dump("proj.out", pb.dumps.proj_out, "projector");
 
     // Reference projector emits nblocks*n_query audio tokens (here 37*3
     // = 111 for T_enc=550) but the LLM forward only consumes
     // `projected_length = T_enc / downsample_rate` of them (110), dropping
     // the trailing tokens that came from the zero-padded window. Mirror
     // that truncation so the audio-side n matches the reference.
-    const int n_audio_full   = pb.n_audio_tokens;
-    const int n_audio_used   = t_enc / cm->hparams.prj_downsample_rate;
+    const int n_audio_full    = pb.n_audio_tokens;
+    const int n_audio_used    = t_enc / cm->hparams.prj_downsample_rate;
     const int n_audio_clipped = std::min(n_audio_used, n_audio_full);
-    cc->n_audio_tokens = n_audio_clipped;
+    cc->n_audio_tokens        = n_audio_clipped;
 
     const int64_t llm_dim_runtime = pb.out->ne[0];
-    cc->proj_out_host.resize(static_cast<size_t>(llm_dim_runtime) *
-                              n_audio_clipped);
-    ggml_backend_tensor_get(pb.out, cc->proj_out_host.data(), 0,
-                            cc->proj_out_host.size() * sizeof(float));
+    cc->proj_out_host.resize(static_cast<size_t>(llm_dim_runtime) * n_audio_clipped);
+    ggml_backend_tensor_get(pb.out, cc->proj_out_host.data(), 0, cc->proj_out_host.size() * sizeof(float));
     ggml_free(proj_ctx);
 
     // add_insertion_slots.
@@ -732,12 +671,11 @@ transcribe_status run(
     const int T_total = cc->n_audio_tokens + n_text;
     const int ceiling = granite_nar_context_ceiling(cc->n_ctx, cm->hparams);
     if (T_total > ceiling) {
-        transcribe::log_msg(
-            TRANSCRIBE_LOG_LEVEL_ERROR,
-            "granite_nar run: input too long — %d audio + %d text tokens "
-            "exceed the %d-token context. Shorten audio or see "
-            "transcribe_capabilities.max_audio_ms.",
-            cc->n_audio_tokens, n_text, ceiling);
+        transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
+                            "granite_nar run: input too long — %d audio + %d text tokens "
+                            "exceed the %d-token context. Shorten audio or see "
+                            "transcribe_capabilities.max_audio_ms.",
+                            cc->n_audio_tokens, n_text, ceiling);
         return TRANSCRIBE_ERR_INPUT_TOO_LONG;
     }
 
@@ -748,25 +686,26 @@ transcribe_status run(
     const float emb_mul = cm->hparams.dec_embedding_multiplier;
     if (emb_mul > 0.0f) {
         const float inv = 1.0f / emb_mul;
-        for (auto & v : cc->proj_out_host) v *= inv;
+        for (auto & v : cc->proj_out_host) {
+            v *= inv;
+        }
     }
 
     // Decoder graph.
     ggml_context * dec_ctx = nullptr;
     {
-        ggml_init_params ip {};
-        ip.mem_size   = 128 * 1024 * 1024;  // 40 layers @ bidirectional
-        ip.no_alloc   = true;
-        dec_ctx = ggml_init(ip);
+        ggml_init_params ip{};
+        ip.mem_size = 128 * 1024 * 1024;  // 40 layers @ bidirectional
+        ip.no_alloc = true;
+        dec_ctx     = ggml_init(ip);
         if (dec_ctx == nullptr) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "granite_nar run: decoder compute context allocation failed — "
-                "out of memory.");
+                                "granite_nar run: decoder compute context allocation failed — "
+                                "out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
     }
-    ForwardBuild fb = build_forward_graph(dec_ctx, cm->weights, cm->hparams,
-                                          cc->n_audio_tokens, n_text);
+    ForwardBuild fb = build_forward_graph(dec_ctx, cm->weights, cm->hparams, cc->n_audio_tokens, n_text);
     if (fb.graph == nullptr || fb.out == nullptr) {
         ggml_free(dec_ctx);
         return TRANSCRIBE_ERR_GGUF;
@@ -775,31 +714,25 @@ transcribe_status run(
     ggml_backend_sched_reset(cc->sched);
     if (!ggml_backend_sched_alloc_graph(cc->sched, fb.graph)) {
         transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "granite_nar run: decoder graph allocation failed — "
-            "out of memory.");
+                            "granite_nar run: decoder graph allocation failed — "
+                            "out of memory.");
         ggml_free(dec_ctx);
         return TRANSCRIBE_ERR_OOM;
     }
 
-    ggml_backend_tensor_set(fb.audio_in, cc->proj_out_host.data(), 0,
-                            cc->proj_out_host.size() * sizeof(float));
-    ggml_backend_tensor_set(fb.text_ids_in, text_ids.data(), 0,
-                            text_ids.size() * sizeof(int32_t));
+    ggml_backend_tensor_set(fb.audio_in, cc->proj_out_host.data(), 0, cc->proj_out_host.size() * sizeof(float));
+    ggml_backend_tensor_set(fb.text_ids_in, text_ids.data(), 0, text_ids.size() * sizeof(int32_t));
     {
         std::vector<int32_t> positions(fb.T_total);
-        for (int i = 0; i < fb.T_total; ++i) positions[i] = i;
-        ggml_backend_tensor_set(fb.positions_in, positions.data(), 0,
-                                positions.size() * sizeof(int32_t));
+        for (int i = 0; i < fb.T_total; ++i) {
+            positions[i] = i;
+        }
+        ggml_backend_tensor_set(fb.positions_in, positions.data(), 0, positions.size() * sizeof(int32_t));
     }
 
     const int64_t t_dec_start = ggml_time_us();
-    if (const ggml_status gs =
-            ggml_backend_sched_graph_compute(cc->sched, fb.graph);
-        gs != GGML_STATUS_SUCCESS)
-    {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "granite_nar run: decoder compute failed (%d)",
-                     static_cast<int>(gs));
+    if (const ggml_status gs = ggml_backend_sched_graph_compute(cc->sched, fb.graph); gs != GGML_STATUS_SUCCESS) {
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "granite_nar run: decoder compute failed (%d)", static_cast<int>(gs));
         ggml_free(dec_ctx);
         return TRANSCRIBE_ERR_GGUF;
     }
@@ -811,32 +744,28 @@ transcribe_status run(
     // Read text-portion logits. ggml stores ne[0]=vocab as the innermost
     // axis, which means the host buffer layout is [t * vocab + v] —
     // i.e. `[n_text, vocab]` numpy row-major already. No transpose.
-    const int64_t vocab = fb.out->ne[0];
+    const int64_t      vocab = fb.out->ne[0];
     std::vector<float> logits_host(static_cast<size_t>(vocab) * n_text);
-    ggml_backend_tensor_get(fb.out, logits_host.data(), 0,
-                            logits_host.size() * sizeof(float));
+    ggml_backend_tensor_get(fb.out, logits_host.data(), 0, logits_host.size() * sizeof(float));
     ggml_free(dec_ctx);
 
     std::vector<int32_t> final_ids;
-    argmax_collapse_drop_eos(logits_host, static_cast<int>(vocab), n_text,
-                             cm->hparams.dec_eos_id, final_ids);
+    argmax_collapse_drop_eos(logits_host, static_cast<int>(vocab), n_text, cm->hparams.dec_eos_id, final_ids);
 
-    cc->full_text = cm->tok.decode(final_ids.data(),
-                                   static_cast<int>(final_ids.size()));
+    cc->full_text = cm->tok.decode(final_ids.data(), static_cast<int>(final_ids.size()));
 
     cc->result_kind = TRANSCRIBE_TIMESTAMPS_NONE;
     cc->has_result  = true;
-    transcribe_session::SegmentEntry seg {};
+    transcribe_session::SegmentEntry seg{};
     seg.text  = cc->full_text;
     seg.t0_ms = 0;
-    seg.t1_ms = static_cast<int64_t>(n_samples) * 1000
-              / static_cast<int64_t>(cm->hparams.fe_sample_rate);
+    seg.t1_ms = static_cast<int64_t>(n_samples) * 1000 / static_cast<int64_t>(cm->hparams.fe_sample_rate);
     cc->segments.push_back(std::move(seg));
 
     return TRANSCRIBE_OK;
 }
 
-} // namespace
+}  // namespace
 
 extern const Arch arch = {
     /* .name             = */ "granite_speech_nar",
@@ -852,4 +781,4 @@ extern const Arch arch = {
     /* .accepts_ext_kind = */ nullptr,
 };
 
-} // namespace transcribe::granite_nar
+}  // namespace transcribe::granite_nar
diff --git a/src/arch/granite_nar/projector.cpp b/src/arch/granite_nar/projector.cpp
index 2e32f1d7..52789b12 100644
--- a/src/arch/granite_nar/projector.cpp
+++ b/src/arch/granite_nar/projector.cpp
@@ -7,13 +7,11 @@
 
 #include "projector.h"
 
+#include "ggml.h"
 #include "granite_nar.h"
-#include "weights.h"
-
 #include "transcribe-debug.h"
 #include "transcribe-log.h"
-
-#include "ggml.h"
+#include "weights.h"
 
 #include <cmath>
 #include <cstdio>
@@ -24,25 +22,26 @@ namespace transcribe::granite_nar {
 namespace {
 
 ggml_tensor * named(ggml_tensor * t, const char * name) {
-    if (t != nullptr && name != nullptr) ggml_set_name(t, name);
+    if (t != nullptr && name != nullptr) {
+        ggml_set_name(t, name);
+    }
     return t;
 }
 
-ggml_tensor * layer_norm(ggml_context * ctx, ggml_tensor * x,
-                         ggml_tensor * gamma, ggml_tensor * beta,
-                         float eps)
-{
+ggml_tensor * layer_norm(ggml_context * ctx, ggml_tensor * x, ggml_tensor * gamma, ggml_tensor * beta, float eps) {
     ggml_tensor * y = ggml_norm(ctx, x, eps);
-    y = ggml_mul(ctx, y, gamma);
-    if (beta != nullptr) y = ggml_add(ctx, y, beta);
+    y               = ggml_mul(ctx, y, gamma);
+    if (beta != nullptr) {
+        y = ggml_add(ctx, y, beta);
+    }
     return y;
 }
 
-ggml_tensor * linear(ggml_context * ctx, ggml_tensor * x,
-                     ggml_tensor * w, ggml_tensor * b)
-{
+ggml_tensor * linear(ggml_context * ctx, ggml_tensor * x, ggml_tensor * w, ggml_tensor * b) {
     ggml_tensor * y = ggml_mul_mat(ctx, w, x);
-    if (b != nullptr) y = ggml_add(ctx, y, b);
+    if (b != nullptr) {
+        y = ggml_add(ctx, y, b);
+    }
     return y;
 }
 
@@ -53,59 +52,53 @@ ggml_tensor * cross_attn(ggml_context * ctx,
                          ggml_tensor *  k_in,
                          ggml_tensor *  v_in,
                          int            n_heads,
-                         int            head_dim)
-{
+                         int            head_dim) {
     const int64_t q_seq = q_in->ne[1];
     const int64_t k_seq = k_in->ne[1];
     const int64_t batch = q_in->ne[2];
     const float   scale = 1.0f / std::sqrt(static_cast<float>(head_dim));
 
     auto split = [&](ggml_tensor * t, int64_t seq) {
-        ggml_tensor * r = ggml_reshape_4d(ctx, t,
-                                          head_dim, n_heads, seq, batch);
-        r = ggml_cont(ctx, ggml_permute(ctx, r, 0, 2, 1, 3));
+        ggml_tensor * r = ggml_reshape_4d(ctx, t, head_dim, n_heads, seq, batch);
+        r               = ggml_cont(ctx, ggml_permute(ctx, r, 0, 2, 1, 3));
         return r;
     };
     ggml_tensor * q = split(q_in, q_seq);
     ggml_tensor * k = split(k_in, k_seq);
     ggml_tensor * v = split(v_in, k_seq);
 
-    ggml_tensor * kq = ggml_mul_mat(ctx, k, q);
-    kq = ggml_scale(ctx, kq, scale);
+    ggml_tensor * kq   = ggml_mul_mat(ctx, k, q);
+    kq                 = ggml_scale(ctx, kq, scale);
     ggml_tensor * attn = ggml_soft_max(ctx, kq);
 
     ggml_tensor * v_t = ggml_cont(ctx, ggml_permute(ctx, v, 1, 0, 2, 3));
     ggml_tensor * out = ggml_mul_mat(ctx, v_t, attn);
-    out = ggml_cont(ctx, ggml_permute(ctx, out, 0, 2, 1, 3));
-    out = ggml_reshape_3d(ctx, out,
-                          static_cast<int64_t>(head_dim) * n_heads,
-                          q_seq, batch);
+    out               = ggml_cont(ctx, ggml_permute(ctx, out, 0, 2, 1, 3));
+    out               = ggml_reshape_3d(ctx, out, static_cast<int64_t>(head_dim) * n_heads, q_seq, batch);
     return out;
 }
 
-} // namespace
+}  // namespace
 
 ProjectorBuild build_projector_graph(ggml_context *            ctx,
                                      const GraniteNarWeights & weights,
                                      const GraniteNarHParams & hp,
-                                     int                       T_enc)
-{
-    ProjectorBuild pb {};
-
-    const int     block_size  = hp.prj_block_size;        // 15
-    const int     downsample  = hp.prj_downsample_rate;   // 5
-    const int     n_query     = block_size / downsample;  // 3
-    const int     n_heads     = hp.prj_n_heads;           // 32
-    const int     prj_hidden  = hp.prj_hidden;            // 2048
-    const int     enc_layers  = hp.prj_num_encoder_layers; // 4
-    const int     enc_hidden  = hp.prj_encoder_dim;       // 1024
-    const int     cat_in      = enc_layers * enc_hidden;  // 4096
-    const float   ln_eps      = hp.prj_layernorm_eps;
+                                     int                       T_enc) {
+    ProjectorBuild pb{};
+
+    const int   block_size = hp.prj_block_size;          // 15
+    const int   downsample = hp.prj_downsample_rate;     // 5
+    const int   n_query    = block_size / downsample;    // 3
+    const int   n_heads    = hp.prj_n_heads;             // 32
+    const int   prj_hidden = hp.prj_hidden;              // 2048
+    const int   enc_layers = hp.prj_num_encoder_layers;  // 4
+    const int   enc_hidden = hp.prj_encoder_dim;         // 1024
+    const int   cat_in     = enc_layers * enc_hidden;    // 4096
+    const float ln_eps     = hp.prj_layernorm_eps;
 
     if (prj_hidden % n_heads != 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "granite_nar projector: prj_hidden (%d) %% n_heads (%d) != 0",
-                     prj_hidden, n_heads);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "granite_nar projector: prj_hidden (%d) %% n_heads (%d) != 0", prj_hidden,
+                n_heads);
         return pb;
     }
     const int head_dim = prj_hidden / n_heads;  // 64
@@ -123,29 +116,23 @@ ProjectorBuild build_projector_graph(ggml_context *            ctx,
     // Slice enc_in along the channel axis into `enc_layers` chunks of
     // size `enc_hidden`, LN each chunk with its own gamma/beta, then
     // concat back.
-    ggml_tensor * normed = nullptr;
-    const size_t cat_in_bytes = ggml_element_size(pb.enc_in) * enc_hidden;
+    ggml_tensor * normed       = nullptr;
+    const size_t  cat_in_bytes = ggml_element_size(pb.enc_in) * enc_hidden;
     for (int j = 0; j < enc_layers; ++j) {
-        ggml_tensor * slc = ggml_view_2d(
-            ctx, pb.enc_in,
-            enc_hidden, T_enc,
-            pb.enc_in->nb[1],
-            cat_in_bytes * j);
-        slc = ggml_cont(ctx, slc);
-        slc = layer_norm(ctx, slc,
-                         weights.proj_top.layer_norms_w[j],
-                         weights.proj_top.layer_norms_b[j],
-                         ln_eps);
-        if (normed == nullptr) normed = slc;
-        else normed = ggml_concat(ctx, normed, slc, /*dim=*/0);
+        ggml_tensor * slc = ggml_view_2d(ctx, pb.enc_in, enc_hidden, T_enc, pb.enc_in->nb[1], cat_in_bytes * j);
+        slc               = ggml_cont(ctx, slc);
+        slc = layer_norm(ctx, slc, weights.proj_top.layer_norms_w[j], weights.proj_top.layer_norms_b[j], ln_eps);
+        if (normed == nullptr) {
+            normed = slc;
+        } else {
+            normed = ggml_concat(ctx, normed, slc, /*dim=*/0);
+        }
     }
     // normed ne = [cat_in, T_enc]
 
     // Linear projector (cat_in -> prj_hidden) + GELU.
-    ggml_tensor * proj_lp = linear(ctx, normed,
-                                   weights.proj_top.layer_projector_w,
-                                   weights.proj_top.layer_projector_b);
-    proj_lp = ggml_gelu(ctx, proj_lp);
+    ggml_tensor * proj_lp = linear(ctx, normed, weights.proj_top.layer_projector_w, weights.proj_top.layer_projector_b);
+    proj_lp               = ggml_gelu(ctx, proj_lp);
     // proj_lp ne = [prj_hidden, T_enc]
 
     // Pad along T to nblocks * block_size.
@@ -155,8 +142,7 @@ ProjectorBuild build_projector_graph(ggml_context *            ctx,
     // before the windowed pool.
     ggml_tensor * full = proj_lp;
     if (pb.t_enc_pad > 0) {
-        pb.enc_pad = ggml_new_tensor_2d(
-            ctx, GGML_TYPE_F32, prj_hidden, pb.t_enc_pad);
+        pb.enc_pad = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, prj_hidden, pb.t_enc_pad);
         named(pb.enc_pad, "proj.t_pad_zero");
         ggml_set_input(pb.enc_pad);
         full = ggml_concat(ctx, proj_lp, pb.enc_pad, /*dim=*/1);
@@ -164,40 +150,36 @@ ProjectorBuild build_projector_graph(ggml_context *            ctx,
     // full ne = [prj_hidden, T_pad]
 
     // Reshape to [prj_hidden, block_size, nblocks].
-    ggml_tensor * windowed = ggml_reshape_3d(ctx, full,
-                                             prj_hidden, block_size, pb.nblocks);
+    ggml_tensor * windowed = ggml_reshape_3d(ctx, full, prj_hidden, block_size, pb.nblocks);
 
     // K/V: x + window_positions.
     // window_positions tensor ne = [prj_hidden, block_size, 1]. We add
     // it to `windowed` which is [prj_hidden, block_size, nblocks]; ggml
     // broadcasts the ne[2]=1 across the nblocks dim.
-    ggml_tensor * wpos = ggml_cast(ctx, weights.proj_top.window_positions,
-                                   GGML_TYPE_F32);
-    ggml_tensor * kv = ggml_add(ctx, windowed, wpos);
+    ggml_tensor * wpos = ggml_cast(ctx, weights.proj_top.window_positions, GGML_TYPE_F32);
+    ggml_tensor * kv   = ggml_add(ctx, windowed, wpos);
 
     // Mean-pool windowed -> [prj_hidden, n_query, nblocks].
     // Reference reshapes the windowed tensor (B*nblocks, block_size, h) as
     // (B*nblocks, n_query, downsample, h) and means over the downsample
     // axis. In ggml ne order, this is reshape [h, block_size, nblocks] ->
     // [h, downsample, n_query, nblocks] then mean over ne[1].
-    ggml_tensor * mp_view = ggml_reshape_4d(ctx, windowed,
-                                            prj_hidden, downsample, n_query, pb.nblocks);
+    ggml_tensor * mp_view   = ggml_reshape_4d(ctx, windowed, prj_hidden, downsample, n_query, pb.nblocks);
     // ggml_mean reduces over ne[0] only. Permute so downsample becomes
     // ne[0]: (h, downsample, n_query, nblocks) -> (downsample, h, n_query, nblocks)
     // via permute(1, 0, 2, 3). Then mean reduces ne[0] = downsample,
     // yielding (1, h, n_query, nblocks). Squeeze ne[0]=1 with reshape.
-    ggml_tensor * mp_perm = ggml_cont(ctx, ggml_permute(ctx, mp_view, 1, 0, 2, 3));
-    ggml_tensor * mp_mean = ggml_mean(ctx, mp_perm);
+    ggml_tensor * mp_perm   = ggml_cont(ctx, ggml_permute(ctx, mp_view, 1, 0, 2, 3));
+    ggml_tensor * mp_mean   = ggml_mean(ctx, mp_perm);
     // mp_mean ne = [1, h, n_query, nblocks]; reshape to [h, n_query, nblocks].
-    ggml_tensor * mean_pool = ggml_reshape_3d(ctx, mp_mean,
-                                              prj_hidden, n_query, pb.nblocks);
+    ggml_tensor * mean_pool = ggml_reshape_3d(ctx, mp_mean, prj_hidden, n_query, pb.nblocks);
 
     // Query: learned [prj_hidden, n_query, 1] + mean_pool.
     ggml_tensor * query = ggml_cast(ctx, weights.proj_top.query, GGML_TYPE_F32);
     // Broadcast query over the nblocks axis when adding mean_pool. ggml_add
     // broadcasts dims of size 1, so the [h, n_query, 1] query expands
     // naturally to match mean_pool's [h, n_query, nblocks].
-    query = ggml_add(ctx, mean_pool, query);
+    query               = ggml_add(ctx, mean_pool, query);
 
     // Q-Former layers (no self-attention).
     for (int i = 0; i < hp.prj_n_layers; ++i) {
@@ -206,19 +188,18 @@ ProjectorBuild build_projector_graph(ggml_context *            ctx,
         // Pre-LN cross-attention.
         ggml_tensor * q_norm = layer_norm(ctx, query, b.norm_attn_w, b.norm_attn_b, ln_eps);
         ggml_tensor * q_proj = linear(ctx, q_norm, b.cross_attn_q_w, b.cross_attn_q_b);
-        ggml_tensor * k_proj = linear(ctx, kv,     b.cross_attn_k_w, b.cross_attn_k_b);
-        ggml_tensor * v_proj = linear(ctx, kv,     b.cross_attn_v_w, b.cross_attn_v_b);
-        ggml_tensor * attn   = cross_attn(ctx, q_proj, k_proj, v_proj,
-                                          n_heads, head_dim);
-        attn = linear(ctx, attn, b.cross_attn_o_w, b.cross_attn_o_b);
-        query = ggml_add(ctx, query, attn);
+        ggml_tensor * k_proj = linear(ctx, kv, b.cross_attn_k_w, b.cross_attn_k_b);
+        ggml_tensor * v_proj = linear(ctx, kv, b.cross_attn_v_w, b.cross_attn_v_b);
+        ggml_tensor * attn   = cross_attn(ctx, q_proj, k_proj, v_proj, n_heads, head_dim);
+        attn                 = linear(ctx, attn, b.cross_attn_o_w, b.cross_attn_o_b);
+        query                = ggml_add(ctx, query, attn);
 
         // Pre-LN FFN.
         ggml_tensor * f_norm = layer_norm(ctx, query, b.norm_ffn_w, b.norm_ffn_b, ln_eps);
         ggml_tensor * mid    = linear(ctx, f_norm, b.ffn_fc1_w, b.ffn_fc1_b);
-        mid = ggml_silu(ctx, mid);
-        ggml_tensor * f_out  = linear(ctx, mid,    b.ffn_fc2_w, b.ffn_fc2_b);
-        query = ggml_add(ctx, query, f_out);
+        mid                  = ggml_silu(ctx, mid);
+        ggml_tensor * f_out  = linear(ctx, mid, b.ffn_fc2_w, b.ffn_fc2_b);
+        query                = ggml_add(ctx, query, f_out);
     }
 
     // qformer.out dump tap (HF emits this BEFORE out_norm + out_linear).
@@ -227,33 +208,29 @@ ProjectorBuild build_projector_graph(ggml_context *            ctx,
     transcribe::debug::mark_tensor_for_dump(query);
 
     // out_norm + out_linear (LLM-space).
-    ggml_tensor * onorm = layer_norm(ctx, query,
-                                     weights.proj_top.out_norm_w,
-                                     weights.proj_top.out_norm_b,
-                                     ln_eps);
+    ggml_tensor * onorm = layer_norm(ctx, query, weights.proj_top.out_norm_w, weights.proj_top.out_norm_b, ln_eps);
 
     // Reshape to [prj_hidden, n_query * nblocks].
-    ggml_tensor * tokens = ggml_reshape_2d(ctx, onorm,
-                                           prj_hidden,
-                                           static_cast<int64_t>(n_query) * pb.nblocks);
-    ggml_tensor * out = ggml_mul_mat(ctx, weights.proj_top.out_linear_w, tokens);
-    out = ggml_add(ctx, out, weights.proj_top.out_linear_b);
+    ggml_tensor * tokens = ggml_reshape_2d(ctx, onorm, prj_hidden, static_cast<int64_t>(n_query) * pb.nblocks);
+    ggml_tensor * out    = ggml_mul_mat(ctx, weights.proj_top.out_linear_w, tokens);
+    out                  = ggml_add(ctx, out, weights.proj_top.out_linear_b);
     named(out, "proj.out");
-    pb.out = out;
+    pb.out            = out;
     pb.dumps.proj_out = out;
     ggml_set_output(out);
     transcribe::debug::mark_tensor_for_dump(out);
 
     pb.graph = ggml_new_graph_custom(ctx, /*size=*/4096, /*grads=*/false);
     if (pb.graph == nullptr) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "granite_nar projector: ggml_new_graph_custom failed");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "granite_nar projector: ggml_new_graph_custom failed");
         return pb;
     }
     ggml_build_forward_expand(pb.graph, pb.out);
-    if (pb.dumps.qformer_out) ggml_build_forward_expand(pb.graph, pb.dumps.qformer_out);
+    if (pb.dumps.qformer_out) {
+        ggml_build_forward_expand(pb.graph, pb.dumps.qformer_out);
+    }
 
     return pb;
 }
 
-} // namespace transcribe::granite_nar
+}  // namespace transcribe::granite_nar
diff --git a/src/arch/granite_nar/projector.h b/src/arch/granite_nar/projector.h
index 67e3337e..912769d7 100644
--- a/src/arch/granite_nar/projector.h
+++ b/src/arch/granite_nar/projector.h
@@ -14,9 +14,8 @@
 
 #pragma once
 
-#include "weights.h"
-
 #include "ggml.h"
+#include "weights.h"
 
 #include <cstdint>
 #include <vector>
@@ -28,20 +27,20 @@ struct ggml_cgraph;
 namespace transcribe::granite_nar {
 
 struct ProjectorBuild {
-    ggml_tensor * enc_in    = nullptr;  // [num_layers * enc_hidden, T_enc]
-    ggml_tensor * enc_pad   = nullptr;  // optional [num_layers * enc_hidden, pad_n]
+    ggml_tensor * enc_in  = nullptr;  // [num_layers * enc_hidden, T_enc]
+    ggml_tensor * enc_pad = nullptr;  // optional [num_layers * enc_hidden, pad_n]
 
-    ggml_tensor * out       = nullptr;  // [llm_dim, n_audio_tokens]
+    ggml_tensor * out = nullptr;      // [llm_dim, n_audio_tokens]
 
     struct {
         ggml_tensor * qformer_out = nullptr;  // [llm_dim, n_query, nblocks]
         ggml_tensor * proj_out    = nullptr;  // == out
     } dumps;
 
-    ggml_cgraph * graph = nullptr;
-    int nblocks         = 0;
-    int n_audio_tokens  = 0;
-    int t_enc_pad       = 0;
+    ggml_cgraph * graph          = nullptr;
+    int           nblocks        = 0;
+    int           n_audio_tokens = 0;
+    int           t_enc_pad      = 0;
 };
 
 ProjectorBuild build_projector_graph(ggml_context *            ctx,
@@ -49,4 +48,4 @@ ProjectorBuild build_projector_graph(ggml_context *            ctx,
                                      const GraniteNarHParams & hp,
                                      int                       T_enc);
 
-} // namespace transcribe::granite_nar
+}  // namespace transcribe::granite_nar
diff --git a/src/arch/granite_nar/weights.cpp b/src/arch/granite_nar/weights.cpp
index 73de9e67..9fedde6a 100644
--- a/src/arch/granite_nar/weights.cpp
+++ b/src/arch/granite_nar/weights.cpp
@@ -2,12 +2,11 @@
 
 #include "weights.h"
 
-#include "transcribe-meta.h"
-#include "transcribe-weights-util.h"
-#include "transcribe-log.h"
-
 #include "ggml.h"
 #include "gguf.h"
+#include "transcribe-log.h"
+#include "transcribe-meta.h"
+#include "transcribe-weights-util.h"
 
 #include <cstdio>
 
@@ -18,48 +17,73 @@ constexpr const char * kTag = "granite_nar";
 
 using transcribe::weights::lname;
 
-#define GET_F32(slot, name, ...) \
-    do { \
-        ggml_tensor * _t = transcribe::weights::find_tensor( \
-            ctx_meta, (name), {GGML_TYPE_F32}, {__VA_ARGS__}, kTag); \
-        if (_t == nullptr) return TRANSCRIBE_ERR_GGUF; \
-        (slot) = _t; \
+#define GET_F32(slot, name, ...)                                                                          \
+    do {                                                                                                  \
+        ggml_tensor * _t =                                                                                \
+            transcribe::weights::find_tensor(ctx_meta, (name), { GGML_TYPE_F32 }, { __VA_ARGS__ }, kTag); \
+        if (_t == nullptr)                                                                                \
+            return TRANSCRIBE_ERR_GGUF;                                                                   \
+        (slot) = _t;                                                                                      \
     } while (0)
 
-#define GET_CONV(slot, name, ...) \
-    do { \
-        ggml_tensor * _t = transcribe::weights::find_tensor( \
-            ctx_meta, (name), {TRANSCRIBE_QUANT_CONV_TYPES}, \
-            {__VA_ARGS__}, kTag); \
-        if (_t == nullptr) return TRANSCRIBE_ERR_GGUF; \
-        (slot) = _t; \
+#define GET_CONV(slot, name, ...)                                                                              \
+    do {                                                                                                       \
+        ggml_tensor * _t = transcribe::weights::find_tensor(ctx_meta, (name), { TRANSCRIBE_QUANT_CONV_TYPES }, \
+                                                            { __VA_ARGS__ }, kTag);                            \
+        if (_t == nullptr)                                                                                     \
+            return TRANSCRIBE_ERR_GGUF;                                                                        \
+        (slot) = _t;                                                                                           \
     } while (0)
 
-#define GET_LIN(slot, name, ...) \
-    do { \
-        ggml_tensor * _t = transcribe::weights::find_tensor( \
-            ctx_meta, (name), {TRANSCRIBE_QUANT_LINEAR_TYPES}, \
-            {__VA_ARGS__}, kTag); \
-        if (_t == nullptr) return TRANSCRIBE_ERR_GGUF; \
-        (slot) = _t; \
+#define GET_LIN(slot, name, ...)                                                                                 \
+    do {                                                                                                         \
+        ggml_tensor * _t = transcribe::weights::find_tensor(ctx_meta, (name), { TRANSCRIBE_QUANT_LINEAR_TYPES }, \
+                                                            { __VA_ARGS__ }, kTag);                              \
+        if (_t == nullptr)                                                                                       \
+            return TRANSCRIBE_ERR_GGUF;                                                                          \
+        (slot) = _t;                                                                                             \
     } while (0)
 
-} // namespace
+}  // namespace
 
-transcribe_status read_granite_nar_hparams(const gguf_context * gguf,
-                                           GraniteNarHParams &  hp)
-{
-    if (gguf == nullptr) return TRANSCRIBE_ERR_INVALID_ARG;
+transcribe_status read_granite_nar_hparams(const gguf_context * gguf, GraniteNarHParams & hp) {
+    if (gguf == nullptr) {
+        return TRANSCRIBE_ERR_INVALID_ARG;
+    }
 
     // Encoder
-    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.encoder.n_layers", kTag, hp.enc_n_layers); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.encoder.hidden", kTag, hp.enc_hidden); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.encoder.n_heads", kTag, hp.enc_n_heads); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.encoder.head_dim", kTag, hp.enc_head_dim); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.encoder.input_dim", kTag, hp.enc_input_dim); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.encoder.output_dim", kTag, hp.enc_output_dim); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.encoder.bpe_output_dim", kTag, hp.enc_bpe_output_dim); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.encoder.bpe_pool_window", kTag, hp.enc_bpe_pool_window); st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.encoder.n_layers", kTag, hp.enc_n_layers);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.encoder.hidden", kTag, hp.enc_hidden);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.encoder.n_heads", kTag, hp.enc_n_heads);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.encoder.head_dim", kTag, hp.enc_head_dim);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.encoder.input_dim", kTag, hp.enc_input_dim);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.encoder.output_dim", kTag, hp.enc_output_dim);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.encoder.bpe_output_dim", kTag, hp.enc_bpe_output_dim);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.encoder.bpe_pool_window", kTag, hp.enc_bpe_pool_window);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
     // bpe_blank_id is an optional key; older GGUFs lack it. Default to 0 to
     // preserve the legacy decode scheme.
     {
@@ -70,18 +94,40 @@ transcribe_status read_granite_nar_hparams(const gguf_context * gguf,
             hp.enc_bpe_blank_id = 0;
         }
     }
-    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.encoder.self_cond_layer", kTag, hp.enc_self_cond_layer); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.encoder.feedforward_mult", kTag, hp.enc_feedforward_mult); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.encoder.conv_kernel_size", kTag, hp.enc_conv_kernel_size); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.encoder.conv_expansion", kTag, hp.enc_conv_expansion); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.encoder.max_pos_emb", kTag, hp.enc_max_pos_emb); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.encoder.context_size", kTag, hp.enc_context_size); st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.encoder.self_cond_layer", kTag, hp.enc_self_cond_layer);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.encoder.feedforward_mult", kTag, hp.enc_feedforward_mult);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.encoder.conv_kernel_size", kTag, hp.enc_conv_kernel_size);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.encoder.conv_expansion", kTag, hp.enc_conv_expansion);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.encoder.max_pos_emb", kTag, hp.enc_max_pos_emb);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.encoder.context_size", kTag, hp.enc_context_size);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     {
         std::vector<int32_t> tmp;
         switch (read_int32_array_kv(gguf, "stt.granite_nar.encoder.layer_indices", tmp)) {
-            case KvResult::Ok:     hp.enc_layer_indices = std::move(tmp); break;
-            case KvResult::Absent: hp.enc_layer_indices = {-1}; break;
+            case KvResult::Ok:
+                hp.enc_layer_indices = std::move(tmp);
+                break;
+            case KvResult::Absent:
+                hp.enc_layer_indices = { -1 };
+                break;
             case KvResult::BadType:
                 log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: encoder.layer_indices wrong type", kTag);
                 return TRANSCRIBE_ERR_GGUF;
@@ -89,65 +135,190 @@ transcribe_status read_granite_nar_hparams(const gguf_context * gguf,
     }
 
     // Projector
-    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.projector.n_layers", kTag, hp.prj_n_layers); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.projector.hidden", kTag, hp.prj_hidden); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.projector.mlp_ratio", kTag, hp.prj_mlp_ratio); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.projector.n_heads", kTag, hp.prj_n_heads); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.projector.encoder_dim", kTag, hp.prj_encoder_dim); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.projector.num_encoder_layers", kTag, hp.prj_num_encoder_layers); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.projector.block_size", kTag, hp.prj_block_size); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.projector.downsample_rate", kTag, hp.prj_downsample_rate); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.projector.llm_dim", kTag, hp.prj_llm_dim); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf, "stt.granite_nar.projector.layernorm_eps", kTag, hp.prj_layernorm_eps); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_bool_kv(gguf, "stt.granite_nar.projector.attn_bias", kTag, true,  hp.prj_attn_bias);  st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_bool_kv(gguf, "stt.granite_nar.projector.mlp_bias",  kTag, true,  hp.prj_mlp_bias);   st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_bool_kv(gguf, "stt.granite_nar.scale_projected_embeddings", kTag, true, hp.scale_projected_embeddings); st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.projector.n_layers", kTag, hp.prj_n_layers);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.projector.hidden", kTag, hp.prj_hidden);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.projector.mlp_ratio", kTag, hp.prj_mlp_ratio);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.projector.n_heads", kTag, hp.prj_n_heads);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.projector.encoder_dim", kTag, hp.prj_encoder_dim);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st =
+            read_required_u32_kv(gguf, "stt.granite_nar.projector.num_encoder_layers", kTag, hp.prj_num_encoder_layers);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.projector.block_size", kTag, hp.prj_block_size);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.projector.downsample_rate", kTag, hp.prj_downsample_rate);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.projector.llm_dim", kTag, hp.prj_llm_dim);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.granite_nar.projector.layernorm_eps", kTag, hp.prj_layernorm_eps);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_bool_kv(gguf, "stt.granite_nar.projector.attn_bias", kTag, true, hp.prj_attn_bias);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_bool_kv(gguf, "stt.granite_nar.projector.mlp_bias", kTag, true, hp.prj_mlp_bias);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_bool_kv(gguf, "stt.granite_nar.scale_projected_embeddings", kTag, true,
+                                        hp.scale_projected_embeddings);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Text LM
-    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.text.n_layers", kTag, hp.dec_n_layers); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.text.hidden", kTag, hp.dec_hidden); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.text.intermediate", kTag, hp.dec_intermediate); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.text.n_heads", kTag, hp.dec_n_heads); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.text.n_kv_heads", kTag, hp.dec_n_kv_heads); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.text.head_dim", kTag, hp.dec_head_dim); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.granite_nar.text.hidden_act", kTag, hp.dec_hidden_act); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf, "stt.granite_nar.text.rms_norm_eps", kTag, hp.dec_rms_norm_eps); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf, "stt.granite_nar.text.rope_theta", kTag, hp.dec_rope_theta); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.text.max_position_embeddings", kTag, hp.dec_max_pos_emb); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_bool_kv(gguf, "stt.granite_nar.text.tie_word_embeddings", kTag, true, hp.dec_tie_word_embeddings); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.text.vocab_size", kTag, hp.dec_vocab_size); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf, "stt.granite_nar.text.embedding_multiplier", kTag, hp.dec_embedding_multiplier); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf, "stt.granite_nar.text.logits_scaling", kTag, hp.dec_logits_scaling); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf, "stt.granite_nar.text.attention_multiplier", kTag, hp.dec_attention_multiplier); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf, "stt.granite_nar.text.residual_multiplier", kTag, hp.dec_residual_multiplier); st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.text.n_layers", kTag, hp.dec_n_layers);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.text.hidden", kTag, hp.dec_hidden); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.text.intermediate", kTag, hp.dec_intermediate);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.text.n_heads", kTag, hp.dec_n_heads);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.text.n_kv_heads", kTag, hp.dec_n_kv_heads);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.text.head_dim", kTag, hp.dec_head_dim);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_string_kv(gguf, "stt.granite_nar.text.hidden_act", kTag, hp.dec_hidden_act);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.granite_nar.text.rms_norm_eps", kTag, hp.dec_rms_norm_eps);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.granite_nar.text.rope_theta", kTag, hp.dec_rope_theta);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.text.max_position_embeddings", kTag, hp.dec_max_pos_emb);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_bool_kv(gguf, "stt.granite_nar.text.tie_word_embeddings", kTag, true,
+                                        hp.dec_tie_word_embeddings);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.text.vocab_size", kTag, hp.dec_vocab_size);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st =
+            read_required_f32_kv(gguf, "stt.granite_nar.text.embedding_multiplier", kTag, hp.dec_embedding_multiplier);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.granite_nar.text.logits_scaling", kTag, hp.dec_logits_scaling);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st =
+            read_required_f32_kv(gguf, "stt.granite_nar.text.attention_multiplier", kTag, hp.dec_attention_multiplier);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st =
+            read_required_f32_kv(gguf, "stt.granite_nar.text.residual_multiplier", kTag, hp.dec_residual_multiplier);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
     {
         int32_t tmp;
-        if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.text.bos_id", kTag, tmp); st != TRANSCRIBE_OK) return st;
+        if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.text.bos_id", kTag, tmp); st != TRANSCRIBE_OK) {
+            return st;
+        }
         hp.dec_bos_id = tmp;
-        if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.text.eos_id", kTag, tmp); st != TRANSCRIBE_OK) return st;
+        if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.text.eos_id", kTag, tmp); st != TRANSCRIBE_OK) {
+            return st;
+        }
         hp.dec_eos_id = tmp;
-        if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.text.pad_id", kTag, tmp); st != TRANSCRIBE_OK) return st;
+        if (auto st = read_required_u32_kv(gguf, "stt.granite_nar.text.pad_id", kTag, tmp); st != TRANSCRIBE_OK) {
+            return st;
+        }
         hp.dec_pad_id = tmp;
     }
 
     // Frontend
-    if (auto st = read_required_string_kv(gguf, "stt.frontend.type", kTag, hp.fe_type); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.frontend.sample_rate", kTag, hp.fe_sample_rate); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.frontend.num_mels", kTag, hp.fe_num_mels); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.frontend.n_fft", kTag, hp.fe_n_fft); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.frontend.win_length", kTag, hp.fe_win_length); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.frontend.hop_length", kTag, hp.fe_hop_length); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.frontend.window", kTag, hp.fe_window); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.frontend.normalize", kTag, hp.fe_normalize); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_string_kv(gguf, "stt.frontend.pad_mode", kTag, "reflect", hp.fe_pad_mode); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_string_kv(gguf, "stt.frontend.mel_norm", kTag, "htk", hp.fe_mel_norm); st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_string_kv(gguf, "stt.frontend.type", kTag, hp.fe_type); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.sample_rate", kTag, hp.fe_sample_rate);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.num_mels", kTag, hp.fe_num_mels); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.n_fft", kTag, hp.fe_n_fft); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.win_length", kTag, hp.fe_win_length); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.hop_length", kTag, hp.fe_hop_length); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_string_kv(gguf, "stt.frontend.window", kTag, hp.fe_window); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_string_kv(gguf, "stt.frontend.normalize", kTag, hp.fe_normalize); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_string_kv(gguf, "stt.frontend.pad_mode", kTag, "reflect", hp.fe_pad_mode);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_string_kv(gguf, "stt.frontend.mel_norm", kTag, "htk", hp.fe_mel_norm);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // CTC chars array.
     {
         std::vector<std::string> tmp;
         switch (read_string_array_kv(gguf, "stt.granite_nar.ctc_chars", tmp)) {
-            case KvResult::Ok:     hp.ctc_chars = std::move(tmp); break;
-            case KvResult::Absent: hp.ctc_chars.clear(); break;
+            case KvResult::Ok:
+                hp.ctc_chars = std::move(tmp);
+                break;
+            case KvResult::Absent:
+                hp.ctc_chars.clear();
+                break;
             case KvResult::BadType:
                 log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: ctc_chars wrong type", kTag);
                 return TRANSCRIBE_ERR_GGUF;
@@ -155,15 +326,16 @@ transcribe_status read_granite_nar_hparams(const gguf_context * gguf,
     }
 
     // Cross-field invariants.
-    if (hp.prj_num_encoder_layers != (int32_t)hp.enc_layer_indices.size()) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: prj_num_encoder_layers (%d) != "
-                     "len(enc_layer_indices) (%zu)",
-                     kTag, hp.prj_num_encoder_layers, hp.enc_layer_indices.size());
+    if (hp.prj_num_encoder_layers != (int32_t) hp.enc_layer_indices.size()) {
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
+                "%s: prj_num_encoder_layers (%d) != "
+                "len(enc_layer_indices) (%zu)",
+                kTag, hp.prj_num_encoder_layers, hp.enc_layer_indices.size());
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.dec_hidden != hp.prj_llm_dim) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: dec_hidden (%d) != prj_llm_dim (%d)",
-                     kTag, hp.dec_hidden, hp.prj_llm_dim);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: dec_hidden (%d) != prj_llm_dim (%d)", kTag, hp.dec_hidden,
+                hp.prj_llm_dim);
         return TRANSCRIBE_ERR_GGUF;
     }
 
@@ -172,24 +344,25 @@ transcribe_status read_granite_nar_hparams(const gguf_context * gguf,
 
 transcribe_status build_granite_nar_weights(ggml_context *            ctx_meta,
                                             const GraniteNarHParams & hp,
-                                            GraniteNarWeights &       weights)
-{
-    if (ctx_meta == nullptr) return TRANSCRIBE_ERR_INVALID_ARG;
-
-    const int64_t enc_h        = hp.enc_hidden;
-    const int64_t enc_in       = hp.enc_input_dim;
-    const int64_t enc_out      = hp.enc_output_dim;
-    const int64_t enc_bpe_out  = hp.enc_bpe_output_dim;
-    const int64_t enc_inner    = (int64_t)hp.enc_n_heads * hp.enc_head_dim;
-    const int64_t enc_ffn      = enc_h * hp.enc_feedforward_mult;
-    const int64_t conv_inner   = enc_h * hp.enc_conv_expansion;
-    const int64_t conv_up_out  = conv_inner * 2;
-    const int64_t conv_k       = hp.enc_conv_kernel_size;
-    const int64_t rel_pos_len  = 2 * hp.enc_max_pos_emb + 1;
+                                            GraniteNarWeights &       weights) {
+    if (ctx_meta == nullptr) {
+        return TRANSCRIBE_ERR_INVALID_ARG;
+    }
+
+    const int64_t enc_h       = hp.enc_hidden;
+    const int64_t enc_in      = hp.enc_input_dim;
+    const int64_t enc_out     = hp.enc_output_dim;
+    const int64_t enc_bpe_out = hp.enc_bpe_output_dim;
+    const int64_t enc_inner   = (int64_t) hp.enc_n_heads * hp.enc_head_dim;
+    const int64_t enc_ffn     = enc_h * hp.enc_feedforward_mult;
+    const int64_t conv_inner  = enc_h * hp.enc_conv_expansion;
+    const int64_t conv_up_out = conv_inner * 2;
+    const int64_t conv_k      = hp.enc_conv_kernel_size;
+    const int64_t rel_pos_len = 2 * hp.enc_max_pos_emb + 1;
 
     const int64_t prj_h        = hp.prj_hidden;
-    const int64_t prj_im       = (int64_t)hp.prj_hidden * hp.prj_mlp_ratio;
-    const int64_t prj_kv_in    = (int64_t)hp.prj_num_encoder_layers * hp.prj_encoder_dim;
+    const int64_t prj_im       = (int64_t) hp.prj_hidden * hp.prj_mlp_ratio;
+    const int64_t prj_kv_in    = (int64_t) hp.prj_num_encoder_layers * hp.prj_encoder_dim;
     const int64_t prj_llm_dim  = hp.prj_llm_dim;
     const int64_t prj_n_layers = hp.prj_n_layers;
     const int64_t prj_n_query  = hp.prj_block_size / hp.prj_downsample_rate;
@@ -202,19 +375,19 @@ transcribe_status build_granite_nar_weights(ggml_context *            ctx_meta,
     const int64_t dec_nkv   = hp.dec_n_kv_heads;
     const int64_t dec_hd    = hp.dec_head_dim;
     const int64_t dec_im    = hp.dec_intermediate;
-    const int64_t q_out     = dec_nh  * dec_hd;
+    const int64_t q_out     = dec_nh * dec_hd;
     const int64_t kv_out    = dec_nkv * dec_hd;
 
     // Encoder top.
-    GET_LIN(weights.enc_top.input_linear_w, "enc.input_linear.weight", enc_in,  enc_h);
-    GET_F32(weights.enc_top.input_linear_b, "enc.input_linear.bias",   enc_h);
-    GET_LIN(weights.enc_top.ctc_proj_w,     "enc.ctc_proj.weight",     enc_h,   enc_out);
-    GET_F32(weights.enc_top.ctc_proj_b,     "enc.ctc_proj.bias",       enc_out);
-    GET_LIN(weights.enc_top.ctc_bypass_w,   "enc.ctc_bypass.weight",   enc_out, enc_h);
-    GET_F32(weights.enc_top.ctc_bypass_b,   "enc.ctc_bypass.bias",     enc_h);
+    GET_LIN(weights.enc_top.input_linear_w, "enc.input_linear.weight", enc_in, enc_h);
+    GET_F32(weights.enc_top.input_linear_b, "enc.input_linear.bias", enc_h);
+    GET_LIN(weights.enc_top.ctc_proj_w, "enc.ctc_proj.weight", enc_h, enc_out);
+    GET_F32(weights.enc_top.ctc_proj_b, "enc.ctc_proj.bias", enc_out);
+    GET_LIN(weights.enc_top.ctc_bypass_w, "enc.ctc_bypass.weight", enc_out, enc_h);
+    GET_F32(weights.enc_top.ctc_bypass_b, "enc.ctc_bypass.bias", enc_h);
     if (enc_bpe_out > 0) {
-        GET_LIN(weights.enc_top.ctc_bpe_w,  "enc.ctc_bpe.weight",      enc_h,    enc_bpe_out);
-        GET_F32(weights.enc_top.ctc_bpe_b,  "enc.ctc_bpe.bias",        enc_bpe_out);
+        GET_LIN(weights.enc_top.ctc_bpe_w, "enc.ctc_bpe.weight", enc_h, enc_bpe_out);
+        GET_F32(weights.enc_top.ctc_bpe_b, "enc.ctc_bpe.bias", enc_bpe_out);
     }
 
     // Encoder blocks.
@@ -222,101 +395,98 @@ transcribe_status build_granite_nar_weights(ggml_context *            ctx_meta,
     for (int i = 0; i < hp.enc_n_layers; ++i) {
         auto & b = weights.enc_blocks[i];
         GET_F32(b.norm_ff1_w, lname("enc.blocks.%d.norm_ff1.weight", i), enc_h);
-        GET_F32(b.norm_ff1_b, lname("enc.blocks.%d.norm_ff1.bias",   i), enc_h);
-        GET_LIN(b.ff1_up_w,   lname("enc.blocks.%d.ff1_up.weight",   i), enc_h,   enc_ffn);
-        GET_F32(b.ff1_up_b,   lname("enc.blocks.%d.ff1_up.bias",     i), enc_ffn);
+        GET_F32(b.norm_ff1_b, lname("enc.blocks.%d.norm_ff1.bias", i), enc_h);
+        GET_LIN(b.ff1_up_w, lname("enc.blocks.%d.ff1_up.weight", i), enc_h, enc_ffn);
+        GET_F32(b.ff1_up_b, lname("enc.blocks.%d.ff1_up.bias", i), enc_ffn);
         GET_LIN(b.ff1_down_w, lname("enc.blocks.%d.ff1_down.weight", i), enc_ffn, enc_h);
-        GET_F32(b.ff1_down_b, lname("enc.blocks.%d.ff1_down.bias",   i), enc_h);
+        GET_F32(b.ff1_down_b, lname("enc.blocks.%d.ff1_down.bias", i), enc_h);
 
         GET_F32(b.norm_attn_w, lname("enc.blocks.%d.norm_attn.weight", i), enc_h);
-        GET_F32(b.norm_attn_b, lname("enc.blocks.%d.norm_attn.bias",   i), enc_h);
-        GET_LIN(b.attn_q_w,    lname("enc.blocks.%d.attn_q.weight",    i), enc_h, enc_inner);
-        GET_LIN(b.attn_kv_w,   lname("enc.blocks.%d.attn_kv.weight",   i), enc_h, 2 * enc_inner);
-        GET_LIN(b.attn_out_w,  lname("enc.blocks.%d.attn_out.weight",  i), enc_inner, enc_h);
-        GET_F32(b.attn_out_b,  lname("enc.blocks.%d.attn_out.bias",    i), enc_h);
-        GET_LIN(b.attn_rel_pos_emb,
-                lname("enc.blocks.%d.attn_rel_pos_emb.weight", i),
-                hp.enc_head_dim, rel_pos_len);
-
-        GET_F32(b.norm_conv_w,       lname("enc.blocks.%d.norm_conv.weight",       i), enc_h);
-        GET_F32(b.norm_conv_b,       lname("enc.blocks.%d.norm_conv.bias",         i), enc_h);
+        GET_F32(b.norm_attn_b, lname("enc.blocks.%d.norm_attn.bias", i), enc_h);
+        GET_LIN(b.attn_q_w, lname("enc.blocks.%d.attn_q.weight", i), enc_h, enc_inner);
+        GET_LIN(b.attn_kv_w, lname("enc.blocks.%d.attn_kv.weight", i), enc_h, 2 * enc_inner);
+        GET_LIN(b.attn_out_w, lname("enc.blocks.%d.attn_out.weight", i), enc_inner, enc_h);
+        GET_F32(b.attn_out_b, lname("enc.blocks.%d.attn_out.bias", i), enc_h);
+        GET_LIN(b.attn_rel_pos_emb, lname("enc.blocks.%d.attn_rel_pos_emb.weight", i), hp.enc_head_dim, rel_pos_len);
+
+        GET_F32(b.norm_conv_w, lname("enc.blocks.%d.norm_conv.weight", i), enc_h);
+        GET_F32(b.norm_conv_b, lname("enc.blocks.%d.norm_conv.bias", i), enc_h);
         GET_CONV(b.conv_pointwise1_w, lname("enc.blocks.%d.conv_pointwise1.weight", i), 1, enc_h, conv_up_out);
-        GET_F32(b.conv_pointwise1_b,  lname("enc.blocks.%d.conv_pointwise1.bias",   i), conv_up_out);
-        GET_CONV(b.conv_depthwise_w,  lname("enc.blocks.%d.conv_depthwise.weight",  i), conv_k, 1, conv_inner);
-        GET_F32(b.conv_bn_w,          lname("enc.blocks.%d.conv_bn.weight",         i), conv_inner);
-        GET_F32(b.conv_bn_b,          lname("enc.blocks.%d.conv_bn.bias",           i), conv_inner);
-        GET_F32(b.conv_bn_mean,       lname("enc.blocks.%d.conv_bn.running_mean",   i), conv_inner);
-        GET_F32(b.conv_bn_var,        lname("enc.blocks.%d.conv_bn.running_var",    i), conv_inner);
+        GET_F32(b.conv_pointwise1_b, lname("enc.blocks.%d.conv_pointwise1.bias", i), conv_up_out);
+        GET_CONV(b.conv_depthwise_w, lname("enc.blocks.%d.conv_depthwise.weight", i), conv_k, 1, conv_inner);
+        GET_F32(b.conv_bn_w, lname("enc.blocks.%d.conv_bn.weight", i), conv_inner);
+        GET_F32(b.conv_bn_b, lname("enc.blocks.%d.conv_bn.bias", i), conv_inner);
+        GET_F32(b.conv_bn_mean, lname("enc.blocks.%d.conv_bn.running_mean", i), conv_inner);
+        GET_F32(b.conv_bn_var, lname("enc.blocks.%d.conv_bn.running_var", i), conv_inner);
         GET_CONV(b.conv_pointwise2_w, lname("enc.blocks.%d.conv_pointwise2.weight", i), 1, conv_inner, enc_h);
-        GET_F32(b.conv_pointwise2_b,  lname("enc.blocks.%d.conv_pointwise2.bias",   i), enc_h);
+        GET_F32(b.conv_pointwise2_b, lname("enc.blocks.%d.conv_pointwise2.bias", i), enc_h);
 
         GET_F32(b.norm_ff2_w, lname("enc.blocks.%d.norm_ff2.weight", i), enc_h);
-        GET_F32(b.norm_ff2_b, lname("enc.blocks.%d.norm_ff2.bias",   i), enc_h);
-        GET_LIN(b.ff2_up_w,   lname("enc.blocks.%d.ff2_up.weight",   i), enc_h,   enc_ffn);
-        GET_F32(b.ff2_up_b,   lname("enc.blocks.%d.ff2_up.bias",     i), enc_ffn);
+        GET_F32(b.norm_ff2_b, lname("enc.blocks.%d.norm_ff2.bias", i), enc_h);
+        GET_LIN(b.ff2_up_w, lname("enc.blocks.%d.ff2_up.weight", i), enc_h, enc_ffn);
+        GET_F32(b.ff2_up_b, lname("enc.blocks.%d.ff2_up.bias", i), enc_ffn);
         GET_LIN(b.ff2_down_w, lname("enc.blocks.%d.ff2_down.weight", i), enc_ffn, enc_h);
-        GET_F32(b.ff2_down_b, lname("enc.blocks.%d.ff2_down.bias",   i), enc_h);
+        GET_F32(b.ff2_down_b, lname("enc.blocks.%d.ff2_down.bias", i), enc_h);
 
         GET_F32(b.norm_post_w, lname("enc.blocks.%d.norm_post.weight", i), enc_h);
-        GET_F32(b.norm_post_b, lname("enc.blocks.%d.norm_post.bias",   i), enc_h);
+        GET_F32(b.norm_post_b, lname("enc.blocks.%d.norm_post.bias", i), enc_h);
     }
 
     // Projector top.
     GET_LIN(weights.proj_top.layer_projector_w, "prj.layer_projector.weight", prj_kv_in, prj_h);
-    GET_F32(weights.proj_top.layer_projector_b, "prj.layer_projector.bias",   prj_h);
-    GET_F32(weights.proj_top.out_norm_w,        "prj.out_norm.weight",        prj_h);
-    GET_F32(weights.proj_top.out_norm_b,        "prj.out_norm.bias",          prj_h);
-    GET_LIN(weights.proj_top.out_linear_w,      "prj.out_linear.weight",      prj_h, prj_llm_dim);
-    GET_F32(weights.proj_top.out_linear_b,      "prj.out_linear.bias",        prj_llm_dim);
+    GET_F32(weights.proj_top.layer_projector_b, "prj.layer_projector.bias", prj_h);
+    GET_F32(weights.proj_top.out_norm_w, "prj.out_norm.weight", prj_h);
+    GET_F32(weights.proj_top.out_norm_b, "prj.out_norm.bias", prj_h);
+    GET_LIN(weights.proj_top.out_linear_w, "prj.out_linear.weight", prj_h, prj_llm_dim);
+    GET_F32(weights.proj_top.out_linear_b, "prj.out_linear.bias", prj_llm_dim);
     // query is [1, n_query=3, hidden=2048]. In HF tensor.shape this is
     // (1, 3, 2048). ggml stores reverse: ne[0]=2048, ne[1]=3, ne[2]=1.
     {
         ggml_tensor * _t = transcribe::weights::find_tensor(
-            ctx_meta, "prj.query",
-            {GGML_TYPE_F32, GGML_TYPE_BF16, GGML_TYPE_F16},
-            {prj_h, prj_n_query, 1}, kTag);
-        if (_t == nullptr) return TRANSCRIBE_ERR_GGUF;
+            ctx_meta, "prj.query", { GGML_TYPE_F32, GGML_TYPE_BF16, GGML_TYPE_F16 }, { prj_h, prj_n_query, 1 }, kTag);
+        if (_t == nullptr) {
+            return TRANSCRIBE_ERR_GGUF;
+        }
         weights.proj_top.query = _t;
     }
     {
-        ggml_tensor * _t = transcribe::weights::find_tensor(
-            ctx_meta, "prj.window_positions",
-            {GGML_TYPE_F32, GGML_TYPE_BF16, GGML_TYPE_F16},
-            {prj_h, prj_block_sz, 1}, kTag);
-        if (_t == nullptr) return TRANSCRIBE_ERR_GGUF;
+        ggml_tensor * _t = transcribe::weights::find_tensor(ctx_meta, "prj.window_positions",
+                                                            { GGML_TYPE_F32, GGML_TYPE_BF16, GGML_TYPE_F16 },
+                                                            { prj_h, prj_block_sz, 1 }, kTag);
+        if (_t == nullptr) {
+            return TRANSCRIBE_ERR_GGUF;
+        }
         weights.proj_top.window_positions = _t;
     }
 
     weights.proj_top.layer_norms_w.assign(prj_num_enc, nullptr);
     weights.proj_top.layer_norms_b.assign(prj_num_enc, nullptr);
     for (int j = 0; j < prj_num_enc; ++j) {
-        GET_F32(weights.proj_top.layer_norms_w[j],
-                lname("prj.layer_norms.%d.weight", j), hp.prj_encoder_dim);
-        GET_F32(weights.proj_top.layer_norms_b[j],
-                lname("prj.layer_norms.%d.bias",   j), hp.prj_encoder_dim);
+        GET_F32(weights.proj_top.layer_norms_w[j], lname("prj.layer_norms.%d.weight", j), hp.prj_encoder_dim);
+        GET_F32(weights.proj_top.layer_norms_b[j], lname("prj.layer_norms.%d.bias", j), hp.prj_encoder_dim);
     }
 
     weights.proj_blocks.assign(prj_n_layers, GraniteNarProjBlock{});
     for (int i = 0; i < prj_n_layers; ++i) {
         auto & b = weights.proj_blocks[i];
         GET_F32(b.norm_attn_w, lname("prj.blocks.%d.norm_attn.weight", i), prj_h);
-        GET_F32(b.norm_attn_b, lname("prj.blocks.%d.norm_attn.bias",   i), prj_h);
+        GET_F32(b.norm_attn_b, lname("prj.blocks.%d.norm_attn.bias", i), prj_h);
 
         GET_LIN(b.cross_attn_q_w, lname("prj.blocks.%d.cross_attn_q.weight", i), prj_h, prj_h);
-        GET_F32(b.cross_attn_q_b, lname("prj.blocks.%d.cross_attn_q.bias",   i), prj_h);
+        GET_F32(b.cross_attn_q_b, lname("prj.blocks.%d.cross_attn_q.bias", i), prj_h);
         GET_LIN(b.cross_attn_k_w, lname("prj.blocks.%d.cross_attn_k.weight", i), prj_h, prj_h);
-        GET_F32(b.cross_attn_k_b, lname("prj.blocks.%d.cross_attn_k.bias",   i), prj_h);
+        GET_F32(b.cross_attn_k_b, lname("prj.blocks.%d.cross_attn_k.bias", i), prj_h);
         GET_LIN(b.cross_attn_v_w, lname("prj.blocks.%d.cross_attn_v.weight", i), prj_h, prj_h);
-        GET_F32(b.cross_attn_v_b, lname("prj.blocks.%d.cross_attn_v.bias",   i), prj_h);
+        GET_F32(b.cross_attn_v_b, lname("prj.blocks.%d.cross_attn_v.bias", i), prj_h);
         GET_LIN(b.cross_attn_o_w, lname("prj.blocks.%d.cross_attn_o.weight", i), prj_h, prj_h);
-        GET_F32(b.cross_attn_o_b, lname("prj.blocks.%d.cross_attn_o.bias",   i), prj_h);
+        GET_F32(b.cross_attn_o_b, lname("prj.blocks.%d.cross_attn_o.bias", i), prj_h);
 
         GET_F32(b.norm_ffn_w, lname("prj.blocks.%d.norm_ffn.weight", i), prj_h);
-        GET_F32(b.norm_ffn_b, lname("prj.blocks.%d.norm_ffn.bias",   i), prj_h);
-        GET_LIN(b.ffn_fc1_w,  lname("prj.blocks.%d.ffn_fc1.weight",  i), prj_h, prj_im);
-        GET_F32(b.ffn_fc1_b,  lname("prj.blocks.%d.ffn_fc1.bias",    i), prj_im);
-        GET_LIN(b.ffn_fc2_w,  lname("prj.blocks.%d.ffn_fc2.weight",  i), prj_im, prj_h);
-        GET_F32(b.ffn_fc2_b,  lname("prj.blocks.%d.ffn_fc2.bias",    i), prj_h);
+        GET_F32(b.norm_ffn_b, lname("prj.blocks.%d.norm_ffn.bias", i), prj_h);
+        GET_LIN(b.ffn_fc1_w, lname("prj.blocks.%d.ffn_fc1.weight", i), prj_h, prj_im);
+        GET_F32(b.ffn_fc1_b, lname("prj.blocks.%d.ffn_fc1.bias", i), prj_im);
+        GET_LIN(b.ffn_fc2_w, lname("prj.blocks.%d.ffn_fc2.weight", i), prj_im, prj_h);
+        GET_F32(b.ffn_fc2_b, lname("prj.blocks.%d.ffn_fc2.bias", i), prj_h);
     }
 
     // LLM (granite-4).
@@ -326,14 +496,14 @@ transcribe_status build_granite_nar_weights(ggml_context *            ctx_meta,
     for (int i = 0; i < hp.dec_n_layers; ++i) {
         auto & b = weights.dec_blocks[i];
         GET_F32(b.norm_attn_w, lname("dec.blocks.%d.norm_attn.weight", i), dec_h);
-        GET_F32(b.norm_ffn_w,  lname("dec.blocks.%d.norm_ffn.weight",  i), dec_h);
-        GET_LIN(b.attn_q_w,    lname("dec.blocks.%d.attn.q.weight",    i), dec_h, q_out);
-        GET_LIN(b.attn_k_w,    lname("dec.blocks.%d.attn.k.weight",    i), dec_h, kv_out);
-        GET_LIN(b.attn_v_w,    lname("dec.blocks.%d.attn.v.weight",    i), dec_h, kv_out);
-        GET_LIN(b.attn_o_w,    lname("dec.blocks.%d.attn.o.weight",    i), q_out, dec_h);
-        GET_LIN(b.ffn_gate_w,  lname("dec.blocks.%d.ffn.gate.weight",  i), dec_h, dec_im);
-        GET_LIN(b.ffn_up_w,    lname("dec.blocks.%d.ffn.up.weight",    i), dec_h, dec_im);
-        GET_LIN(b.ffn_down_w,  lname("dec.blocks.%d.ffn.down.weight",  i), dec_im, dec_h);
+        GET_F32(b.norm_ffn_w, lname("dec.blocks.%d.norm_ffn.weight", i), dec_h);
+        GET_LIN(b.attn_q_w, lname("dec.blocks.%d.attn.q.weight", i), dec_h, q_out);
+        GET_LIN(b.attn_k_w, lname("dec.blocks.%d.attn.k.weight", i), dec_h, kv_out);
+        GET_LIN(b.attn_v_w, lname("dec.blocks.%d.attn.v.weight", i), dec_h, kv_out);
+        GET_LIN(b.attn_o_w, lname("dec.blocks.%d.attn.o.weight", i), q_out, dec_h);
+        GET_LIN(b.ffn_gate_w, lname("dec.blocks.%d.ffn.gate.weight", i), dec_h, dec_im);
+        GET_LIN(b.ffn_up_w, lname("dec.blocks.%d.ffn.up.weight", i), dec_h, dec_im);
+        GET_LIN(b.ffn_down_w, lname("dec.blocks.%d.ffn.down.weight", i), dec_im, dec_h);
     }
 
     GET_F32(weights.dec_final.norm_w, "dec.output_norm.weight", dec_h);
@@ -341,4 +511,4 @@ transcribe_status build_granite_nar_weights(ggml_context *            ctx_meta,
     return TRANSCRIBE_OK;
 }
 
-} // namespace transcribe::granite_nar
+}  // namespace transcribe::granite_nar
diff --git a/src/arch/granite_nar/weights.h b/src/arch/granite_nar/weights.h
index 8a7becf4..a1fab0de 100644
--- a/src/arch/granite_nar/weights.h
+++ b/src/arch/granite_nar/weights.h
@@ -40,25 +40,25 @@ namespace transcribe::granite_nar {
 
 struct GraniteNarHParams {
     // Encoder
-    int32_t enc_n_layers         = 0;   // 16
-    int32_t enc_hidden           = 0;   // 1024
-    int32_t enc_n_heads          = 0;   // 8
-    int32_t enc_head_dim         = 0;   // 128
-    int32_t enc_input_dim        = 0;   // 160 (2 stacked mel frames)
-    int32_t enc_output_dim       = 0;   // 348 (CTC char vocab)
-    int32_t enc_bpe_output_dim   = 0;   // 100352 (new snapshot) or 100353 (old)
-    int32_t enc_bpe_pool_window  = 0;   // 4
+    int32_t enc_n_layers         = 0;  // 16
+    int32_t enc_hidden           = 0;  // 1024
+    int32_t enc_n_heads          = 0;  // 8
+    int32_t enc_head_dim         = 0;  // 128
+    int32_t enc_input_dim        = 0;  // 160 (2 stacked mel frames)
+    int32_t enc_output_dim       = 0;  // 348 (CTC char vocab)
+    int32_t enc_bpe_output_dim   = 0;  // 100352 (new snapshot) or 100353 (old)
+    int32_t enc_bpe_pool_window  = 0;  // 4
     // BPE-CTC blank id. New snapshot: 100257 (BOS, channel exists inside
     // the bpe_output_dim=vocab_size head, decode uses argmax directly).
     // Old snapshot: 0 (separate blank channel at index 0, decode subtracts 1
     // from non-blank argmax to recover the LLM token id).
     int32_t enc_bpe_blank_id     = 0;
-    int32_t enc_self_cond_layer  = 0;   // 8 (1-indexed boundary)
-    int32_t enc_feedforward_mult = 0;   // 4
-    int32_t enc_conv_kernel_size = 0;   // 15
-    int32_t enc_conv_expansion   = 0;   // 2
-    int32_t enc_max_pos_emb      = 0;   // 512
-    int32_t enc_context_size     = 0;   // 200
+    int32_t enc_self_cond_layer  = 0;  // 8 (1-indexed boundary)
+    int32_t enc_feedforward_mult = 0;  // 4
+    int32_t enc_conv_kernel_size = 0;  // 15
+    int32_t enc_conv_expansion   = 0;  // 2
+    int32_t enc_max_pos_emb      = 0;  // 512
+    int32_t enc_context_size     = 0;  // 200
 
     // 1-indexed layer indices to capture into the projector's multi-layer
     // concat. e.g. [4, 8, 12, -1]. Negative values are interpreted as
@@ -86,30 +86,30 @@ struct GraniteNarHParams {
     bool scale_projected_embeddings = true;
 
     // Text LM (Granite-4)
-    int32_t dec_n_layers      = 0;  // 40
-    int32_t dec_hidden        = 0;  // 2048
-    int32_t dec_intermediate  = 0;  // 4096
-    int32_t dec_n_heads       = 0;  // 16
-    int32_t dec_n_kv_heads    = 0;  // 4
-    int32_t dec_head_dim      = 0;  // 128
+    int32_t     dec_n_layers     = 0;  // 40
+    int32_t     dec_hidden       = 0;  // 2048
+    int32_t     dec_intermediate = 0;  // 4096
+    int32_t     dec_n_heads      = 0;  // 16
+    int32_t     dec_n_kv_heads   = 0;  // 4
+    int32_t     dec_head_dim     = 0;  // 128
     std::string dec_hidden_act;
-    float   dec_rms_norm_eps  = 0.0f;
-    float   dec_rope_theta    = 0.0f;
-    int32_t dec_max_pos_emb   = 0;
-    bool    dec_tie_word_embeddings = true;
-    int32_t dec_vocab_size    = 0;  // 100352
+    float       dec_rms_norm_eps        = 0.0f;
+    float       dec_rope_theta          = 0.0f;
+    int32_t     dec_max_pos_emb         = 0;
+    bool        dec_tie_word_embeddings = true;
+    int32_t     dec_vocab_size          = 0;  // 100352
 
-    float dec_embedding_multiplier = 0.0f;  // 12
-    float dec_logits_scaling       = 0.0f;  // 8
-    float dec_attention_multiplier = 0.0f;  // 1/128 = 0.0078125
-    float dec_residual_multiplier  = 0.0f;  // 0.22
+    float dec_embedding_multiplier = 0.0f;    // 12
+    float dec_logits_scaling       = 0.0f;    // 8
+    float dec_attention_multiplier = 0.0f;    // 1/128 = 0.0078125
+    float dec_residual_multiplier  = 0.0f;    // 0.22
 
     int32_t dec_bos_id = 0;
     int32_t dec_eos_id = 0;
     int32_t dec_pad_id = 0;
 
     // Frontend
-    std::string fe_type;             // "mel"
+    std::string fe_type;  // "mel"
     int32_t     fe_sample_rate = 0;
     int32_t     fe_num_mels    = 0;
     int32_t     fe_n_fft       = 0;
@@ -125,8 +125,7 @@ struct GraniteNarHParams {
     std::vector<std::string> ctc_chars;
 };
 
-transcribe_status read_granite_nar_hparams(const gguf_context * gguf,
-                                           GraniteNarHParams &  hp);
+transcribe_status read_granite_nar_hparams(const gguf_context * gguf, GraniteNarHParams & hp);
 
 // Weight slots
 
@@ -143,45 +142,45 @@ struct GraniteNarEncTop {
 
 struct GraniteNarEncBlock {
     // FF1 macaron
-    ggml_tensor * norm_ff1_w   = nullptr;
-    ggml_tensor * norm_ff1_b   = nullptr;
-    ggml_tensor * ff1_up_w     = nullptr;
-    ggml_tensor * ff1_up_b     = nullptr;
-    ggml_tensor * ff1_down_w   = nullptr;
-    ggml_tensor * ff1_down_b   = nullptr;
+    ggml_tensor * norm_ff1_w          = nullptr;
+    ggml_tensor * norm_ff1_b          = nullptr;
+    ggml_tensor * ff1_up_w            = nullptr;
+    ggml_tensor * ff1_up_b            = nullptr;
+    ggml_tensor * ff1_down_w          = nullptr;
+    ggml_tensor * ff1_down_b          = nullptr;
     // Shaw block-local attention
-    ggml_tensor * norm_attn_w  = nullptr;
-    ggml_tensor * norm_attn_b  = nullptr;
-    ggml_tensor * attn_q_w     = nullptr;
-    ggml_tensor * attn_kv_w    = nullptr;
-    ggml_tensor * attn_out_w   = nullptr;
-    ggml_tensor * attn_out_b   = nullptr;
-    ggml_tensor * attn_rel_pos_emb = nullptr;
+    ggml_tensor * norm_attn_w         = nullptr;
+    ggml_tensor * norm_attn_b         = nullptr;
+    ggml_tensor * attn_q_w            = nullptr;
+    ggml_tensor * attn_kv_w           = nullptr;
+    ggml_tensor * attn_out_w          = nullptr;
+    ggml_tensor * attn_out_b          = nullptr;
+    ggml_tensor * attn_rel_pos_emb    = nullptr;
     // Conv module
-    ggml_tensor * norm_conv_w        = nullptr;
-    ggml_tensor * norm_conv_b        = nullptr;
-    ggml_tensor * conv_pointwise1_w  = nullptr;
-    ggml_tensor * conv_pointwise1_b  = nullptr;
-    ggml_tensor * conv_depthwise_w   = nullptr;
-    ggml_tensor * conv_bn_w          = nullptr;
-    ggml_tensor * conv_bn_b          = nullptr;
-    ggml_tensor * conv_bn_mean       = nullptr;
-    ggml_tensor * conv_bn_var        = nullptr;
-    ggml_tensor * conv_pointwise2_w  = nullptr;
-    ggml_tensor * conv_pointwise2_b  = nullptr;
+    ggml_tensor * norm_conv_w         = nullptr;
+    ggml_tensor * norm_conv_b         = nullptr;
+    ggml_tensor * conv_pointwise1_w   = nullptr;
+    ggml_tensor * conv_pointwise1_b   = nullptr;
+    ggml_tensor * conv_depthwise_w    = nullptr;
+    ggml_tensor * conv_bn_w           = nullptr;
+    ggml_tensor * conv_bn_b           = nullptr;
+    ggml_tensor * conv_bn_mean        = nullptr;
+    ggml_tensor * conv_bn_var         = nullptr;
+    ggml_tensor * conv_pointwise2_w   = nullptr;
+    ggml_tensor * conv_pointwise2_b   = nullptr;
     // Pre-fused BN (computed at load time).
     ggml_tensor * conv_bn_fused_scale = nullptr;
     ggml_tensor * conv_bn_fused_bias  = nullptr;
     // FF2 macaron
-    ggml_tensor * norm_ff2_w   = nullptr;
-    ggml_tensor * norm_ff2_b   = nullptr;
-    ggml_tensor * ff2_up_w     = nullptr;
-    ggml_tensor * ff2_up_b     = nullptr;
-    ggml_tensor * ff2_down_w   = nullptr;
-    ggml_tensor * ff2_down_b   = nullptr;
+    ggml_tensor * norm_ff2_w          = nullptr;
+    ggml_tensor * norm_ff2_b          = nullptr;
+    ggml_tensor * ff2_up_w            = nullptr;
+    ggml_tensor * ff2_up_b            = nullptr;
+    ggml_tensor * ff2_down_w          = nullptr;
+    ggml_tensor * ff2_down_b          = nullptr;
     // Post-block LayerNorm
-    ggml_tensor * norm_post_w  = nullptr;
-    ggml_tensor * norm_post_b  = nullptr;
+    ggml_tensor * norm_post_w         = nullptr;
+    ggml_tensor * norm_post_b         = nullptr;
 };
 
 struct GraniteNarProjTop {
@@ -202,8 +201,8 @@ struct GraniteNarProjTop {
 
 struct GraniteNarProjBlock {
     // pre-norm before cross-attention
-    ggml_tensor * norm_attn_w   = nullptr;
-    ggml_tensor * norm_attn_b   = nullptr;
+    ggml_tensor * norm_attn_w    = nullptr;
+    ggml_tensor * norm_attn_b    = nullptr;
     // cross-attention (q from query stream, k/v from encoder slice)
     ggml_tensor * cross_attn_q_w = nullptr;
     ggml_tensor * cross_attn_q_b = nullptr;
@@ -214,17 +213,17 @@ struct GraniteNarProjBlock {
     ggml_tensor * cross_attn_o_w = nullptr;
     ggml_tensor * cross_attn_o_b = nullptr;
     // pre-norm before FFN
-    ggml_tensor * norm_ffn_w    = nullptr;
-    ggml_tensor * norm_ffn_b    = nullptr;
+    ggml_tensor * norm_ffn_w     = nullptr;
+    ggml_tensor * norm_ffn_b     = nullptr;
     // FFN (fc1 -> SiLU -> fc2)
-    ggml_tensor * ffn_fc1_w     = nullptr;
-    ggml_tensor * ffn_fc1_b     = nullptr;
-    ggml_tensor * ffn_fc2_w     = nullptr;
-    ggml_tensor * ffn_fc2_b     = nullptr;
+    ggml_tensor * ffn_fc1_w      = nullptr;
+    ggml_tensor * ffn_fc1_b      = nullptr;
+    ggml_tensor * ffn_fc2_w      = nullptr;
+    ggml_tensor * ffn_fc2_b      = nullptr;
 };
 
 struct GraniteNarDecEmbed {
-    ggml_tensor * token_w = nullptr;   // tied: also serves as lm_head
+    ggml_tensor * token_w = nullptr;  // tied: also serves as lm_head
 };
 
 struct GraniteNarDecBlock {
@@ -244,19 +243,19 @@ struct GraniteNarDecFinal {
 };
 
 struct GraniteNarWeights {
-    GraniteNarEncTop                   enc_top;
-    std::vector<GraniteNarEncBlock>    enc_blocks;
+    GraniteNarEncTop                enc_top;
+    std::vector<GraniteNarEncBlock> enc_blocks;
 
-    GraniteNarProjTop                  proj_top;
-    std::vector<GraniteNarProjBlock>   proj_blocks;
+    GraniteNarProjTop                proj_top;
+    std::vector<GraniteNarProjBlock> proj_blocks;
 
-    GraniteNarDecEmbed                 dec_embed;
-    std::vector<GraniteNarDecBlock>    dec_blocks;
-    GraniteNarDecFinal                 dec_final;
+    GraniteNarDecEmbed              dec_embed;
+    std::vector<GraniteNarDecBlock> dec_blocks;
+    GraniteNarDecFinal              dec_final;
 };
 
-transcribe_status build_granite_nar_weights(ggml_context *           ctx_meta,
+transcribe_status build_granite_nar_weights(ggml_context *            ctx_meta,
                                             const GraniteNarHParams & hp,
-                                            GraniteNarWeights &      weights);
+                                            GraniteNarWeights &       weights);
 
-} // namespace transcribe::granite_nar
+}  // namespace transcribe::granite_nar
diff --git a/src/arch/medasr/capabilities.cpp b/src/arch/medasr/capabilities.cpp
index fdf8d8ec..77b2ad4e 100644
--- a/src/arch/medasr/capabilities.cpp
+++ b/src/arch/medasr/capabilities.cpp
@@ -34,4 +34,4 @@ void apply_family_invariants(transcribe_model & model) {
     transcribe::set_feature(&model, TRANSCRIBE_FEATURE_CANCELLATION, true);
 }
 
-} // namespace transcribe::medasr
+}  // namespace transcribe::medasr
diff --git a/src/arch/medasr/encoder.cpp b/src/arch/medasr/encoder.cpp
index d8395d84..e096fee8 100644
--- a/src/arch/medasr/encoder.cpp
+++ b/src/arch/medasr/encoder.cpp
@@ -11,14 +11,12 @@
 
 #include "encoder.h"
 
-#include "weights.h"
-
 #include "conformer/conformer.h"
+#include "ggml.h"
 #include "transcribe-debug.h"
 #include "transcribe-flash-policy.h"
 #include "transcribe-log.h"
-
-#include "ggml.h"
+#include "weights.h"
 
 #include <cmath>
 #include <cstdio>
@@ -38,10 +36,7 @@ namespace conf = transcribe::conformer;
 // overflows to NaN and every transcript comes back empty. GGML_PREC_F32
 // matches CPU/Metal's always-F32 accumulate. No-op on CPU/Metal and on
 // non-F16 weights (BF16 already COMPUTE_32F; quantized routes through MMQ).
-ggml_tensor * mul_mat_f32acc(ggml_context * ctx,
-                             ggml_tensor *  w,
-                             ggml_tensor *  x)
-{
+ggml_tensor * mul_mat_f32acc(ggml_context * ctx, ggml_tensor * w, ggml_tensor * x) {
     ggml_tensor * y = ggml_mul_mat(ctx, w, x);
     if (w->type == GGML_TYPE_F16) {
         ggml_mul_mat_set_prec(y, GGML_PREC_F32);
@@ -53,11 +48,7 @@ ggml_tensor * mul_mat_f32acc(ggml_context * ctx,
 // `nn.LayerNorm(hidden_size, layer_norm_eps, bias=False)` on every
 // encoder LN; eps is loaded from the GGUF (1e-6 for medasr) and is
 // distinct from the conformer helper's hardcoded 1e-5.
-ggml_tensor * lasr_layer_norm(ggml_context * ctx,
-                              ggml_tensor *  x,
-                              ggml_tensor *  scale,
-                              float          eps)
-{
+ggml_tensor * lasr_layer_norm(ggml_context * ctx, ggml_tensor * x, ggml_tensor * scale, float eps) {
     x = ggml_norm(ctx, x, eps);
     if (scale != nullptr) {
         x = ggml_mul(ctx, x, scale);
@@ -67,11 +58,7 @@ ggml_tensor * lasr_layer_norm(ggml_context * ctx,
 
 // Two-linear feed forward with no biases: y = Linear2(SiLU(Linear1(x))).
 // Matches LASR's `LasrEncoderFeedForward` (SiLU activation via hidden_act).
-ggml_tensor * lasr_feed_forward(ggml_context * ctx,
-                                ggml_tensor *  x,
-                                ggml_tensor *  up_w,
-                                ggml_tensor *  down_w)
-{
+ggml_tensor * lasr_feed_forward(ggml_context * ctx, ggml_tensor * x, ggml_tensor * up_w, ggml_tensor * down_w) {
     x = mul_mat_f32acc(ctx, up_w, x);
     x = ggml_silu(ctx, x);
     x = mul_mat_f32acc(ctx, down_w, x);
@@ -81,14 +68,9 @@ ggml_tensor * lasr_feed_forward(ggml_context * ctx,
 // Scaled residual: out = w0 * residual + w1 * branch. Used for FF1/FF2
 // macaron (w0=1.5, w1=0.5) and conv (w0=2.0, w1=1.0). For the standard
 // w0=1.0 residual we just ggml_add directly.
-ggml_tensor * scaled_residual(ggml_context * ctx,
-                              ggml_tensor *  residual,
-                              ggml_tensor *  branch,
-                              float          w0,
-                              float          w1)
-{
+ggml_tensor * scaled_residual(ggml_context * ctx, ggml_tensor * residual, ggml_tensor * branch, float w0, float w1) {
     ggml_tensor * a = (w0 == 1.0f) ? residual : ggml_scale(ctx, residual, w0);
-    ggml_tensor * b = (w1 == 1.0f) ? branch   : ggml_scale(ctx, branch,   w1);
+    ggml_tensor * b = (w1 == 1.0f) ? branch : ggml_scale(ctx, branch, w1);
     return ggml_add(ctx, a, b);
 }
 
@@ -103,15 +85,13 @@ ggml_tensor * build_subsampling(ggml_context *            ctx,
                                 const MedAsrSubsampling & ss,
                                 ggml_tensor *             mel_in,
                                 const MedAsrHParams &     hp,
-                                const conf::ConvPolicy &  /*policy*/,
-                                EncoderDumps *            dumps = nullptr)
-{
+                                const conf::ConvPolicy & /*policy*/,
+                                EncoderDumps * dumps = nullptr) {
     const int sub_k = hp.enc_sub_kernel;
 
     // mel_in ne=[n_mels, T_mel, 1, B]. Squeeze the singleton ne[2] so
     // dense_0's mul_mat sees a clean [n_mels, T_mel, B].
-    ggml_tensor * x = ggml_reshape_3d(ctx, mel_in,
-                                      mel_in->ne[0], mel_in->ne[1], mel_in->ne[3]);
+    ggml_tensor * x = ggml_reshape_3d(ctx, mel_in, mel_in->ne[0], mel_in->ne[1], mel_in->ne[3]);
 
     // dense_0: Linear(n_mels -> d_model). mul_mat broadcasts over the
     // batch axis (ne[2]).
@@ -135,7 +115,7 @@ ggml_tensor * build_subsampling(ggml_context *            ctx,
                           /*padding=*/0, /*dilation=*/1);
     if (ss.conv0_b != nullptr) {
         ggml_tensor * bias_r = ggml_reshape_3d(ctx, ss.conv0_b, 1, x->ne[1], 1);
-        x = ggml_add(ctx, x, bias_r);
+        x                    = ggml_add(ctx, x, bias_r);
     }
     x = ggml_relu(ctx, x);
     if (dumps != nullptr) {
@@ -149,7 +129,7 @@ ggml_tensor * build_subsampling(ggml_context *            ctx,
                           /*padding=*/0, /*dilation=*/1);
     if (ss.conv1_b != nullptr) {
         ggml_tensor * bias_r = ggml_reshape_3d(ctx, ss.conv1_b, 1, x->ne[1], 1);
-        x = ggml_add(ctx, x, bias_r);
+        x                    = ggml_add(ctx, x, bias_r);
     }
     x = ggml_relu(ctx, x);
     if (dumps != nullptr) {
@@ -203,11 +183,10 @@ ggml_tensor * build_conv_module(ggml_context *           ctx,
                                 int                      d_model,
                                 int                      conv_kernel,
                                 const conf::ConvPolicy & policy,
-                                ggml_tensor *            conv_pad_mask)
-{
-    conf::BlockView bv {};
+                                ggml_tensor *            conv_pad_mask) {
+    conf::BlockView bv{};
     bv.conv_pw1_w          = b.conv_pw1_w;
-    bv.conv_pw1_b          = nullptr;   // bias=False on LASR conv layers
+    bv.conv_pw1_b          = nullptr;  // bias=False on LASR conv layers
     bv.conv_dw_w           = b.conv_dw_w;
     bv.conv_dw_b           = nullptr;
     bv.conv_pw2_w          = b.conv_pw2_w;
@@ -215,15 +194,15 @@ ggml_tensor * build_conv_module(ggml_context *           ctx,
     bv.conv_bn_fused_scale = bn_scale;
     bv.conv_bn_fused_bias  = bn_bias;
 
-    conf::BlockParams bp {};
+    conf::BlockParams bp{};
     bp.d_model            = d_model;
-    bp.n_head             = 0;          // unused in conv_module
+    bp.n_head             = 0;  // unused in conv_module
     bp.conv_kernel        = conv_kernel;
     bp.kv_type            = GGML_TYPE_F32;
-    bp.use_flash          = false;      // irrelevant for conv_module
+    bp.use_flash          = false;                                   // irrelevant for conv_module
     bp.policy             = policy;
-    bp.conv_context_left  = (conv_kernel - 1) / 2;       // 15 for k=32
-    bp.conv_context_right = conv_kernel - 1 - bp.conv_context_left; // 16
+    bp.conv_context_left  = (conv_kernel - 1) / 2;                   // 15 for k=32
+    bp.conv_context_right = conv_kernel - 1 - bp.conv_context_left;  // 16
     bp.conv_norm_type     = conf::BlockParams::ConvNormType::BatchNorm;
     bp.conv_pad_mask      = conv_pad_mask;
 
@@ -257,8 +236,7 @@ ggml_tensor * build_rope_attn(ggml_context *      ctx,
                               float               rope_theta,
                               int                 rope_max_pos,
                               bool                use_flash,
-                              ggml_tensor *       attn_pad_mask = nullptr)
-{
+                              ggml_tensor *       attn_pad_mask = nullptr) {
     const int     head_dim = d_model / n_head;
     const float   scale    = 1.0f / std::sqrt(static_cast<float>(head_dim));
     const int64_t T        = x->ne[1];
@@ -307,20 +285,18 @@ ggml_tensor * build_rope_attn(ggml_context *      ctx,
 
     ggml_tensor * o;
     if (flash) {
-        o = ggml_flash_attn_ext(ctx, q, k, v, /*mask=*/nullptr,
-                                scale, 0.0f, 0.0f);
+        o = ggml_flash_attn_ext(ctx, q, k, v, /*mask=*/nullptr, scale, 0.0f, 0.0f);
         // ggml_flash_attn_ext returns [head_dim, n_head, T, B].
         o = ggml_permute(ctx, o, 0, 2, 1, 3);
         o = ggml_cont(ctx, o);
     } else {
-        ggml_tensor * kq = ggml_mul_mat(ctx, k, q); // [T_k, T_q, n_head, B]
+        ggml_tensor * kq = ggml_mul_mat(ctx, k, q);  // [T_k, T_q, n_head, B]
         if (attn_pad_mask != nullptr) {
             kq = ggml_add(ctx, kq, attn_pad_mask);
         }
-        ggml_tensor * kq_soft = ggml_soft_max_ext(ctx, kq, /*mask=*/nullptr,
-                                                  scale, 0.0f);
-        ggml_tensor * v_t = ggml_cont(ctx, ggml_permute(ctx, v, 1, 0, 2, 3));
-        o = ggml_mul_mat(ctx, v_t, kq_soft);
+        ggml_tensor * kq_soft = ggml_soft_max_ext(ctx, kq, /*mask=*/nullptr, scale, 0.0f);
+        ggml_tensor * v_t     = ggml_cont(ctx, ggml_permute(ctx, v, 1, 0, 2, 3));
+        o                     = ggml_mul_mat(ctx, v_t, kq_soft);
     }
     // o: [head_dim, T, n_head, B] -> [head_dim, n_head, T, B] -> [d_model, T, B]
     o = ggml_permute(ctx, o, 0, 2, 1, 3);
@@ -353,59 +329,64 @@ ggml_tensor * build_block(ggml_context *           ctx,
                           bool                     use_flash,
                           ggml_tensor *            attn_pad_mask,
                           ggml_tensor *            conv_pad_mask,
-                          BlockObs *               obs)
-{
-    const int d_model    = hp.enc_hidden;
-    const int n_head     = hp.enc_n_heads;
-    const int conv_k     = hp.enc_conv_kernel;
+                          BlockObs *               obs) {
+    const int   d_model  = hp.enc_hidden;
+    const int   n_head   = hp.enc_n_heads;
+    const int   conv_k   = hp.enc_conv_kernel;
     const float ln_eps   = hp.enc_layer_norm_eps;
     const float rope_th  = hp.enc_rope_theta;
-    const int rope_max   = hp.enc_max_pos_emb;
-    const float ff_w0    = hp.enc_ff_resid_w0;   // 1.5
-    const float ff_w1    = hp.enc_ff_resid_w1;   // 0.5
-    const float conv_w0  = hp.enc_conv_resid_w0; // 2.0
-    const float conv_w1  = hp.enc_conv_resid_w1; // 1.0
+    const int   rope_max = hp.enc_max_pos_emb;
+    const float ff_w0    = hp.enc_ff_resid_w0;    // 1.5
+    const float ff_w1    = hp.enc_ff_resid_w1;    // 0.5
+    const float conv_w0  = hp.enc_conv_resid_w0;  // 2.0
+    const float conv_w1  = hp.enc_conv_resid_w1;  // 1.0
 
     // Macaron FF1.
     {
         ggml_tensor * y = lasr_layer_norm(ctx, x, b.norm_ff1_w, ln_eps);
-        y = lasr_feed_forward(ctx, y, b.ff1_up_w, b.ff1_down_w);
-        x = scaled_residual(ctx, x, y, ff_w0, ff_w1);
+        y               = lasr_feed_forward(ctx, y, b.ff1_up_w, b.ff1_down_w);
+        x               = scaled_residual(ctx, x, y, ff_w0, ff_w1);
+    }
+    if (obs != nullptr) {
+        obs->post_ff1 = x;
     }
-    if (obs != nullptr) obs->post_ff1 = x;
 
     // Self-attention.
     {
         ggml_tensor * y = lasr_layer_norm(ctx, x, b.norm_attn_w, ln_eps);
-        y = build_rope_attn(ctx, y, positions, b, d_model, n_head,
-                            rope_th, rope_max, use_flash, attn_pad_mask);
+        y = build_rope_attn(ctx, y, positions, b, d_model, n_head, rope_th, rope_max, use_flash, attn_pad_mask);
         x = ggml_add(ctx, x, y);
     }
-    if (obs != nullptr) obs->post_attn = x;
+    if (obs != nullptr) {
+        obs->post_attn = x;
+    }
 
     // Conv module.
     {
         ggml_tensor * y = lasr_layer_norm(ctx, x, b.norm_conv_w, ln_eps);
-        y = build_conv_module(ctx, y, b, bn_scale, bn_bias,
-                              d_model, conv_k, policy, conv_pad_mask);
-        x = scaled_residual(ctx, x, y, conv_w0, conv_w1);
+        y               = build_conv_module(ctx, y, b, bn_scale, bn_bias, d_model, conv_k, policy, conv_pad_mask);
+        x               = scaled_residual(ctx, x, y, conv_w0, conv_w1);
+    }
+    if (obs != nullptr) {
+        obs->post_conv = x;
     }
-    if (obs != nullptr) obs->post_conv = x;
 
     // Macaron FF2.
     {
         ggml_tensor * y = lasr_layer_norm(ctx, x, b.norm_ff2_w, ln_eps);
-        y = lasr_feed_forward(ctx, y, b.ff2_up_w, b.ff2_down_w);
-        x = scaled_residual(ctx, x, y, ff_w0, ff_w1);
+        y               = lasr_feed_forward(ctx, y, b.ff2_up_w, b.ff2_down_w);
+        x               = scaled_residual(ctx, x, y, ff_w0, ff_w1);
+    }
+    if (obs != nullptr) {
+        obs->post_ff2 = x;
     }
-    if (obs != nullptr) obs->post_ff2 = x;
 
     // Final per-block LN (= block output).
     x = lasr_layer_norm(ctx, x, b.norm_post_w, ln_eps);
     return x;
 }
 
-} // namespace
+}  // namespace
 
 EncoderBuild build_encoder_graph(ggml_context *        ctx,
                                  const MedAsrWeights & w,
@@ -413,20 +394,21 @@ EncoderBuild build_encoder_graph(ggml_context *        ctx,
                                  int                   n_mel_frames,
                                  const char *          backend_name,
                                  int                   n_batch,
-                                 bool                  batch_var_len)
-{
-    EncoderBuild eb {};
+                                 bool                  batch_var_len) {
+    EncoderBuild eb{};
     if (ctx == nullptr || n_mel_frames <= 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "medasr encoder: invalid arg "
-                     "(ctx=%p, n_mel_frames=%d)",
-                     static_cast<void *>(ctx), n_mel_frames);
+                "medasr encoder: invalid arg "
+                "(ctx=%p, n_mel_frames=%d)",
+                static_cast<void *>(ctx), n_mel_frames);
         return eb;
     }
-    if (n_batch < 1) n_batch = 1;
+    if (n_batch < 1) {
+        n_batch = 1;
+    }
     const bool var_len_masks = batch_var_len && n_batch > 1;
 
-    const int d_model = hp.enc_hidden;
+    const int d_model  = hp.enc_hidden;
     const int n_layers = hp.enc_n_layers;
 
     // Mel input. The LASR reference dumps `mel.in` as numpy [T_mel, n_mels]
@@ -435,9 +417,10 @@ EncoderBuild build_encoder_graph(ggml_context *        ctx,
     // ne=[n_mels, T_mel, 1, B]. The C++ MelFrontend writes the same
     // [T_mel, n_mels] row-major layout so the same upload byte stream
     // works in both modes.
-    eb.mel_in = ggml_new_tensor_4d(ctx, GGML_TYPE_F32,
-                                   hp.fe_num_mels, n_mel_frames, 1, n_batch);
-    if (eb.mel_in == nullptr) return eb;
+    eb.mel_in = ggml_new_tensor_4d(ctx, GGML_TYPE_F32, hp.fe_num_mels, n_mel_frames, 1, n_batch);
+    if (eb.mel_in == nullptr) {
+        return eb;
+    }
     ggml_set_name(eb.mel_in, "mel.in");
     ggml_set_input(eb.mel_in);
     transcribe::debug::mark_tensor_for_dump(eb.mel_in);
@@ -445,22 +428,23 @@ EncoderBuild build_encoder_graph(ggml_context *        ctx,
     // Conv policy. medasr's depthwise k=32 is too large for the direct
     // 2-D depthwise on some Metal kernels; use im2col im2col_dw to stay safe
     // until empirically profiled. Pointwise is always direct mul_mat.
-    conf::ConvPolicy policy {};
+    conf::ConvPolicy policy{};
     policy.direct_pw               = conf::detect_direct_pw(backend_name);
     policy.direct_dw_in_block      = true;
     policy.direct_dw_in_pre_encode = false;
     policy.causal_pre_encode       = false;
 
     // Build subsampling (passes dumps for stage-by-stage diagnostic).
-    ggml_tensor * x = build_subsampling(ctx, w.subsampling, eb.mel_in, hp,
-                                        policy, &eb.dumps);
-    if (x == nullptr) return eb;
+    ggml_tensor * x = build_subsampling(ctx, w.subsampling, eb.mel_in, hp, policy, &eb.dumps);
+    if (x == nullptr) {
+        return eb;
+    }
     ggml_set_name(x, "enc.subsampling.out");
     eb.dumps.subsampling_out = x;
     transcribe::debug::mark_tensor_for_dump(x);
 
     if (n_layers <= 0) {
-        eb.out = x;
+        eb.out   = x;
         eb.graph = ggml_new_graph(ctx);
         ggml_build_forward_expand(eb.graph, x);
         return eb;
@@ -475,10 +459,8 @@ EncoderBuild build_encoder_graph(ggml_context *        ctx,
 
     // Variable-length batch masks.
     if (var_len_masks) {
-        eb.attn_pad_mask_in = ggml_new_tensor_4d(ctx, GGML_TYPE_F32,
-                                                 T_enc, 1, 1, n_batch);
-        eb.conv_pad_mask_in = ggml_new_tensor_4d(ctx, GGML_TYPE_F32,
-                                                 T_enc, 1, n_batch, 1);
+        eb.attn_pad_mask_in = ggml_new_tensor_4d(ctx, GGML_TYPE_F32, T_enc, 1, 1, n_batch);
+        eb.conv_pad_mask_in = ggml_new_tensor_4d(ctx, GGML_TYPE_F32, T_enc, 1, n_batch, 1);
         ggml_set_name(eb.attn_pad_mask_in, "enc.attn_pad_mask");
         ggml_set_name(eb.conv_pad_mask_in, "enc.conv_pad_mask");
         ggml_set_input(eb.attn_pad_mask_in);
@@ -490,9 +472,11 @@ EncoderBuild build_encoder_graph(ggml_context *        ctx,
     eb.bn_scale_inputs.assign(n_layers, nullptr);
     eb.bn_bias_inputs.assign(n_layers, nullptr);
     for (int i = 0; i < n_layers; ++i) {
-        ggml_tensor * s = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, d_model);
+        ggml_tensor * s  = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, d_model);
         ggml_tensor * bt = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, d_model);
-        if (s == nullptr || bt == nullptr) return eb;
+        if (s == nullptr || bt == nullptr) {
+            return eb;
+        }
         char nm[64];
         std::snprintf(nm, sizeof(nm), "enc.block.%d.conv_bn.scale", i);
         ggml_set_name(s, nm);
@@ -515,27 +499,25 @@ EncoderBuild build_encoder_graph(ggml_context *        ctx,
     eb.dumps.all_block_outs.assign(n_layers, nullptr);
 
     for (int i = 0; i < n_layers; ++i) {
-        BlockObs obs{};
+        BlockObs   obs{};
         const bool with_obs = (i == 0);
-        x = build_block(ctx, x, eb.positions, w.blocks[i],
-                        eb.bn_scale_inputs[i], eb.bn_bias_inputs[i],
-                        hp, policy, use_flash,
-                        eb.attn_pad_mask_in, eb.conv_pad_mask_in,
-                        with_obs ? &obs : nullptr);
+        x = build_block(ctx, x, eb.positions, w.blocks[i], eb.bn_scale_inputs[i], eb.bn_bias_inputs[i], hp, policy,
+                        use_flash, eb.attn_pad_mask_in, eb.conv_pad_mask_in, with_obs ? &obs : nullptr);
 
         if (with_obs) {
             // Block 0 sub-steps.
-            const auto mark = [&](ggml_tensor * t, const char * nm,
-                                  ggml_tensor *& slot) {
-                if (t == nullptr) return;
+            const auto mark = [&](ggml_tensor * t, const char * nm, ggml_tensor *& slot) {
+                if (t == nullptr) {
+                    return;
+                }
                 ggml_set_name(t, nm);
                 transcribe::debug::mark_tensor_for_dump(t);
                 slot = t;
             };
-            mark(obs.post_ff1,  "enc.block.0.post_ff1",  eb.dumps.block0_post_ff1);
+            mark(obs.post_ff1, "enc.block.0.post_ff1", eb.dumps.block0_post_ff1);
             mark(obs.post_attn, "enc.block.0.post_attn", eb.dumps.block0_post_attn);
             mark(obs.post_conv, "enc.block.0.post_conv", eb.dumps.block0_post_conv);
-            mark(obs.post_ff2,  "enc.block.0.post_ff2",  eb.dumps.block0_post_ff2);
+            mark(obs.post_ff2, "enc.block.0.post_ff2", eb.dumps.block0_post_ff2);
         }
 
         char nm[32];
@@ -559,9 +541,8 @@ EncoderBuild build_encoder_graph(ggml_context *        ctx,
     // is byte-equivalent to numpy [T_enc, vocab] — handy for the decode
     // loop's per-frame argmax).
     {
-        ggml_tensor * proj_w = ggml_reshape_2d(ctx, w.ctc_head.proj_w,
-                                               d_model, hp.ctc_vocab_size);
-        x = mul_mat_f32acc(ctx, proj_w, x);
+        ggml_tensor * proj_w = ggml_reshape_2d(ctx, w.ctc_head.proj_w, d_model, hp.ctc_vocab_size);
+        x                    = mul_mat_f32acc(ctx, proj_w, x);
         if (w.ctc_head.proj_b != nullptr) {
             x = ggml_add(ctx, x, w.ctc_head.proj_b);
         }
@@ -588,8 +569,7 @@ EncoderBuild build_encoder_graph(ggml_context *        ctx,
     // CTC head ~ 1000 nodes; 8192 leaves ample headroom.
     eb.graph = ggml_new_graph_custom(ctx, /*size=*/8192, /*grads=*/false);
     if (eb.graph == nullptr) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "medasr encoder: ggml_new_graph_custom failed");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "medasr encoder: ggml_new_graph_custom failed");
         return eb;
     }
     ggml_build_forward_expand(eb.graph, eb.out);
@@ -602,4 +582,4 @@ EncoderBuild build_encoder_graph(ggml_context *        ctx,
     return eb;
 }
 
-} // namespace transcribe::medasr
+}  // namespace transcribe::medasr
diff --git a/src/arch/medasr/encoder.h b/src/arch/medasr/encoder.h
index 7b0e0ad8..71c3193a 100644
--- a/src/arch/medasr/encoder.h
+++ b/src/arch/medasr/encoder.h
@@ -2,9 +2,8 @@
 
 #pragma once
 
-#include "weights.h"
-
 #include "ggml.h"
+#include "weights.h"
 
 #include <vector>
 
@@ -48,22 +47,22 @@ struct EncoderDumps {
 
 struct EncoderBuild {
     // Inputs.
-    ggml_tensor * mel_in    = nullptr; // [T_mel, n_mels, 1, B]
-    ggml_tensor * positions = nullptr; // [T_enc] i32
+    ggml_tensor * mel_in    = nullptr;  // [T_mel, n_mels, 1, B]
+    ggml_tensor * positions = nullptr;  // [T_enc] i32
 
     // Per-layer fused-BN scale/bias inputs (allocated in the same ctx as
     // the graph; the driver uploads from MedAsrWeights::fused_bn_*_storage
     // after sched_alloc_graph). One pair per encoder layer.
-    std::vector<ggml_tensor *> bn_scale_inputs; // each [d_model]
-    std::vector<ggml_tensor *> bn_bias_inputs;  // each [d_model]
+    std::vector<ggml_tensor *> bn_scale_inputs;  // each [d_model]
+    std::vector<ggml_tensor *> bn_bias_inputs;   // each [d_model]
 
     // Optional variable-length batch masks (one or both null in single-shot
     // or same-length batch mode). Sized to per-encoder-frame T_enc.
-    ggml_tensor * attn_pad_mask_in = nullptr; // [T_enc, 1, 1, B] f32 add (-INF/0)
-    ggml_tensor * conv_pad_mask_in = nullptr; // [T_enc, 1, B, 1] f32 (0/1)
+    ggml_tensor * attn_pad_mask_in = nullptr;  // [T_enc, 1, 1, B] f32 add (-INF/0)
+    ggml_tensor * conv_pad_mask_in = nullptr;  // [T_enc, 1, B, 1] f32 (0/1)
 
     // Output.
-    ggml_tensor * out = nullptr; // == ctc_logits
+    ggml_tensor * out = nullptr;  // == ctc_logits
 
     ggml_cgraph * graph = nullptr;
 
@@ -78,4 +77,4 @@ EncoderBuild build_encoder_graph(ggml_context *        ctx,
                                  int                   n_batch       = 1,
                                  bool                  batch_var_len = false);
 
-} // namespace transcribe::medasr
+}  // namespace transcribe::medasr
diff --git a/src/arch/medasr/medasr.h b/src/arch/medasr/medasr.h
index 25dcebfd..3a822284 100644
--- a/src/arch/medasr/medasr.h
+++ b/src/arch/medasr/medasr.h
@@ -5,13 +5,12 @@
 
 #pragma once
 
-#include "weights.h"
-
 #include "transcribe-backend.h"
 #include "transcribe-mel.h"
 #include "transcribe-model.h"
 #include "transcribe-session.h"
 #include "transcribe-tokenizer.h"
+#include "weights.h"
 
 #include <cstdint>
 #include <optional>
@@ -31,10 +30,10 @@ namespace transcribe::medasr {
 void apply_family_invariants(transcribe_model & model);
 
 struct MedAsrModel final : public transcribe_model {
-    Tokenizer        tok;
-    MedAsrHParams    hparams;
-    MedAsrWeights    weights;
-    ggml_context *   ctx_meta = nullptr;
+    Tokenizer      tok;
+    MedAsrHParams  hparams;
+    MedAsrWeights  weights;
+    ggml_context * ctx_meta = nullptr;
 
     transcribe::BackendPlan plan;
     ggml_backend_buffer_t   backend_buffer = nullptr;
@@ -53,13 +52,12 @@ struct MedAsrSession final : public transcribe_session {
 
     ggml_tensor * encoder_out = nullptr;
 
-    std::vector<float>   mel_buf;
-    std::vector<float>   enc_host;   // [d_enc * T_enc] f32 readback
-    std::vector<float>   logits_buf; // [vocab * T_enc] f32 readback
-
+    std::vector<float> mel_buf;
+    std::vector<float> enc_host;    // [d_enc * T_enc] f32 readback
+    std::vector<float> logits_buf;  // [vocab * T_enc] f32 readback
 
     MedAsrSession() = default;
     ~MedAsrSession() override;
 };
 
-} // namespace transcribe::medasr
+}  // namespace transcribe::medasr
diff --git a/src/arch/medasr/model.cpp b/src/arch/medasr/model.cpp
index cb48be61..a97b0f8d 100644
--- a/src/arch/medasr/model.cpp
+++ b/src/arch/medasr/model.cpp
@@ -12,11 +12,12 @@
 // back the CTC logits, performs greedy collapse (drop blanks, collapse
 // repeats), and populates the result snapshot.
 
-#include "medasr.h"
-
 #include "encoder.h"
-#include "weights.h"
-
+#include "ggml-alloc.h"
+#include "ggml-backend.h"
+#include "ggml.h"
+#include "gguf.h"
+#include "medasr.h"
 #include "transcribe-arch.h"
 #include "transcribe-batch-util.h"
 #include "transcribe-debug.h"
@@ -25,11 +26,7 @@
 #include "transcribe-loader.h"
 #include "transcribe-log.h"
 #include "transcribe-meta.h"
-
-#include "ggml.h"
-#include "ggml-alloc.h"
-#include "ggml-backend.h"
-#include "gguf.h"
+#include "weights.h"
 
 #include <algorithm>
 #include <cmath>
@@ -48,7 +45,7 @@ namespace transcribe::medasr {
 
 extern const Arch arch;
 
-static_assert(std::is_base_of_v<transcribe_model,   MedAsrModel>);
+static_assert(std::is_base_of_v<transcribe_model, MedAsrModel>);
 static_assert(std::is_base_of_v<transcribe_session, MedAsrSession>);
 
 MedAsrSession::~MedAsrSession() {
@@ -72,9 +69,7 @@ MedAsrModel::~MedAsrModel() {
         ggml_backend_buffer_free(backend_buffer);
         backend_buffer = nullptr;
     }
-    for (auto it = plan.scheduler_list.rbegin();
-         it != plan.scheduler_list.rend(); ++it)
-    {
+    for (auto it = plan.scheduler_list.rbegin(); it != plan.scheduler_list.rend(); ++it) {
         ggml_backend_free(*it);
     }
     plan.scheduler_list.clear();
@@ -105,7 +100,9 @@ int medasr_subsample_factor(const MedAsrHParams & hp) {
         return 4;
     }
     int factor = 1;
-    for (int i = 0; i < hp.enc_sub_n_layers; ++i) factor *= hp.enc_sub_stride;
+    for (int i = 0; i < hp.enc_sub_n_layers; ++i) {
+        factor *= hp.enc_sub_stride;
+    }
     return factor;
 }
 
@@ -119,8 +116,7 @@ int64_t medasr_ms_per_encoder_frame(const MedAsrHParams & hp) {
     if (hp.fe_hop_length <= 0 || hp.fe_sample_rate <= 0) {
         return 0;
     }
-    return static_cast<int64_t>(hp.fe_hop_length) *
-           medasr_subsample_factor(hp) * 1000 / hp.fe_sample_rate;
+    return static_cast<int64_t>(hp.fe_hop_length) * medasr_subsample_factor(hp) * 1000 / hp.fe_sample_rate;
 }
 
 // Advisory transcribe_capabilities::max_audio_ms: the RoPE-trained window,
@@ -138,13 +134,10 @@ int64_t medasr_max_audio_ms(const MedAsrHParams & hp) {
     return static_cast<int64_t>(hp.enc_max_pos_emb) * ms_per_frame;
 }
 
-transcribe_status load(Loader &                              loader,
-                       const transcribe_model_load_params *  params,
-                       transcribe_model **                   out_model)
-{
+transcribe_status load(Loader & loader, const transcribe_model_load_params * params, transcribe_model ** out_model) {
     const int64_t t_load_start = ggml_time_us();
 
-    auto m = std::make_unique<MedAsrModel>();
+    auto m       = std::make_unique<MedAsrModel>();
     m->arch      = &arch;
     m->t_load_us = 0;
 
@@ -155,14 +148,18 @@ transcribe_status load(Loader &                              loader,
     m->caps.n_languages = 0;
     m->caps.languages   = nullptr;
 
-    if (auto st = read_capability_kv(loader.gguf(), m->caps); st != TRANSCRIBE_OK)
+    if (auto st = read_capability_kv(loader.gguf(), m->caps); st != TRANSCRIBE_OK) {
         return st;
-    if (auto st = read_languages_kv(loader.gguf(), *m); st != TRANSCRIBE_OK)
+    }
+    if (auto st = read_languages_kv(loader.gguf(), *m); st != TRANSCRIBE_OK) {
         return st;
-    if (auto st = m->tok.load(loader.gguf()); st != TRANSCRIBE_OK)
+    }
+    if (auto st = m->tok.load(loader.gguf()); st != TRANSCRIBE_OK) {
         return st;
-    if (auto st = read_medasr_hparams(loader.gguf(), m->hparams); st != TRANSCRIBE_OK)
+    }
+    if (auto st = read_medasr_hparams(loader.gguf(), m->hparams); st != TRANSCRIBE_OK) {
         return st;
+    }
 
     // Publish the soft-window input-length advisory now that the RoPE range
     // and frontend rate are known (apply_family_invariants ran before the
@@ -172,48 +169,40 @@ transcribe_status load(Loader &                              loader,
     m->caps.max_audio_ms = medasr_max_audio_ms(m->hparams);
 
     // Reopen for tensor metadata.
-    gguf_init_params init_params {};
-    init_params.no_alloc = true;
-    init_params.ctx      = &m->ctx_meta;
-    gguf_context * gguf_data = gguf_init_from_file(loader.path().c_str(),
-                                                   init_params);
-    if (gguf_data == nullptr) return TRANSCRIBE_ERR_GGUF;
-
-    if (auto st = build_medasr_weights(m->ctx_meta, m->hparams, m->weights);
-        st != TRANSCRIBE_OK)
-    {
+    gguf_init_params init_params{};
+    init_params.no_alloc     = true;
+    init_params.ctx          = &m->ctx_meta;
+    gguf_context * gguf_data = gguf_init_from_file(loader.path().c_str(), init_params);
+    if (gguf_data == nullptr) {
+        return TRANSCRIBE_ERR_GGUF;
+    }
+
+    if (auto st = build_medasr_weights(m->ctx_meta, m->hparams, m->weights); st != TRANSCRIBE_OK) {
         gguf_free(gguf_data);
         return st;
     }
 
-    const transcribe_backend_request backend_req =
-        (params != nullptr) ? params->backend : TRANSCRIBE_BACKEND_AUTO;
-    if (auto st = transcribe::load_common::init_backends(
-            backend_req, (params != nullptr) ? params->gpu_device : 0, "medasr", m->plan);
-        st != TRANSCRIBE_OK)
-    {
+    const transcribe_backend_request backend_req = (params != nullptr) ? params->backend : TRANSCRIBE_BACKEND_AUTO;
+    if (auto st = transcribe::load_common::init_backends(backend_req, (params != nullptr) ? params->gpu_device : 0,
+                                                         "medasr", m->plan);
+        st != TRANSCRIBE_OK) {
         gguf_free(gguf_data);
         return st;
     }
-    m->backend = ggml_backend_name(m->plan.primary);
+    m->backend         = ggml_backend_name(m->plan.primary);
     m->primary_backend = m->plan.primary;
 
-    ggml_backend_buffer_t weights_buffer =
-        ggml_backend_alloc_ctx_tensors(m->ctx_meta, m->plan.primary);
+    ggml_backend_buffer_t weights_buffer = ggml_backend_alloc_ctx_tensors(m->ctx_meta, m->plan.primary);
     if (weights_buffer == nullptr) {
         gguf_free(gguf_data);
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "medasr: ggml_backend_alloc_ctx_tensors failed");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "medasr: ggml_backend_alloc_ctx_tensors failed");
         return TRANSCRIBE_ERR_GGUF;
     }
     m->backend_buffer = weights_buffer;
-    ggml_backend_buffer_set_usage(weights_buffer,
-                                  GGML_BACKEND_BUFFER_USAGE_WEIGHTS);
+    ggml_backend_buffer_set_usage(weights_buffer, GGML_BACKEND_BUFFER_USAGE_WEIGHTS);
 
-    if (auto st = transcribe::load_common::stream_tensor_data(
-            loader.path(), gguf_data, m->ctx_meta, "medasr");
-        st != TRANSCRIBE_OK)
-    {
+    if (auto st = transcribe::load_common::stream_tensor_data(loader.path(), gguf_data, m->ctx_meta, "medasr");
+        st != TRANSCRIBE_OK) {
         gguf_free(gguf_data);
         return st;
     }
@@ -221,9 +210,7 @@ transcribe_status load(Loader &                              loader,
     // Fuse BatchNorm into host-resident scale/bias vectors. After this
     // point the raw bn.{weight,bias,running_mean,running_var} tensors
     // are no longer consulted.
-    if (auto st = fuse_batch_norm(gguf_data, m->ctx_meta, m->hparams, m->weights);
-        st != TRANSCRIBE_OK)
-    {
+    if (auto st = fuse_batch_norm(gguf_data, m->ctx_meta, m->hparams, m->weights); st != TRANSCRIBE_OK) {
         gguf_free(gguf_data);
         return st;
     }
@@ -238,9 +225,9 @@ transcribe_status load(Loader &                              loader,
     // row-major (ggml ne=[n_mels, n_freq]); MelConfig wants [n_mels,
     // n_freq] row-major, so we transpose once at load.
     {
-        const MedAsrHParams & hp = m->hparams;
-        const int n_freq = hp.fe_n_fft / 2 + 1;
-        transcribe::MelConfig cfg {};
+        const MedAsrHParams & hp     = m->hparams;
+        const int             n_freq = hp.fe_n_fft / 2 + 1;
+        transcribe::MelConfig cfg{};
         cfg.sample_rate   = hp.fe_sample_rate;
         cfg.num_mels      = hp.fe_num_mels;
         cfg.n_fft         = hp.fe_n_fft;
@@ -256,20 +243,15 @@ transcribe_status load(Loader &                              loader,
 
         if (m->weights.frontend_window != nullptr) {
             cfg.window.assign(hp.fe_win_length, 0.0f);
-            ggml_backend_tensor_get(m->weights.frontend_window,
-                                    cfg.window.data(), 0,
+            ggml_backend_tensor_get(m->weights.frontend_window, cfg.window.data(), 0,
                                     cfg.window.size() * sizeof(float));
         }
         if (m->weights.frontend_mel_filterbank != nullptr) {
-            std::vector<float> raw(
-                static_cast<size_t>(hp.fe_num_mels) * n_freq);
-            ggml_backend_tensor_get(m->weights.frontend_mel_filterbank,
-                                    raw.data(), 0,
-                                    raw.size() * sizeof(float));
+            std::vector<float> raw(static_cast<size_t>(hp.fe_num_mels) * n_freq);
+            ggml_backend_tensor_get(m->weights.frontend_mel_filterbank, raw.data(), 0, raw.size() * sizeof(float));
             // raw is [n_freq, n_mels] row-major (mel fast). Transpose
             // into [n_mels, n_freq] row-major (freq fast) for MelConfig.
-            cfg.filterbank.assign(
-                static_cast<size_t>(hp.fe_num_mels) * n_freq, 0.0f);
+            cfg.filterbank.assign(static_cast<size_t>(hp.fe_num_mels) * n_freq, 0.0f);
             for (int k = 0; k < n_freq; ++k) {
                 for (int mi = 0; mi < hp.fe_num_mels; ++mi) {
                     cfg.filterbank[static_cast<size_t>(mi) * n_freq + k] =
@@ -281,17 +263,18 @@ transcribe_status load(Loader &                              loader,
     }
 
     m->t_load_us = ggml_time_us() - t_load_start;
-    *out_model = m.release();
+    *out_model   = m.release();
     return TRANSCRIBE_OK;
 }
 
 transcribe_status init_context(transcribe_model *                model,
                                const transcribe_session_params * params,
-                               transcribe_session **             out_ctx)
-{
-    if (model->arch != &arch) return TRANSCRIBE_ERR_INVALID_ARG;
+                               transcribe_session **             out_ctx) {
+    if (model->arch != &arch) {
+        return TRANSCRIBE_ERR_INVALID_ARG;
+    }
 
-    auto gc = std::make_unique<MedAsrSession>();
+    auto gc       = std::make_unique<MedAsrSession>();
     gc->model     = model;
     gc->n_threads = params->n_threads;
     gc->kv_type   = params->kv_type;
@@ -303,55 +286,49 @@ transcribe_status init_context(transcribe_model *                model,
 #ifdef TRANSCRIBE_ENABLE_VALIDATION_HOOKS
 // Load reference mel sidecar from <dir>/mel.in.f32 (or
 // frontend.mel.out.f32).
-transcribe_status load_ref_mel(const std::string & dir,
-                               int                 n_mels,
-                               int &               n_mel_frames,
-                               std::vector<float> & out)
-{
+transcribe_status load_ref_mel(const std::string & dir, int n_mels, int & n_mel_frames, std::vector<float> & out) {
     auto try_open = [&](const std::string & path) -> std::ifstream {
         return std::ifstream(path, std::ios::binary | std::ios::ate);
     };
     std::string base = dir;
-    if (!base.empty() && base.back() != '/') base += '/';
+    if (!base.empty() && base.back() != '/') {
+        base += '/';
+    }
 
-    std::ifstream f = try_open(base + "mel.in.f32");
-    std::string used = base + "mel.in.f32";
+    std::ifstream f    = try_open(base + "mel.in.f32");
+    std::string   used = base + "mel.in.f32";
     if (!f) {
-        f = try_open(base + "frontend.mel.out.f32");
+        f    = try_open(base + "frontend.mel.out.f32");
         used = base + "frontend.mel.out.f32";
     }
     if (!f) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "medasr: cannot open mel ref under '%s' "
-                     "(expected mel.in.f32 or frontend.mel.out.f32)",
-                     dir.c_str());
+                "medasr: cannot open mel ref under '%s' "
+                "(expected mel.in.f32 or frontend.mel.out.f32)",
+                dir.c_str());
         return TRANSCRIBE_ERR_FILE_NOT_FOUND;
     }
 
     const std::streamsize total_bytes = f.tellg();
     f.seekg(0, std::ios::beg);
-    if (total_bytes <= 0 ||
-        (static_cast<size_t>(total_bytes) % (sizeof(float) * n_mels)) != 0)
-    {
+    if (total_bytes <= 0 || (static_cast<size_t>(total_bytes) % (sizeof(float) * n_mels)) != 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "medasr: mel ref '%s' size %lld not divisible by "
-                     "n_mels=%d * 4",
-                     used.c_str(), static_cast<long long>(total_bytes),
-                     n_mels);
+                "medasr: mel ref '%s' size %lld not divisible by "
+                "n_mels=%d * 4",
+                used.c_str(), static_cast<long long>(total_bytes), n_mels);
         return TRANSCRIBE_ERR_GGUF;
     }
     const size_t n_elems = static_cast<size_t>(total_bytes) / sizeof(float);
-    n_mel_frames = static_cast<int>(n_elems / n_mels);
+    n_mel_frames         = static_cast<int>(n_elems / n_mels);
     out.assign(n_elems, 0.0f);
-    f.read(reinterpret_cast<char *>(out.data()),
-           static_cast<std::streamsize>(total_bytes));
+    f.read(reinterpret_cast<char *>(out.data()), static_cast<std::streamsize>(total_bytes));
     if (static_cast<std::streamsize>(f.gcount()) != total_bytes) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "medasr: short read on mel ref");
         return TRANSCRIBE_ERR_GGUF;
     }
     return TRANSCRIBE_OK;
 }
-#endif // TRANSCRIBE_ENABLE_VALIDATION_HOOKS
+#endif  // TRANSCRIBE_ENABLE_VALIDATION_HOOKS
 
 // Greedy CTC decode: argmax per frame, collapse repeats, drop blanks
 // AND skip the LASR special tokens (<s>=1, </s>=2, <unk>=3) — matching
@@ -359,38 +336,43 @@ transcribe_status load_ref_mel(const std::string & dir,
 // Without this, a final frame that argmaxes to id 2 (`</s>`) leaks the
 // literal `</s>` into the transcript, scoring as a +1 insertion (~0.2pp
 // WER on test-clean). `<epsilon>` (id 0) is the standard blank-skip.
-void decode_ctc_greedy(const float * logits,
-                       int           vocab,
-                       int           T_enc,
-                       int           blank_id,
+void decode_ctc_greedy(const float *      logits,
+                       int                vocab,
+                       int                T_enc,
+                       int                blank_id,
                        std::vector<int> & tokens,
-                       std::vector<int> & frames)
-{
+                       std::vector<int> & frames) {
     tokens.clear();
     frames.clear();
     int prev = -1;
     for (int t = 0; t < T_enc; ++t) {
-        const float * row = logits + static_cast<size_t>(t) * vocab;
-        int best = 0;
-        float best_v = row[0];
+        const float * row    = logits + static_cast<size_t>(t) * vocab;
+        int           best   = 0;
+        float         best_v = row[0];
         for (int v = 1; v < vocab; ++v) {
-            if (row[v] > best_v) { best_v = row[v]; best = v; }
+            if (row[v] > best_v) {
+                best_v = row[v];
+                best   = v;
+            }
+        }
+        if (best == blank_id) {
+            prev = -1;
+            continue;
+        }
+        if (best == prev) {
+            continue;
         }
-        if (best == blank_id) { prev = -1; continue; }
-        if (best == prev) continue;
         prev = best;
         // skip_special_tokens=True: drop ids 1 (<s>), 2 (</s>), 3 (<unk>).
-        if (best == 1 || best == 2 || best == 3) continue;
+        if (best == 1 || best == 2 || best == 3) {
+            continue;
+        }
         tokens.push_back(best);
         frames.push_back(t);
     }
 }
 
-transcribe_status run(transcribe_session *      session,
-                      const float *             pcm,
-                      int                       n_samples,
-                      const transcribe_run_params *)
-{
+transcribe_status run(transcribe_session * session, const float * pcm, int n_samples, const transcribe_run_params *) {
     if (session == nullptr || pcm == nullptr || n_samples <= 0) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
@@ -399,45 +381,48 @@ transcribe_status run(transcribe_session *      session,
     if (gm == nullptr || gm->plan.scheduler_list.empty()) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
-    if (gc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
+    if (gc->poll_abort()) {
+        return TRANSCRIBE_ERR_ABORTED;
+    }
 
     transcribe::debug::init();
 
     // ----- Mel acquisition -----------------------------------------------
-    int mel_n_frames = 0;
-    bool mel_from_ref = false;
-    const int64_t t_mel_start = ggml_time_us();
+    int           mel_n_frames = 0;
+    bool          mel_from_ref = false;
+    const int64_t t_mel_start  = ggml_time_us();
 #ifdef TRANSCRIBE_ENABLE_VALIDATION_HOOKS
     if (const char * ref_dir = transcribe::env::str("TRANSCRIBE_MEL_FROM_REF")) {
-        if (auto st = load_ref_mel(ref_dir, gm->hparams.fe_num_mels,
-                                   mel_n_frames, gc->mel_buf);
-            st != TRANSCRIBE_OK) return st;
+        if (auto st = load_ref_mel(ref_dir, gm->hparams.fe_num_mels, mel_n_frames, gc->mel_buf); st != TRANSCRIBE_OK) {
+            return st;
+        }
         mel_from_ref = true;
     }
 #endif
     if (!mel_from_ref) {
-        int out_n_mels = 0;
+        int                out_n_mels = 0;
         std::vector<float> m_major;
-        if (auto st = gm->mel->compute(pcm, static_cast<size_t>(n_samples),
-                                       m_major, out_n_mels, mel_n_frames,
-                                       gc->n_threads);
-            st != TRANSCRIBE_OK) return st;
+        if (auto st =
+                gm->mel->compute(pcm, static_cast<size_t>(n_samples), m_major, out_n_mels, mel_n_frames, gc->n_threads);
+            st != TRANSCRIBE_OK) {
+            return st;
+        }
         // Shared MelFrontend writes [n_mels, T_mel] row-major (m * T + t);
         // medasr's encoder mel_in tensor (ne=[n_mels, T_mel, 1, B]) expects
         // T-major bytes (each frame is n_mels contiguous floats). One-shot
         // transpose into mel_buf.
-        gc->mel_buf.assign(
-            static_cast<size_t>(out_n_mels) * mel_n_frames, 0.0f);
+        gc->mel_buf.assign(static_cast<size_t>(out_n_mels) * mel_n_frames, 0.0f);
         for (int mi = 0; mi < out_n_mels; ++mi) {
-            const float * src = m_major.data() +
-                                static_cast<size_t>(mi) * mel_n_frames;
+            const float * src = m_major.data() + static_cast<size_t>(mi) * mel_n_frames;
             for (int t = 0; t < mel_n_frames; ++t) {
                 gc->mel_buf[static_cast<size_t>(t) * out_n_mels + mi] = src[t];
             }
         }
     }
     gc->t_mel_us = ggml_time_us() - t_mel_start;
-    if (mel_n_frames <= 0) return TRANSCRIBE_ERR_GGUF;
+    if (mel_n_frames <= 0) {
+        return TRANSCRIBE_ERR_GGUF;
+    }
 
     // ----- Soft-window input-length advisory (see docs/input-limits.md) -----
     // MedASR has no hard context cap, but its RoPE was trained to
@@ -449,23 +434,19 @@ transcribe_status run(transcribe_session *      session,
     {
         const int sub_k = gm->hparams.enc_sub_kernel;
         const int sub_s = gm->hparams.enc_sub_stride;
-        auto sub_t = [&](int t_in) {
+        auto      sub_t = [&](int t_in) {
             return (t_in < sub_k) ? 0 : (t_in - sub_k) / sub_s + 1;
         };
         const int enc_frames = sub_t(sub_t(mel_n_frames));
         if (enc_frames > gm->hparams.enc_max_pos_emb) {
-            const int64_t ms_per_frame =
-                medasr_ms_per_encoder_frame(gm->hparams);
-            const double audio_s =
-                static_cast<double>(enc_frames) *
-                static_cast<double>(ms_per_frame) / 1000.0;
-            transcribe::log_msg(
-                TRANSCRIBE_LOG_LEVEL_WARN,
-                "medasr run: audio is %.1f s (%d encoder frames), beyond the "
-                "%d-frame RoPE range this model was trained on; transcription "
-                "may be degraded past this point. See "
-                "transcribe_capabilities.max_audio_ms.",
-                audio_s, enc_frames, gm->hparams.enc_max_pos_emb);
+            const int64_t ms_per_frame = medasr_ms_per_encoder_frame(gm->hparams);
+            const double  audio_s      = static_cast<double>(enc_frames) * static_cast<double>(ms_per_frame) / 1000.0;
+            transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_WARN,
+                                "medasr run: audio is %.1f s (%d encoder frames), beyond the "
+                                "%d-frame RoPE range this model was trained on; transcription "
+                                "may be degraded past this point. See "
+                                "transcribe_capabilities.max_audio_ms.",
+                                audio_s, enc_frames, gm->hparams.enc_max_pos_emb);
         }
     }
 
@@ -476,156 +457,144 @@ transcribe_status run(transcribe_session *      session,
     }
     gc->encoder_out = nullptr;
     {
-        ggml_init_params ip {};
-        ip.mem_size   = 4 * 1024 * 1024;
-        ip.mem_buffer = nullptr;
-        ip.no_alloc   = true;
+        ggml_init_params ip{};
+        ip.mem_size     = 4 * 1024 * 1024;
+        ip.mem_buffer   = nullptr;
+        ip.no_alloc     = true;
         gc->compute_ctx = ggml_init(ip);
         if (gc->compute_ctx == nullptr) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "medasr run: compute context allocation failed — out of memory. "
-                "Split long audio into shorter segments (see "
-                "transcribe_capabilities.max_audio_ms).");
+                                "medasr run: compute context allocation failed — out of memory. "
+                                "Split long audio into shorter segments (see "
+                                "transcribe_capabilities.max_audio_ms).");
             return TRANSCRIBE_ERR_OOM;
         }
     }
 
     // ----- Build encoder graph ------------------------------------------
-    EncoderBuild eb = build_encoder_graph(
-        gc->compute_ctx, gm->weights, gm->hparams,
-        mel_n_frames, gm->backend.c_str(),
-        /*n_batch=*/1, /*batch_var_len=*/false);
+    EncoderBuild eb = build_encoder_graph(gc->compute_ctx, gm->weights, gm->hparams, mel_n_frames, gm->backend.c_str(),
+                                          /*n_batch=*/1, /*batch_var_len=*/false);
     if (eb.mel_in == nullptr || eb.out == nullptr || eb.graph == nullptr) {
         return TRANSCRIBE_ERR_GGUF;
     }
 
     // ----- Scheduler ----------------------------------------------------
     if (gc->sched == nullptr) {
-        gc->sched = ggml_backend_sched_new(
-            gm->plan.scheduler_list.data(), nullptr,
-            static_cast<int>(gm->plan.scheduler_list.size()),
-            /*graph_size=*/8192, /*parallel=*/false, /*op_offload=*/true);
+        gc->sched = ggml_backend_sched_new(gm->plan.scheduler_list.data(), nullptr,
+                                           static_cast<int>(gm->plan.scheduler_list.size()),
+                                           /*graph_size=*/8192, /*parallel=*/false, /*op_offload=*/true);
         if (gc->sched == nullptr) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "medasr run: scheduler allocation failed — out of memory. "
-                "Split long audio into shorter segments (see "
-                "transcribe_capabilities.max_audio_ms).");
+                                "medasr run: scheduler allocation failed — out of memory. "
+                                "Split long audio into shorter segments (see "
+                                "transcribe_capabilities.max_audio_ms).");
             return TRANSCRIBE_ERR_OOM;
         }
     }
     ggml_backend_sched_reset(gc->sched);
     if (!ggml_backend_sched_alloc_graph(gc->sched, eb.graph)) {
         transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "medasr run: encoder graph allocation failed — out of memory. "
-            "Split long audio into shorter segments (see "
-            "transcribe_capabilities.max_audio_ms).");
+                            "medasr run: encoder graph allocation failed — out of memory. "
+                            "Split long audio into shorter segments (see "
+                            "transcribe_capabilities.max_audio_ms).");
         return TRANSCRIBE_ERR_OOM;
     }
 
     // ----- Upload inputs ------------------------------------------------
-    ggml_backend_tensor_set(eb.mel_in, gc->mel_buf.data(), 0,
-                            gc->mel_buf.size() * sizeof(float));
+    ggml_backend_tensor_set(eb.mel_in, gc->mel_buf.data(), 0, gc->mel_buf.size() * sizeof(float));
     transcribe::debug::dump_tensor("mel.in", eb.mel_in, "encoder.mel");
 
     if (eb.positions != nullptr) {
-        const int64_t T_enc = eb.positions->ne[0];
+        const int64_t        T_enc = eb.positions->ne[0];
         std::vector<int32_t> pos(T_enc);
-        for (int64_t i = 0; i < T_enc; ++i) pos[i] = static_cast<int32_t>(i);
-        ggml_backend_tensor_set(eb.positions, pos.data(), 0,
-                                pos.size() * sizeof(int32_t));
+        for (int64_t i = 0; i < T_enc; ++i) {
+            pos[i] = static_cast<int32_t>(i);
+        }
+        ggml_backend_tensor_set(eb.positions, pos.data(), 0, pos.size() * sizeof(int32_t));
     }
 
     // Per-block fused-BN scale + bias.
-    const int n_layers = gm->hparams.enc_n_layers;
-    const int d_model  = gm->hparams.enc_hidden;
+    const int    n_layers        = gm->hparams.enc_n_layers;
+    const int    d_model         = gm->hparams.enc_hidden;
     const size_t bytes_per_layer = d_model * sizeof(float);
     for (int i = 0; i < n_layers; ++i) {
-        if (i < static_cast<int>(eb.bn_scale_inputs.size()) &&
-            eb.bn_scale_inputs[i] != nullptr) {
-            ggml_backend_tensor_set(
-                eb.bn_scale_inputs[i],
-                gm->weights.fused_bn_scale_storage[i].data(),
-                0, bytes_per_layer);
+        if (i < static_cast<int>(eb.bn_scale_inputs.size()) && eb.bn_scale_inputs[i] != nullptr) {
+            ggml_backend_tensor_set(eb.bn_scale_inputs[i], gm->weights.fused_bn_scale_storage[i].data(), 0,
+                                    bytes_per_layer);
         }
-        if (i < static_cast<int>(eb.bn_bias_inputs.size()) &&
-            eb.bn_bias_inputs[i] != nullptr) {
-            ggml_backend_tensor_set(
-                eb.bn_bias_inputs[i],
-                gm->weights.fused_bn_bias_storage[i].data(),
-                0, bytes_per_layer);
+        if (i < static_cast<int>(eb.bn_bias_inputs.size()) && eb.bn_bias_inputs[i] != nullptr) {
+            ggml_backend_tensor_set(eb.bn_bias_inputs[i], gm->weights.fused_bn_bias_storage[i].data(), 0,
+                                    bytes_per_layer);
         }
     }
 
     // ----- Compute ------------------------------------------------------
     const int64_t t_enc_start = ggml_time_us();
-    if (ggml_backend_sched_graph_compute(gc->sched, eb.graph)
-            != GGML_STATUS_SUCCESS) {
+    if (ggml_backend_sched_graph_compute(gc->sched, eb.graph) != GGML_STATUS_SUCCESS) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "medasr: graph_compute failed");
         return TRANSCRIBE_ERR_GGUF;
     }
     gc->t_encode_us = ggml_time_us() - t_enc_start;
 
     // ----- Dump intermediates -------------------------------------------
-    auto try_dump = [&](const char * name, ggml_tensor * t,
-                        const char * stage) {
-        if (t != nullptr) transcribe::debug::dump_tensor(name, t, stage);
+    auto try_dump = [&](const char * name, ggml_tensor * t, const char * stage) {
+        if (t != nullptr) {
+            transcribe::debug::dump_tensor(name, t, stage);
+        }
     };
     try_dump("enc.subsampling.out", eb.dumps.subsampling_out, "encoder.subsampling");
-    try_dump("enc.block.0.post_ff1",  eb.dumps.block0_post_ff1,  "encoder.block.0");
+    try_dump("enc.block.0.post_ff1", eb.dumps.block0_post_ff1, "encoder.block.0");
     try_dump("enc.block.0.post_attn", eb.dumps.block0_post_attn, "encoder.block.0");
     try_dump("enc.block.0.post_conv", eb.dumps.block0_post_conv, "encoder.block.0");
-    try_dump("enc.block.0.post_ff2",  eb.dumps.block0_post_ff2,  "encoder.block.0");
+    try_dump("enc.block.0.post_ff2", eb.dumps.block0_post_ff2, "encoder.block.0");
     for (int i = 0; i < n_layers; ++i) {
-        if (eb.dumps.all_block_outs[i] == nullptr) continue;
+        if (eb.dumps.all_block_outs[i] == nullptr) {
+            continue;
+        }
         char nm[32];
         std::snprintf(nm, sizeof(nm), "enc.block.%d.out", i);
         try_dump(nm, eb.dumps.all_block_outs[i], "encoder.block");
     }
-    try_dump("enc.out_norm.out", eb.dumps.out_norm_out,        "encoder.out_norm");
-    try_dump("enc.ctc_logits",   eb.dumps.ctc_logits_for_dump, "encoder.ctc_logits");
+    try_dump("enc.out_norm.out", eb.dumps.out_norm_out, "encoder.out_norm");
+    try_dump("enc.ctc_logits", eb.dumps.ctc_logits_for_dump, "encoder.ctc_logits");
 
     // Per-utterance encoder-output dump (single-shot baseline for the
     // batched-equals-single-shot gate). Matches the parakeet / gigaam name.
     if (transcribe::debug::enabled() && eb.dumps.out_norm_out != nullptr) {
-        ggml_tensor * t = eb.dumps.out_norm_out;
-        const int d_enc = static_cast<int>(t->ne[0]);
-        const int T_enc_dump = static_cast<int>(t->ne[1]);
+        ggml_tensor * t          = eb.dumps.out_norm_out;
+        const int     d_enc      = static_cast<int>(t->ne[0]);
+        const int     T_enc_dump = static_cast<int>(t->ne[1]);
         gc->enc_host.assign(static_cast<size_t>(d_enc) * T_enc_dump, 0.0f);
-        ggml_backend_tensor_get(t, gc->enc_host.data(), 0,
-                                gc->enc_host.size() * sizeof(float));
-        const long long shape[2] = {T_enc_dump, d_enc};
+        ggml_backend_tensor_get(t, gc->enc_host.data(), 0, gc->enc_host.size() * sizeof(float));
+        const long long shape[2] = { T_enc_dump, d_enc };
         transcribe::debug::dump_host_f32("dec.enc_out", gc->enc_host.data(),
-                                         static_cast<long long>(gc->enc_host.size()),
-                                         shape, 2, "decoder.enc_out");
+                                         static_cast<long long>(gc->enc_host.size()), shape, 2, "decoder.enc_out");
     }
 
     gc->encoder_out = eb.out;
 
     // ----- Greedy CTC decode --------------------------------------------
     const int64_t t_dec_start = ggml_time_us();
-    ggml_tensor * logits_t = eb.dumps.ctc_logits;
-    if (logits_t == nullptr) return TRANSCRIBE_ERR_GGUF;
+    ggml_tensor * logits_t    = eb.dumps.ctc_logits;
+    if (logits_t == nullptr) {
+        return TRANSCRIBE_ERR_GGUF;
+    }
 
     const int vocab = static_cast<int>(logits_t->ne[0]);
     const int T_enc = static_cast<int>(logits_t->ne[1]);
     if (vocab != gm->hparams.ctc_vocab_size || T_enc <= 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "medasr: ctc_logits shape mismatch (vocab=%d T_enc=%d)",
-                     vocab, T_enc);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "medasr: ctc_logits shape mismatch (vocab=%d T_enc=%d)", vocab, T_enc);
         return TRANSCRIBE_ERR_GGUF;
     }
     gc->logits_buf.assign(static_cast<size_t>(vocab) * T_enc, 0.0f);
-    ggml_backend_tensor_get(logits_t, gc->logits_buf.data(), 0,
-                            gc->logits_buf.size() * sizeof(float));
+    ggml_backend_tensor_get(logits_t, gc->logits_buf.data(), 0, gc->logits_buf.size() * sizeof(float));
 
     std::vector<int> tokens;
     std::vector<int> frames;
-    decode_ctc_greedy(gc->logits_buf.data(), vocab, T_enc,
-                      gm->hparams.ctc_blank_id, tokens, frames);
+    decode_ctc_greedy(gc->logits_buf.data(), vocab, T_enc, gm->hparams.ctc_blank_id, tokens, frames);
     gc->t_decode_us = ggml_time_us() - t_dec_start;
 
-    std::string text = gm->tok.decode(tokens.data(),
-                                      static_cast<int>(tokens.size()));
+    std::string text = gm->tok.decode(tokens.data(), static_cast<int>(tokens.size()));
     if (!text.empty() && text.front() == ' ') {
         text.erase(text.begin());
     }
@@ -638,7 +607,7 @@ transcribe_status run(transcribe_session *      session,
     gc->tokens.clear();
     gc->tokens.reserve(tokens.size());
     for (size_t i = 0; i < tokens.size(); ++i) {
-        transcribe_session::TokenEntry te {};
+        transcribe_session::TokenEntry te{};
         te.id    = tokens[i];
         te.text  = gm->tok.token(tokens[i]);
         te.t0_ms = static_cast<int64_t>(frames[i]) * 40;
@@ -649,7 +618,7 @@ transcribe_status run(transcribe_session *      session,
     return TRANSCRIBE_OK;
 }
 
-} // namespace
+}  // namespace
 
 // ---------------------------------------------------------------------------
 // Offline batch (transcribe_run_batch)
@@ -672,7 +641,9 @@ namespace {
 //         -> floor((T1 - sub_kernel) / sub_stride) + 1        (conv_1)
 // With sub_kernel=5 and sub_stride=2, padding=0, two stride-2 convs.
 int subsampling_t_out(int T_in, int sub_kernel, int sub_stride) {
-    if (T_in < sub_kernel) return 0;
+    if (T_in < sub_kernel) {
+        return 0;
+    }
     return (T_in - sub_kernel) / sub_stride + 1;
 }
 
@@ -686,17 +657,15 @@ void pack_pad_time_major(std::vector<float> &                    dst,
                          const std::vector<std::vector<float>> & src,
                          const std::vector<int> &                lens,
                          int                                     n_mels,
-                         int                                     T_max)
-{
+                         int                                     T_max) {
     const size_t n = src.size();
     dst.assign(static_cast<size_t>(n_mels) * T_max * n, 0.0f);
     for (size_t b = 0; b < n; ++b) {
-        const size_t slab_off = b * n_mels * T_max;
-        const int T_b = lens[static_cast<size_t>(b)];
+        const size_t slab_off    = b * n_mels * T_max;
+        const int    T_b         = lens[static_cast<size_t>(b)];
         const size_t copy_floats = static_cast<size_t>(T_b) * n_mels;
         if (T_b > 0 && copy_floats <= src[b].size()) {
-            std::memcpy(dst.data() + slab_off, src[b].data(),
-                        copy_floats * sizeof(float));
+            std::memcpy(dst.data() + slab_off, src[b].data(), copy_floats * sizeof(float));
         }
         // Tail (t >= T_b) stays zero from the assign above.
     }
@@ -707,19 +676,16 @@ transcribe_status decode_one_utterance(MedAsrSession * gc,
                                        const float *   enc_logits,
                                        int             T_enc_valid,
                                        int             vocab,
-                                       int             /*utt_index*/)
-{
+                                       int /*utt_index*/) {
     const int64_t t_dec_start = ggml_time_us();
 
     std::vector<int> tokens;
     std::vector<int> frames;
-    decode_ctc_greedy(enc_logits, vocab, T_enc_valid,
-                      gm->hparams.ctc_blank_id, tokens, frames);
+    decode_ctc_greedy(enc_logits, vocab, T_enc_valid, gm->hparams.ctc_blank_id, tokens, frames);
 
     gc->t_decode_us = ggml_time_us() - t_dec_start;
 
-    std::string text = gm->tok.decode(tokens.data(),
-                                      static_cast<int>(tokens.size()));
+    std::string text = gm->tok.decode(tokens.data(), static_cast<int>(tokens.size()));
     if (!text.empty() && text.front() == ' ') {
         text.erase(text.begin());
     }
@@ -730,7 +696,7 @@ transcribe_status decode_one_utterance(MedAsrSession * gc,
     gc->tokens.clear();
     gc->tokens.reserve(tokens.size());
     for (size_t i = 0; i < tokens.size(); ++i) {
-        transcribe_session::TokenEntry te {};
+        transcribe_session::TokenEntry te{};
         te.id    = tokens[i];
         te.text  = gm->tok.token(tokens[i]);
         te.t0_ms = static_cast<int64_t>(frames[i]) * 40;
@@ -746,12 +712,14 @@ transcribe_status run_batch_encode(MedAsrSession *                         gc,
                                    const std::vector<int> &                nf,
                                    int                                     n_mels,
                                    int                                     T_max,
-                                   int64_t                                 total_mel_us)
-{
-    const int n = static_cast<int>(mels.size());
-    bool var_len = false;
+                                   int64_t                                 total_mel_us) {
+    const int n       = static_cast<int>(mels.size());
+    bool      var_len = false;
     for (int b = 0; b < n; ++b) {
-        if (nf[b] != T_max) { var_len = true; break; }
+        if (nf[b] != T_max) {
+            var_len = true;
+            break;
+        }
     }
 
     pack_pad_time_major(gc->mel_buf, mels, nf, n_mels, T_max);
@@ -762,89 +730,81 @@ transcribe_status run_batch_encode(MedAsrSession *                         gc,
     }
     gc->encoder_out = nullptr;
     {
-        ggml_init_params ip {};
-        ip.mem_size   = 4 * 1024 * 1024;
-        ip.mem_buffer = nullptr;
-        ip.no_alloc   = true;
+        ggml_init_params ip{};
+        ip.mem_size     = 4 * 1024 * 1024;
+        ip.mem_buffer   = nullptr;
+        ip.no_alloc     = true;
         gc->compute_ctx = ggml_init(ip);
         if (gc->compute_ctx == nullptr) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "medasr run: compute context allocation failed — out of memory. "
-                "Split long audio into shorter segments (see "
-                "transcribe_capabilities.max_audio_ms).");
+                                "medasr run: compute context allocation failed — out of memory. "
+                                "Split long audio into shorter segments (see "
+                                "transcribe_capabilities.max_audio_ms).");
             return TRANSCRIBE_ERR_OOM;
         }
     }
 
-    EncoderBuild eb = build_encoder_graph(
-        gc->compute_ctx, gm->weights, gm->hparams, T_max,
-        gm->backend.c_str(), /*n_batch=*/n, /*batch_var_len=*/var_len);
+    EncoderBuild eb = build_encoder_graph(gc->compute_ctx, gm->weights, gm->hparams, T_max, gm->backend.c_str(),
+                                          /*n_batch=*/n, /*batch_var_len=*/var_len);
     if (eb.mel_in == nullptr || eb.out == nullptr || eb.graph == nullptr) {
         return TRANSCRIBE_ERR_GGUF;
     }
 
     if (gc->sched == nullptr) {
-        gc->sched = ggml_backend_sched_new(
-            gm->plan.scheduler_list.data(), nullptr,
-            static_cast<int>(gm->plan.scheduler_list.size()),
-            /*graph_size=*/8192, /*parallel=*/false, /*op_offload=*/true);
+        gc->sched = ggml_backend_sched_new(gm->plan.scheduler_list.data(), nullptr,
+                                           static_cast<int>(gm->plan.scheduler_list.size()),
+                                           /*graph_size=*/8192, /*parallel=*/false, /*op_offload=*/true);
         if (gc->sched == nullptr) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "medasr run: scheduler allocation failed — out of memory. "
-                "Split long audio into shorter segments (see "
-                "transcribe_capabilities.max_audio_ms).");
+                                "medasr run: scheduler allocation failed — out of memory. "
+                                "Split long audio into shorter segments (see "
+                                "transcribe_capabilities.max_audio_ms).");
             return TRANSCRIBE_ERR_OOM;
         }
     }
     ggml_backend_sched_reset(gc->sched);
     if (!ggml_backend_sched_alloc_graph(gc->sched, eb.graph)) {
         transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "medasr run: encoder graph allocation failed — out of memory. "
-            "Split long audio into shorter segments (see "
-            "transcribe_capabilities.max_audio_ms).");
+                            "medasr run: encoder graph allocation failed — out of memory. "
+                            "Split long audio into shorter segments (see "
+                            "transcribe_capabilities.max_audio_ms).");
         return TRANSCRIBE_ERR_OOM;
     }
 
     // Upload mel + positions.
-    ggml_backend_tensor_set(eb.mel_in, gc->mel_buf.data(), 0,
-                            gc->mel_buf.size() * sizeof(float));
+    ggml_backend_tensor_set(eb.mel_in, gc->mel_buf.data(), 0, gc->mel_buf.size() * sizeof(float));
     if (eb.positions != nullptr) {
-        const int64_t T_enc = eb.positions->ne[0];
+        const int64_t        T_enc = eb.positions->ne[0];
         std::vector<int32_t> pos(T_enc);
-        for (int64_t i = 0; i < T_enc; ++i) pos[i] = static_cast<int32_t>(i);
-        ggml_backend_tensor_set(eb.positions, pos.data(), 0,
-                                pos.size() * sizeof(int32_t));
+        for (int64_t i = 0; i < T_enc; ++i) {
+            pos[i] = static_cast<int32_t>(i);
+        }
+        ggml_backend_tensor_set(eb.positions, pos.data(), 0, pos.size() * sizeof(int32_t));
     }
 
     // Per-layer fused-BN scale + bias (1-D, broadcast over the batch).
-    const int n_layers = gm->hparams.enc_n_layers;
-    const int d_model  = gm->hparams.enc_hidden;
+    const int    n_layers        = gm->hparams.enc_n_layers;
+    const int    d_model         = gm->hparams.enc_hidden;
     const size_t bytes_per_layer = d_model * sizeof(float);
     for (int i = 0; i < n_layers; ++i) {
-        if (i < static_cast<int>(eb.bn_scale_inputs.size()) &&
-            eb.bn_scale_inputs[i] != nullptr) {
-            ggml_backend_tensor_set(
-                eb.bn_scale_inputs[i],
-                gm->weights.fused_bn_scale_storage[i].data(),
-                0, bytes_per_layer);
+        if (i < static_cast<int>(eb.bn_scale_inputs.size()) && eb.bn_scale_inputs[i] != nullptr) {
+            ggml_backend_tensor_set(eb.bn_scale_inputs[i], gm->weights.fused_bn_scale_storage[i].data(), 0,
+                                    bytes_per_layer);
         }
-        if (i < static_cast<int>(eb.bn_bias_inputs.size()) &&
-            eb.bn_bias_inputs[i] != nullptr) {
-            ggml_backend_tensor_set(
-                eb.bn_bias_inputs[i],
-                gm->weights.fused_bn_bias_storage[i].data(),
-                0, bytes_per_layer);
+        if (i < static_cast<int>(eb.bn_bias_inputs.size()) && eb.bn_bias_inputs[i] != nullptr) {
+            ggml_backend_tensor_set(eb.bn_bias_inputs[i], gm->weights.fused_bn_bias_storage[i].data(), 0,
+                                    bytes_per_layer);
         }
     }
 
     // Per-utterance encoder-frame count after the two stride-2 subsampling
     // convs.
     std::vector<int> real_tenc(static_cast<size_t>(n), 0);
-    const int sub_k = gm->hparams.enc_sub_kernel;
-    const int sub_s = gm->hparams.enc_sub_stride;
+    const int        sub_k = gm->hparams.enc_sub_kernel;
+    const int        sub_s = gm->hparams.enc_sub_stride;
     for (int b = 0; b < n; ++b) {
-        int t = subsampling_t_out(nf[b], sub_k, sub_s);
-        t     = subsampling_t_out(t,     sub_k, sub_s);
+        int t        = subsampling_t_out(nf[b], sub_k, sub_s);
+        t            = subsampling_t_out(t, sub_k, sub_s);
         real_tenc[b] = t;
     }
 
@@ -860,25 +820,24 @@ transcribe_status run_batch_encode(MedAsrSession *                         gc,
         const int64_t ms_per_frame = medasr_ms_per_encoder_frame(gm->hparams);
         for (int b = 0; b < n; ++b) {
             if (real_tenc[b] > gm->hparams.enc_max_pos_emb) {
-                const double audio_s =
-                    static_cast<double>(real_tenc[b]) *
-                    static_cast<double>(ms_per_frame) / 1000.0;
-                transcribe::log_msg(
-                    TRANSCRIBE_LOG_LEVEL_WARN,
-                    "medasr run: utterance %d: audio is %.1f s (%d encoder "
-                    "frames), beyond the %d-frame RoPE range this model was "
-                    "trained on; transcription may be degraded past this point. "
-                    "See transcribe_capabilities.max_audio_ms.",
-                    b, audio_s, real_tenc[b], gm->hparams.enc_max_pos_emb);
+                const double audio_s = static_cast<double>(real_tenc[b]) * static_cast<double>(ms_per_frame) / 1000.0;
+                transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_WARN,
+                                    "medasr run: utterance %d: audio is %.1f s (%d encoder "
+                                    "frames), beyond the %d-frame RoPE range this model was "
+                                    "trained on; transcription may be degraded past this point. "
+                                    "See transcribe_capabilities.max_audio_ms.",
+                                    b, audio_s, real_tenc[b], gm->hparams.enc_max_pos_emb);
             }
         }
     }
 
     if (var_len) {
         const int T_enc_max = real_tenc[0];
-        int T_max_eff = T_enc_max;
+        int       T_max_eff = T_enc_max;
         for (int b = 1; b < n; ++b) {
-            if (real_tenc[b] > T_max_eff) T_max_eff = real_tenc[b];
+            if (real_tenc[b] > T_max_eff) {
+                T_max_eff = real_tenc[b];
+            }
         }
         transcribe::fill_keypad_mask(eb.attn_pad_mask_in, real_tenc, T_max_eff, n);
         transcribe::fill_valid_frame_mask(eb.conv_pad_mask_in, real_tenc, T_max_eff, n);
@@ -888,8 +847,7 @@ transcribe_status run_batch_encode(MedAsrSession *                         gc,
     transcribe::configure_sched_n_threads(gc->sched, gc->n_threads);
 
     const int64_t t_enc_start = ggml_time_us();
-    if (ggml_backend_sched_graph_compute(gc->sched, eb.graph)
-            != GGML_STATUS_SUCCESS) {
+    if (ggml_backend_sched_graph_compute(gc->sched, eb.graph) != GGML_STATUS_SUCCESS) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "medasr run_batch: graph_compute failed");
         return TRANSCRIBE_ERR_GGUF;
     }
@@ -899,19 +857,17 @@ transcribe_status run_batch_encode(MedAsrSession *                         gc,
     // gate. Read the whole [d_enc, T_enc, 1, n] tensor once, then host-slice
     // and dump each utterance under `dec.enc_out.b{i}`.
     if (transcribe::debug::enabled() && eb.dumps.out_norm_out != nullptr) {
-        ggml_tensor * t = eb.dumps.out_norm_out;
-        const int d_enc = static_cast<int>(t->ne[0]);
-        const int T_enc_dump = static_cast<int>(t->ne[1]);
-        const size_t utt_n = static_cast<size_t>(d_enc) * T_enc_dump;
+        ggml_tensor * t          = eb.dumps.out_norm_out;
+        const int     d_enc      = static_cast<int>(t->ne[0]);
+        const int     T_enc_dump = static_cast<int>(t->ne[1]);
+        const size_t  utt_n      = static_cast<size_t>(d_enc) * T_enc_dump;
         gc->enc_host.assign(utt_n * static_cast<size_t>(n), 0.0f);
-        ggml_backend_tensor_get(t, gc->enc_host.data(), 0,
-                                gc->enc_host.size() * sizeof(float));
-        const long long shape[2] = {T_enc_dump, d_enc};
+        ggml_backend_tensor_get(t, gc->enc_host.data(), 0, gc->enc_host.size() * sizeof(float));
+        const long long shape[2] = { T_enc_dump, d_enc };
         for (int b = 0; b < n; ++b) {
             const std::string nm = "dec.enc_out.b" + std::to_string(b);
-            transcribe::debug::dump_host_f32(
-                nm.c_str(), gc->enc_host.data() + b * utt_n,
-                static_cast<long long>(utt_n), shape, 2, "decoder.enc_out");
+            transcribe::debug::dump_host_f32(nm.c_str(), gc->enc_host.data() + b * utt_n, static_cast<long long>(utt_n),
+                                             shape, 2, "decoder.enc_out");
         }
     }
 
@@ -920,7 +876,9 @@ transcribe_status run_batch_encode(MedAsrSession *                         gc,
     // slab b at offset b * T_enc * vocab; within the slab, frame t at
     // offset t * vocab, then per-frame argmax over `vocab` floats.
     ggml_tensor * logits_t = eb.dumps.ctc_logits;
-    if (logits_t == nullptr) return TRANSCRIBE_ERR_GGUF;
+    if (logits_t == nullptr) {
+        return TRANSCRIBE_ERR_GGUF;
+    }
     const int vocab = static_cast<int>(logits_t->ne[0]);
     const int T_enc = static_cast<int>(logits_t->ne[1]);
     if (vocab != gm->hparams.ctc_vocab_size || T_enc <= 0) {
@@ -929,27 +887,24 @@ transcribe_status run_batch_encode(MedAsrSession *                         gc,
 
     const size_t utt_elems = static_cast<size_t>(vocab) * T_enc;
     gc->logits_buf.assign(utt_elems * static_cast<size_t>(n), 0.0f);
-    ggml_backend_tensor_get(logits_t, gc->logits_buf.data(), 0,
-                            gc->logits_buf.size() * sizeof(float));
+    ggml_backend_tensor_get(logits_t, gc->logits_buf.data(), 0, gc->logits_buf.size() * sizeof(float));
 
     // Host-decode each utterance with shared encode + total mel amortized.
-    return transcribe::decode_batch_slices(
-        gc, n, gc->logits_buf.data(), utt_elems, gc->t_encode_us, total_mel_us,
-        [&](int b, const float * enc_b) {
-            // enc_b points at utterance b's full T_enc slab; the decode
-            // loop reads `real_tenc[b]` valid frames and ignores the padded
-            // tail (per-utterance valid-frame count from the
-            // subsampling-output formula above).
-            return decode_one_utterance(gc, gm, enc_b, real_tenc[b], vocab, b);
-        });
+    return transcribe::decode_batch_slices(gc, n, gc->logits_buf.data(), utt_elems, gc->t_encode_us, total_mel_us,
+                                           [&](int b, const float * enc_b) {
+                                               // enc_b points at utterance b's full T_enc slab; the decode
+                                               // loop reads `real_tenc[b]` valid frames and ignores the padded
+                                               // tail (per-utterance valid-frame count from the
+                                               // subsampling-output formula above).
+                                               return decode_one_utterance(gc, gm, enc_b, real_tenc[b], vocab, b);
+                                           });
 }
 
 transcribe_status run_batch(transcribe_session *          session,
                             const float * const *         pcm,
                             const int *                   n_samples,
                             int                           n,
-                            const transcribe_run_params * params)
-{
+                            const transcribe_run_params * params) {
     if (session == nullptr || pcm == nullptr || n_samples == nullptr || n <= 0) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
@@ -961,46 +916,50 @@ transcribe_status run_batch(transcribe_session *          session,
     transcribe::debug::init();
 
     // Per-utterance mel in parallel.
-    const int n_mels = gm->hparams.fe_num_mels;
+    const int                       n_mels = gm->hparams.fe_num_mels;
     std::vector<std::vector<float>> mels(static_cast<size_t>(n));
     std::vector<int>                nf(static_cast<size_t>(n), 0);
-    const int64_t t_mel_start = ggml_time_us();
-    const bool all_ok = transcribe::parallel_for_all(
-        n, gc->n_threads, [&](int i) -> bool {
-            if (pcm[i] == nullptr || n_samples[i] <= 0) return false;
-            int this_frames = 0;
-            int out_n_mels = 0;
-            std::vector<float> m_major;
-            const transcribe_status st = gm->mel->compute(
-                pcm[i], static_cast<size_t>(n_samples[i]),
-                m_major, out_n_mels, this_frames, 1);
-            if (st != TRANSCRIBE_OK || this_frames <= 0) return false;
-            // Transpose [n_mels, T_mel] -> T-major to match the
-            // encoder's mel_in tensor layout. See run() for the
-            // detailed comment.
-            mels[i].assign(
-                static_cast<size_t>(out_n_mels) * this_frames, 0.0f);
-            for (int mi = 0; mi < out_n_mels; ++mi) {
-                const float * src = m_major.data() +
-                                    static_cast<size_t>(mi) * this_frames;
-                for (int t = 0; t < this_frames; ++t) {
-                    mels[i][static_cast<size_t>(t) * out_n_mels + mi] = src[t];
-                }
+    const int64_t                   t_mel_start  = ggml_time_us();
+    const bool                      all_ok       = transcribe::parallel_for_all(n, gc->n_threads, [&](int i) -> bool {
+        if (pcm[i] == nullptr || n_samples[i] <= 0) {
+            return false;
+        }
+        int                     this_frames = 0;
+        int                     out_n_mels  = 0;
+        std::vector<float>      m_major;
+        const transcribe_status st =
+            gm->mel->compute(pcm[i], static_cast<size_t>(n_samples[i]), m_major, out_n_mels, this_frames, 1);
+        if (st != TRANSCRIBE_OK || this_frames <= 0) {
+            return false;
+        }
+        // Transpose [n_mels, T_mel] -> T-major to match the
+        // encoder's mel_in tensor layout. See run() for the
+        // detailed comment.
+        mels[i].assign(static_cast<size_t>(out_n_mels) * this_frames, 0.0f);
+        for (int mi = 0; mi < out_n_mels; ++mi) {
+            const float * src = m_major.data() + static_cast<size_t>(mi) * this_frames;
+            for (int t = 0; t < this_frames; ++t) {
+                mels[i][static_cast<size_t>(t) * out_n_mels + mi] = src[t];
             }
-            nf[i] = this_frames;
-            return true;
-        });
-    const int64_t total_mel_us = ggml_time_us() - t_mel_start;
+        }
+        nf[i] = this_frames;
+        return true;
+    });
+    const int64_t                   total_mel_us = ggml_time_us() - t_mel_start;
 
     if (all_ok) {
         int T_max = 0;
-        for (int i = 0; i < n; ++i) T_max = std::max(T_max, nf[i]);
+        for (int i = 0; i < n; ++i) {
+            T_max = std::max(T_max, nf[i]);
+        }
         return run_batch_encode(gc, gm, mels, nf, n_mels, T_max, total_mel_us);
     }
 
     // Per-utterance fallback (also the malformed-input path).
     for (int i = 0; i < n; ++i) {
-        if (gc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
+        if (gc->poll_abort()) {
+            return TRANSCRIBE_ERR_ABORTED;
+        }
         if (pcm[i] == nullptr || n_samples[i] <= 0) {
             transcribe_session::ResultSet rs;
             rs.status = TRANSCRIBE_ERR_INVALID_ARG;
@@ -1014,21 +973,21 @@ transcribe_status run_batch(transcribe_session *          session,
     return TRANSCRIBE_OK;
 }
 
-} // namespace
+}  // namespace
 
 const Arch arch = {
-    /*.name             =*/ "medasr",
-    /*.load             =*/ load,
-    /*.init_context     =*/ init_context,
-    /*.run              =*/ run,
-    /*.run_batch        =*/ run_batch,
-    /*.stream_validate  =*/ nullptr,
-    /*.stream_begin     =*/ nullptr,
-    /*.stream_feed      =*/ nullptr,
-    /*.stream_finalize  =*/ nullptr,
-    /*.stream_reset     =*/ nullptr,
-    /*.accepts_ext_kind =*/ nullptr,
-    /*.run_validate     =*/ nullptr,
+    /*.name             =*/"medasr",
+    /*.load             =*/load,
+    /*.init_context     =*/init_context,
+    /*.run              =*/run,
+    /*.run_batch        =*/run_batch,
+    /*.stream_validate  =*/nullptr,
+    /*.stream_begin     =*/nullptr,
+    /*.stream_feed      =*/nullptr,
+    /*.stream_finalize  =*/nullptr,
+    /*.stream_reset     =*/nullptr,
+    /*.accepts_ext_kind =*/nullptr,
+    /*.run_validate     =*/nullptr,
 };
 
-} // namespace transcribe::medasr
+}  // namespace transcribe::medasr
diff --git a/src/arch/medasr/weights.cpp b/src/arch/medasr/weights.cpp
index 4eaa9a26..c1413df0 100644
--- a/src/arch/medasr/weights.cpp
+++ b/src/arch/medasr/weights.cpp
@@ -7,13 +7,12 @@
 
 #include "weights.h"
 
-#include "transcribe-meta.h"
-#include "transcribe-weights-util.h"
-#include "transcribe-log.h"
-
-#include "ggml.h"
 #include "ggml-backend.h"
+#include "ggml.h"
 #include "gguf.h"
+#include "transcribe-log.h"
+#include "transcribe-meta.h"
+#include "transcribe-weights-util.h"
 
 #include <cmath>
 #include <cstdio>
@@ -25,76 +24,184 @@ namespace {
 
 constexpr const char * kFamilyTag = "medasr";
 
-} // namespace
+}  // namespace
 
-transcribe_status read_medasr_hparams(const gguf_context * gguf,
-                                      MedAsrHParams &      hp)
-{
-    if (gguf == nullptr) return TRANSCRIBE_ERR_INVALID_ARG;
+transcribe_status read_medasr_hparams(const gguf_context * gguf, MedAsrHParams & hp) {
+    if (gguf == nullptr) {
+        return TRANSCRIBE_ERR_INVALID_ARG;
+    }
 
     // Encoder.
-    if (auto st = read_required_u32_kv   (gguf, "stt.medasr.encoder.n_layers",           kFamilyTag, hp.enc_n_layers);     st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv   (gguf, "stt.medasr.encoder.hidden",             kFamilyTag, hp.enc_hidden);       st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv   (gguf, "stt.medasr.encoder.n_heads",            kFamilyTag, hp.enc_n_heads);      st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv   (gguf, "stt.medasr.encoder.n_kv_heads",         kFamilyTag, hp.enc_n_kv_heads);   st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv   (gguf, "stt.medasr.encoder.head_dim",           kFamilyTag, hp.enc_head_dim);     st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv   (gguf, "stt.medasr.encoder.intermediate",       kFamilyTag, hp.enc_intermediate); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.medasr.encoder.hidden_act",         kFamilyTag, hp.enc_hidden_act);   st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv   (gguf, "stt.medasr.encoder.conv_kernel",        kFamilyTag, hp.enc_conv_kernel);  st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv   (gguf, "stt.medasr.encoder.conv_residual_w0",   kFamilyTag, hp.enc_conv_resid_w0);st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv   (gguf, "stt.medasr.encoder.conv_residual_w1",   kFamilyTag, hp.enc_conv_resid_w1);st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv   (gguf, "stt.medasr.encoder.ff_residual_w0",     kFamilyTag, hp.enc_ff_resid_w0);  st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv   (gguf, "stt.medasr.encoder.ff_residual_w1",     kFamilyTag, hp.enc_ff_resid_w1);  st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv   (gguf, "stt.medasr.encoder.layer_norm_eps",     kFamilyTag, hp.enc_layer_norm_eps); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv   (gguf, "stt.medasr.encoder.max_pos_emb",        kFamilyTag, hp.enc_max_pos_emb);  st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv   (gguf, "stt.medasr.encoder.batch_norm_momentum",kFamilyTag, hp.enc_batch_norm_momentum); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv   (gguf, "stt.medasr.encoder.rope_theta",         kFamilyTag, hp.enc_rope_theta);   st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.medasr.encoder.rope_type",          kFamilyTag, hp.enc_rope_type);    st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv   (gguf, "stt.medasr.encoder.num_mel_bins",       kFamilyTag, hp.enc_num_mel_bins); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv   (gguf, "stt.medasr.encoder.sub_kernel",         kFamilyTag, hp.enc_sub_kernel);   st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv   (gguf, "stt.medasr.encoder.sub_stride",         kFamilyTag, hp.enc_sub_stride);   st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv   (gguf, "stt.medasr.encoder.sub_channels",       kFamilyTag, hp.enc_sub_channels); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv   (gguf, "stt.medasr.encoder.sub_n_layers",       kFamilyTag, hp.enc_sub_n_layers); st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_u32_kv(gguf, "stt.medasr.encoder.n_layers", kFamilyTag, hp.enc_n_layers);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.medasr.encoder.hidden", kFamilyTag, hp.enc_hidden);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.medasr.encoder.n_heads", kFamilyTag, hp.enc_n_heads);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.medasr.encoder.n_kv_heads", kFamilyTag, hp.enc_n_kv_heads);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.medasr.encoder.head_dim", kFamilyTag, hp.enc_head_dim);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.medasr.encoder.intermediate", kFamilyTag, hp.enc_intermediate);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_string_kv(gguf, "stt.medasr.encoder.hidden_act", kFamilyTag, hp.enc_hidden_act);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.medasr.encoder.conv_kernel", kFamilyTag, hp.enc_conv_kernel);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.medasr.encoder.conv_residual_w0", kFamilyTag, hp.enc_conv_resid_w0);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.medasr.encoder.conv_residual_w1", kFamilyTag, hp.enc_conv_resid_w1);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.medasr.encoder.ff_residual_w0", kFamilyTag, hp.enc_ff_resid_w0);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.medasr.encoder.ff_residual_w1", kFamilyTag, hp.enc_ff_resid_w1);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.medasr.encoder.layer_norm_eps", kFamilyTag, hp.enc_layer_norm_eps);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.medasr.encoder.max_pos_emb", kFamilyTag, hp.enc_max_pos_emb);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.medasr.encoder.batch_norm_momentum", kFamilyTag,
+                                       hp.enc_batch_norm_momentum);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.medasr.encoder.rope_theta", kFamilyTag, hp.enc_rope_theta);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_string_kv(gguf, "stt.medasr.encoder.rope_type", kFamilyTag, hp.enc_rope_type);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.medasr.encoder.num_mel_bins", kFamilyTag, hp.enc_num_mel_bins);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.medasr.encoder.sub_kernel", kFamilyTag, hp.enc_sub_kernel);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.medasr.encoder.sub_stride", kFamilyTag, hp.enc_sub_stride);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.medasr.encoder.sub_channels", kFamilyTag, hp.enc_sub_channels);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.medasr.encoder.sub_n_layers", kFamilyTag, hp.enc_sub_n_layers);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     if (hp.enc_n_heads <= 0 || hp.enc_hidden % hp.enc_n_heads != 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "medasr: invariant hidden %% n_heads != 0 "
-                     "(hidden=%d, n_heads=%d)",
-                     hp.enc_hidden, hp.enc_n_heads);
+                "medasr: invariant hidden %% n_heads != 0 "
+                "(hidden=%d, n_heads=%d)",
+                hp.enc_hidden, hp.enc_n_heads);
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.enc_sub_n_layers != 2 || hp.enc_sub_stride != 2) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "medasr: unsupported subsampling shape (n_layers=%d, "
-                     "stride=%d) — only 2 stride-2 convs implemented",
-                     hp.enc_sub_n_layers, hp.enc_sub_stride);
+                "medasr: unsupported subsampling shape (n_layers=%d, "
+                "stride=%d) — only 2 stride-2 convs implemented",
+                hp.enc_sub_n_layers, hp.enc_sub_stride);
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.enc_rope_type != "default") {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "medasr: unsupported rope_type=%s (expected default)",
-                     hp.enc_rope_type.c_str());
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "medasr: unsupported rope_type=%s (expected default)",
+                hp.enc_rope_type.c_str());
         return TRANSCRIBE_ERR_GGUF;
     }
 
     // CTC head.
-    if (auto st = read_required_u32_kv(gguf, "stt.medasr.ctc.vocab_size", kFamilyTag, hp.ctc_vocab_size); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.medasr.ctc.blank_id",   kFamilyTag, hp.ctc_blank_id);   st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_u32_kv(gguf, "stt.medasr.ctc.vocab_size", kFamilyTag, hp.ctc_vocab_size);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.medasr.ctc.blank_id", kFamilyTag, hp.ctc_blank_id);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Frontend.
-    if (auto st = read_required_string_kv(gguf, "stt.frontend.type",        kFamilyTag, hp.fe_type);        st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv   (gguf, "stt.frontend.sample_rate", kFamilyTag, hp.fe_sample_rate); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv   (gguf, "stt.frontend.num_mels",    kFamilyTag, hp.fe_num_mels);    st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv   (gguf, "stt.frontend.n_fft",       kFamilyTag, hp.fe_n_fft);       st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv   (gguf, "stt.frontend.win_length",  kFamilyTag, hp.fe_win_length);  st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv   (gguf, "stt.frontend.hop_length",  kFamilyTag, hp.fe_hop_length);  st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.frontend.window",      kFamilyTag, hp.fe_window);      st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.frontend.normalize",   kFamilyTag, hp.fe_normalize);   st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.frontend.pad_mode",    kFamilyTag, hp.fe_pad_mode);    st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.frontend.mel_norm",    kFamilyTag, hp.fe_mel_norm);    st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv   (gguf, "stt.frontend.log_clamp_min", kFamilyTag, hp.fe_log_clamp_min); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv   (gguf, "stt.frontend.mel_lower_hz", kFamilyTag, hp.fe_mel_lower_hz); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv   (gguf, "stt.frontend.mel_upper_hz", kFamilyTag, hp.fe_mel_upper_hz); st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_string_kv(gguf, "stt.frontend.type", kFamilyTag, hp.fe_type); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.sample_rate", kFamilyTag, hp.fe_sample_rate);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.num_mels", kFamilyTag, hp.fe_num_mels);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.n_fft", kFamilyTag, hp.fe_n_fft); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.win_length", kFamilyTag, hp.fe_win_length);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.hop_length", kFamilyTag, hp.fe_hop_length);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_string_kv(gguf, "stt.frontend.window", kFamilyTag, hp.fe_window); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_string_kv(gguf, "stt.frontend.normalize", kFamilyTag, hp.fe_normalize);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_string_kv(gguf, "stt.frontend.pad_mode", kFamilyTag, hp.fe_pad_mode);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_string_kv(gguf, "stt.frontend.mel_norm", kFamilyTag, hp.fe_mel_norm);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.frontend.log_clamp_min", kFamilyTag, hp.fe_log_clamp_min);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.frontend.mel_lower_hz", kFamilyTag, hp.fe_mel_lower_hz);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.frontend.mel_upper_hz", kFamilyTag, hp.fe_mel_upper_hz);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     return TRANSCRIBE_OK;
 }
@@ -103,53 +210,58 @@ transcribe_status read_medasr_hparams(const gguf_context * gguf,
 // Weights catalog
 // ---------------------------------------------------------------------------
 
-#define GET_LN(slot, name) do { \
-    ggml_tensor * _t = transcribe::weights::find_tensor( \
-        ctx_meta, (name), {GGML_TYPE_F32}, \
-        {hp.enc_hidden}, kFamilyTag); \
-    if (_t == nullptr) return TRANSCRIBE_ERR_GGUF; \
-    (slot) = _t; \
-} while (0)
-
-#define GET_LIN_W(slot, name, in_dim, out_dim) do { \
-    ggml_tensor * _t = transcribe::weights::find_tensor( \
-        ctx_meta, (name), {TRANSCRIBE_QUANT_LINEAR_TYPES}, \
-        {(in_dim), (out_dim)}, kFamilyTag); \
-    if (_t == nullptr) return TRANSCRIBE_ERR_GGUF; \
-    (slot) = _t; \
-} while (0)
-
-#define GET_LIN_B(slot, name, out_dim) do { \
-    ggml_tensor * _t = transcribe::weights::find_tensor( \
-        ctx_meta, (name), {GGML_TYPE_F32}, \
-        {(out_dim)}, kFamilyTag); \
-    if (_t == nullptr) return TRANSCRIBE_ERR_GGUF; \
-    (slot) = _t; \
-} while (0)
-
-#define GET_CONV_W(slot, name, k, in_dim, out_dim) do { \
-    ggml_tensor * _t = transcribe::weights::find_tensor( \
-        ctx_meta, (name), {TRANSCRIBE_QUANT_CONV_TYPES}, \
-        {(k), (in_dim), (out_dim)}, kFamilyTag); \
-    if (_t == nullptr) return TRANSCRIBE_ERR_GGUF; \
-    (slot) = _t; \
-} while (0)
-
-#define GET_F32_1D(slot, name, n) do { \
-    ggml_tensor * _t = transcribe::weights::find_tensor( \
-        ctx_meta, (name), {GGML_TYPE_F32}, \
-        {(n)}, kFamilyTag); \
-    if (_t == nullptr) return TRANSCRIBE_ERR_GGUF; \
-    (slot) = _t; \
-} while (0)
-
-#define GET_F32_2D(slot, name, n0, n1) do { \
-    ggml_tensor * _t = transcribe::weights::find_tensor( \
-        ctx_meta, (name), {GGML_TYPE_F32}, \
-        {(n0), (n1)}, kFamilyTag); \
-    if (_t == nullptr) return TRANSCRIBE_ERR_GGUF; \
-    (slot) = _t; \
-} while (0)
+#define GET_LN(slot, name)                                                                                        \
+    do {                                                                                                          \
+        ggml_tensor * _t =                                                                                        \
+            transcribe::weights::find_tensor(ctx_meta, (name), { GGML_TYPE_F32 }, { hp.enc_hidden }, kFamilyTag); \
+        if (_t == nullptr)                                                                                        \
+            return TRANSCRIBE_ERR_GGUF;                                                                           \
+        (slot) = _t;                                                                                              \
+    } while (0)
+
+#define GET_LIN_W(slot, name, in_dim, out_dim)                                                                   \
+    do {                                                                                                         \
+        ggml_tensor * _t = transcribe::weights::find_tensor(ctx_meta, (name), { TRANSCRIBE_QUANT_LINEAR_TYPES }, \
+                                                            { (in_dim), (out_dim) }, kFamilyTag);                \
+        if (_t == nullptr)                                                                                       \
+            return TRANSCRIBE_ERR_GGUF;                                                                          \
+        (slot) = _t;                                                                                             \
+    } while (0)
+
+#define GET_LIN_B(slot, name, out_dim)                                                                        \
+    do {                                                                                                      \
+        ggml_tensor * _t =                                                                                    \
+            transcribe::weights::find_tensor(ctx_meta, (name), { GGML_TYPE_F32 }, { (out_dim) }, kFamilyTag); \
+        if (_t == nullptr)                                                                                    \
+            return TRANSCRIBE_ERR_GGUF;                                                                       \
+        (slot) = _t;                                                                                          \
+    } while (0)
+
+#define GET_CONV_W(slot, name, k, in_dim, out_dim)                                                             \
+    do {                                                                                                       \
+        ggml_tensor * _t = transcribe::weights::find_tensor(ctx_meta, (name), { TRANSCRIBE_QUANT_CONV_TYPES }, \
+                                                            { (k), (in_dim), (out_dim) }, kFamilyTag);         \
+        if (_t == nullptr)                                                                                     \
+            return TRANSCRIBE_ERR_GGUF;                                                                        \
+        (slot) = _t;                                                                                           \
+    } while (0)
+
+#define GET_F32_1D(slot, name, n)                                                                                      \
+    do {                                                                                                               \
+        ggml_tensor * _t = transcribe::weights::find_tensor(ctx_meta, (name), { GGML_TYPE_F32 }, { (n) }, kFamilyTag); \
+        if (_t == nullptr)                                                                                             \
+            return TRANSCRIBE_ERR_GGUF;                                                                                \
+        (slot) = _t;                                                                                                   \
+    } while (0)
+
+#define GET_F32_2D(slot, name, n0, n1)                                                                         \
+    do {                                                                                                       \
+        ggml_tensor * _t =                                                                                     \
+            transcribe::weights::find_tensor(ctx_meta, (name), { GGML_TYPE_F32 }, { (n0), (n1) }, kFamilyTag); \
+        if (_t == nullptr)                                                                                     \
+            return TRANSCRIBE_ERR_GGUF;                                                                        \
+        (slot) = _t;                                                                                           \
+    } while (0)
 
 using transcribe::weights::lname;
 
@@ -175,54 +287,52 @@ transcribe_status build_block(ggml_context *        ctx_meta,
                               const MedAsrHParams & hp,
                               int                   i,
                               MedAsrBlock &         b,
-                              RawBnTensors &        bn)
-{
-    const int d   = hp.enc_hidden;
-    const int dff = hp.enc_intermediate;
+                              RawBnTensors &        bn) {
+    const int d    = hp.enc_hidden;
+    const int dff  = hp.enc_intermediate;
     const int dw_k = hp.enc_conv_kernel;
 
     // Macaron FF1 (LN no bias; linears no bias).
-    GET_LN   (b.norm_ff1_w,  lname("enc.blocks.%d.norm_ff1.weight", i));
-    GET_LIN_W(b.ff1_up_w,    lname("enc.blocks.%d.ff1_up.weight",   i), d,   dff);
-    GET_LIN_W(b.ff1_down_w,  lname("enc.blocks.%d.ff1_down.weight", i), dff, d);
+    GET_LN(b.norm_ff1_w, lname("enc.blocks.%d.norm_ff1.weight", i));
+    GET_LIN_W(b.ff1_up_w, lname("enc.blocks.%d.ff1_up.weight", i), d, dff);
+    GET_LIN_W(b.ff1_down_w, lname("enc.blocks.%d.ff1_down.weight", i), dff, d);
 
     // Self-attention (RoPE; linears no bias).
-    GET_LN   (b.norm_attn_w, lname("enc.blocks.%d.norm_attn.weight", i));
-    GET_LIN_W(b.attn_q_w,    lname("enc.blocks.%d.attn_q.weight",    i), d, d);
-    GET_LIN_W(b.attn_k_w,    lname("enc.blocks.%d.attn_k.weight",    i), d, d);
-    GET_LIN_W(b.attn_v_w,    lname("enc.blocks.%d.attn_v.weight",    i), d, d);
-    GET_LIN_W(b.attn_o_w,    lname("enc.blocks.%d.attn_o.weight",    i), d, d);
+    GET_LN(b.norm_attn_w, lname("enc.blocks.%d.norm_attn.weight", i));
+    GET_LIN_W(b.attn_q_w, lname("enc.blocks.%d.attn_q.weight", i), d, d);
+    GET_LIN_W(b.attn_k_w, lname("enc.blocks.%d.attn_k.weight", i), d, d);
+    GET_LIN_W(b.attn_v_w, lname("enc.blocks.%d.attn_v.weight", i), d, d);
+    GET_LIN_W(b.attn_o_w, lname("enc.blocks.%d.attn_o.weight", i), d, d);
 
     // Conv module. pw1 is 1x1 conv into 2*d for GLU; depthwise k=32; pw2 1x1.
-    GET_LN    (b.norm_conv_w,   lname("enc.blocks.%d.norm_conv.weight",       i));
-    GET_CONV_W(b.conv_pw1_w,    lname("enc.blocks.%d.conv_pointwise1.weight", i), 1, d, 2 * d);
-    GET_CONV_W(b.conv_dw_w,     lname("enc.blocks.%d.conv_depthwise.weight",  i), dw_k, 1, d);
-    GET_CONV_W(b.conv_pw2_w,    lname("enc.blocks.%d.conv_pointwise2.weight", i), 1, d, d);
+    GET_LN(b.norm_conv_w, lname("enc.blocks.%d.norm_conv.weight", i));
+    GET_CONV_W(b.conv_pw1_w, lname("enc.blocks.%d.conv_pointwise1.weight", i), 1, d, 2 * d);
+    GET_CONV_W(b.conv_dw_w, lname("enc.blocks.%d.conv_depthwise.weight", i), dw_k, 1, d);
+    GET_CONV_W(b.conv_pw2_w, lname("enc.blocks.%d.conv_pointwise2.weight", i), 1, d, d);
 
     // Raw BN tensors (read at fuse time, never consulted after).
-    GET_F32_1D(bn.w,    lname("enc.blocks.%d.conv_bn.weight",       i), d);
-    GET_F32_1D(bn.b,    lname("enc.blocks.%d.conv_bn.bias",         i), d);
+    GET_F32_1D(bn.w, lname("enc.blocks.%d.conv_bn.weight", i), d);
+    GET_F32_1D(bn.b, lname("enc.blocks.%d.conv_bn.bias", i), d);
     GET_F32_1D(bn.mean, lname("enc.blocks.%d.conv_bn.running_mean", i), d);
-    GET_F32_1D(bn.var,  lname("enc.blocks.%d.conv_bn.running_var",  i), d);
+    GET_F32_1D(bn.var, lname("enc.blocks.%d.conv_bn.running_var", i), d);
 
     // Macaron FF2.
-    GET_LN   (b.norm_ff2_w, lname("enc.blocks.%d.norm_ff2.weight", i));
-    GET_LIN_W(b.ff2_up_w,   lname("enc.blocks.%d.ff2_up.weight",   i), d,   dff);
+    GET_LN(b.norm_ff2_w, lname("enc.blocks.%d.norm_ff2.weight", i));
+    GET_LIN_W(b.ff2_up_w, lname("enc.blocks.%d.ff2_up.weight", i), d, dff);
     GET_LIN_W(b.ff2_down_w, lname("enc.blocks.%d.ff2_down.weight", i), dff, d);
 
     // Final per-block LN (no bias).
-    GET_LN   (b.norm_post_w, lname("enc.blocks.%d.norm_post.weight", i));
+    GET_LN(b.norm_post_w, lname("enc.blocks.%d.norm_post.weight", i));
 
     return TRANSCRIBE_OK;
 }
 
-} // namespace
+}  // namespace
 
-transcribe_status build_medasr_weights(ggml_context *        ctx_meta,
-                                       const MedAsrHParams & hp,
-                                       MedAsrWeights &       weights)
-{
-    if (ctx_meta == nullptr) return TRANSCRIBE_ERR_INVALID_ARG;
+transcribe_status build_medasr_weights(ggml_context * ctx_meta, const MedAsrHParams & hp, MedAsrWeights & weights) {
+    if (ctx_meta == nullptr) {
+        return TRANSCRIBE_ERR_INVALID_ARG;
+    }
 
     const int d      = hp.enc_hidden;
     const int n_mels = hp.enc_num_mel_bins;
@@ -233,27 +343,27 @@ transcribe_status build_medasr_weights(ggml_context *        ctx_meta,
     // Frontend buffers (baked into the GGUF by the converter). The
     // converter emits the filterbank with numpy shape (n_freq, n_mels);
     // GGUF reverses to ggml ne=[n_mels, n_freq] (fast=n_mels).
-    GET_F32_2D(weights.frontend_mel_filterbank,
-               "frontend.mel_filterbank", hp.fe_num_mels, n_freq);
+    GET_F32_2D(weights.frontend_mel_filterbank, "frontend.mel_filterbank", hp.fe_num_mels, n_freq);
     GET_F32_1D(weights.frontend_window, "frontend.window", hp.fe_win_length);
 
     // Subsampling: Linear(128 -> 512) -> ReLU -> Conv1d(512, 512, k=5, s=2)
     // -> ReLU -> Conv1d(512, 256, k=5, s=2) -> ReLU -> Linear(256 -> 512).
     GET_LIN_W(weights.subsampling.dense0_w, "enc.subsampling.dense_0.weight", n_mels, d);
-    GET_LIN_B(weights.subsampling.dense0_b, "enc.subsampling.dense_0.bias",   d);
-    GET_CONV_W(weights.subsampling.conv0_w, "enc.subsampling.conv_0.weight",  sub_k, d, d);
-    GET_LIN_B (weights.subsampling.conv0_b, "enc.subsampling.conv_0.bias",    d);
-    GET_CONV_W(weights.subsampling.conv1_w, "enc.subsampling.conv_1.weight",  sub_k, d, sub_c);
-    GET_LIN_B (weights.subsampling.conv1_b, "enc.subsampling.conv_1.bias",    sub_c);
-    GET_LIN_W (weights.subsampling.dense1_w,"enc.subsampling.dense_1.weight", sub_c, d);
-    GET_LIN_B (weights.subsampling.dense1_b,"enc.subsampling.dense_1.bias",   d);
+    GET_LIN_B(weights.subsampling.dense0_b, "enc.subsampling.dense_0.bias", d);
+    GET_CONV_W(weights.subsampling.conv0_w, "enc.subsampling.conv_0.weight", sub_k, d, d);
+    GET_LIN_B(weights.subsampling.conv0_b, "enc.subsampling.conv_0.bias", d);
+    GET_CONV_W(weights.subsampling.conv1_w, "enc.subsampling.conv_1.weight", sub_k, d, sub_c);
+    GET_LIN_B(weights.subsampling.conv1_b, "enc.subsampling.conv_1.bias", sub_c);
+    GET_LIN_W(weights.subsampling.dense1_w, "enc.subsampling.dense_1.weight", sub_c, d);
+    GET_LIN_B(weights.subsampling.dense1_b, "enc.subsampling.dense_1.bias", d);
 
     // Conformer blocks.
     weights.blocks.resize(hp.enc_n_layers);
     g_raw_bn.assign(hp.enc_n_layers, RawBnTensors{});
     for (int i = 0; i < hp.enc_n_layers; ++i) {
-        if (auto st = build_block(ctx_meta, hp, i, weights.blocks[i], g_raw_bn[i]);
-            st != TRANSCRIBE_OK) return st;
+        if (auto st = build_block(ctx_meta, hp, i, weights.blocks[i], g_raw_bn[i]); st != TRANSCRIBE_OK) {
+            return st;
+        }
     }
 
     // Top-level out norm (no bias).
@@ -261,24 +371,23 @@ transcribe_status build_medasr_weights(ggml_context *        ctx_meta,
 
     // CTC head: Conv1d(d, vocab, k=1) with bias.
     GET_CONV_W(weights.ctc_head.proj_w, "ctc.proj.weight", 1, d, hp.ctc_vocab_size);
-    GET_LIN_B (weights.ctc_head.proj_b, "ctc.proj.bias",      hp.ctc_vocab_size);
+    GET_LIN_B(weights.ctc_head.proj_b, "ctc.proj.bias", hp.ctc_vocab_size);
 
     return TRANSCRIBE_OK;
 }
 
-transcribe_status fuse_batch_norm(const gguf_context *  /*gguf_data*/,
-                                  ggml_context *        /*ctx_meta*/,
+transcribe_status fuse_batch_norm(const gguf_context * /*gguf_data*/,
+                                  ggml_context * /*ctx_meta*/,
                                   const MedAsrHParams & hp,
-                                  MedAsrWeights &       weights)
-{
+                                  MedAsrWeights &       weights) {
     if (hp.enc_n_layers <= 0 || hp.enc_hidden <= 0) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
     if (static_cast<int>(g_raw_bn.size()) != hp.enc_n_layers) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "medasr fuse_batch_norm: raw BN catalog size %zu != "
-                     "n_layers %d",
-                     g_raw_bn.size(), hp.enc_n_layers);
+                "medasr fuse_batch_norm: raw BN catalog size %zu != "
+                "n_layers %d",
+                g_raw_bn.size(), hp.enc_n_layers);
         return TRANSCRIBE_ERR_GGUF;
     }
 
@@ -289,35 +398,33 @@ transcribe_status fuse_batch_norm(const gguf_context *  /*gguf_data*/,
     // are used directly. Eps is the standard PyTorch default 1e-5 (NOT the
     // encoder's layer_norm_eps 1e-6; the two epsilons are independent).
     constexpr float kBnEps = 1e-5f;
-    const int d = hp.enc_hidden;
+    const int       d      = hp.enc_hidden;
 
-    weights.fused_bn_scale_storage.assign(static_cast<size_t>(hp.enc_n_layers),
-                                          std::vector<float>(d, 0.0f));
-    weights.fused_bn_bias_storage.assign(static_cast<size_t>(hp.enc_n_layers),
-                                         std::vector<float>(d, 0.0f));
+    weights.fused_bn_scale_storage.assign(static_cast<size_t>(hp.enc_n_layers), std::vector<float>(d, 0.0f));
+    weights.fused_bn_bias_storage.assign(static_cast<size_t>(hp.enc_n_layers), std::vector<float>(d, 0.0f));
 
     std::vector<float> bn_w(d), bn_b(d), bn_mean(d), bn_var(d);
 
     for (int i = 0; i < hp.enc_n_layers; ++i) {
         const RawBnTensors & raw = g_raw_bn[static_cast<size_t>(i)];
-        if (raw.w == nullptr || raw.b == nullptr ||
-            raw.mean == nullptr || raw.var == nullptr) {
+        if (raw.w == nullptr || raw.b == nullptr || raw.mean == nullptr || raw.var == nullptr) {
             log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "medasr fuse_batch_norm: missing raw BN tensor at "
-                         "layer %d", i);
+                    "medasr fuse_batch_norm: missing raw BN tensor at "
+                    "layer %d",
+                    i);
             return TRANSCRIBE_ERR_GGUF;
         }
-        ggml_backend_tensor_get(raw.w,    bn_w.data(),    0, d * sizeof(float));
-        ggml_backend_tensor_get(raw.b,    bn_b.data(),    0, d * sizeof(float));
+        ggml_backend_tensor_get(raw.w, bn_w.data(), 0, d * sizeof(float));
+        ggml_backend_tensor_get(raw.b, bn_b.data(), 0, d * sizeof(float));
         ggml_backend_tensor_get(raw.mean, bn_mean.data(), 0, d * sizeof(float));
-        ggml_backend_tensor_get(raw.var,  bn_var.data(),  0, d * sizeof(float));
+        ggml_backend_tensor_get(raw.var, bn_var.data(), 0, d * sizeof(float));
 
         auto & scale = weights.fused_bn_scale_storage[static_cast<size_t>(i)];
-        auto & bias  = weights.fused_bn_bias_storage [static_cast<size_t>(i)];
+        auto & bias  = weights.fused_bn_bias_storage[static_cast<size_t>(i)];
         for (int c = 0; c < d; ++c) {
             const float s = bn_w[c] / std::sqrt(bn_var[c] + kBnEps);
-            scale[c] = s;
-            bias[c]  = bn_b[c] - bn_mean[c] * s;
+            scale[c]      = s;
+            bias[c]       = bn_b[c] - bn_mean[c] * s;
         }
     }
 
@@ -326,4 +433,4 @@ transcribe_status fuse_batch_norm(const gguf_context *  /*gguf_data*/,
     return TRANSCRIBE_OK;
 }
 
-} // namespace transcribe::medasr
+}  // namespace transcribe::medasr
diff --git a/src/arch/medasr/weights.h b/src/arch/medasr/weights.h
index 608b7178..e1fe5502 100644
--- a/src/arch/medasr/weights.h
+++ b/src/arch/medasr/weights.h
@@ -27,53 +27,52 @@ namespace transcribe::medasr {
 
 struct MedAsrHParams {
     // Encoder.
-    int32_t enc_n_layers     = 0;
-    int32_t enc_hidden       = 0;     // d_model
-    int32_t enc_n_heads      = 0;
-    int32_t enc_n_kv_heads   = 0;     // = n_heads (no GQA)
-    int32_t enc_head_dim     = 0;
-    int32_t enc_intermediate = 0;     // d_ff
-    std::string enc_hidden_act;       // "silu"
-    int32_t enc_conv_kernel  = 0;     // 32
-    float   enc_conv_resid_w0 = 0.0f; // 2.0
-    float   enc_conv_resid_w1 = 0.0f; // 1.0
-    float   enc_ff_resid_w0   = 0.0f; // 1.5
-    float   enc_ff_resid_w1   = 0.0f; // 0.5
-    float   enc_layer_norm_eps = 1e-6f;
-    int32_t enc_max_pos_emb  = 0;
-    float   enc_batch_norm_momentum = 0.01f;
-    float   enc_rope_theta   = 10000.0f;
-    std::string enc_rope_type;        // "default"
+    int32_t     enc_n_layers     = 0;
+    int32_t     enc_hidden       = 0;            // d_model
+    int32_t     enc_n_heads      = 0;
+    int32_t     enc_n_kv_heads   = 0;            // = n_heads (no GQA)
+    int32_t     enc_head_dim     = 0;
+    int32_t     enc_intermediate = 0;            // d_ff
+    std::string enc_hidden_act;                  // "silu"
+    int32_t     enc_conv_kernel         = 0;     // 32
+    float       enc_conv_resid_w0       = 0.0f;  // 2.0
+    float       enc_conv_resid_w1       = 0.0f;  // 1.0
+    float       enc_ff_resid_w0         = 0.0f;  // 1.5
+    float       enc_ff_resid_w1         = 0.0f;  // 0.5
+    float       enc_layer_norm_eps      = 1e-6f;
+    int32_t     enc_max_pos_emb         = 0;
+    float       enc_batch_norm_momentum = 0.01f;
+    float       enc_rope_theta          = 10000.0f;
+    std::string enc_rope_type;  // "default"
 
     // Subsampling (encoder stem).
-    int32_t enc_num_mel_bins = 0;     // 128
-    int32_t enc_sub_kernel   = 0;     // 5
-    int32_t enc_sub_stride   = 0;     // 2
-    int32_t enc_sub_channels = 0;     // 256
-    int32_t enc_sub_n_layers = 0;     // 2
+    int32_t enc_num_mel_bins = 0;  // 128
+    int32_t enc_sub_kernel   = 0;  // 5
+    int32_t enc_sub_stride   = 0;  // 2
+    int32_t enc_sub_channels = 0;  // 256
+    int32_t enc_sub_n_layers = 0;  // 2
 
     // CTC head.
     int32_t ctc_vocab_size = 0;
-    int32_t ctc_blank_id   = 0;       // 0 (<epsilon>)
+    int32_t ctc_blank_id   = 0;  // 0 (<epsilon>)
 
     // Frontend.
-    std::string fe_type;              // "mel"
-    int32_t fe_sample_rate = 0;
-    int32_t fe_num_mels    = 0;
-    int32_t fe_n_fft       = 0;
-    int32_t fe_win_length  = 0;
-    int32_t fe_hop_length  = 0;
-    std::string fe_window;            // "hann_symmetric"
-    std::string fe_normalize;         // "none"
-    std::string fe_pad_mode;          // "zero"
-    std::string fe_mel_norm;          // "htk"
-    float fe_log_clamp_min = 1e-5f;
-    float fe_mel_lower_hz  = 125.0f;
-    float fe_mel_upper_hz  = 7500.0f;
+    std::string fe_type;  // "mel"
+    int32_t     fe_sample_rate = 0;
+    int32_t     fe_num_mels    = 0;
+    int32_t     fe_n_fft       = 0;
+    int32_t     fe_win_length  = 0;
+    int32_t     fe_hop_length  = 0;
+    std::string fe_window;     // "hann_symmetric"
+    std::string fe_normalize;  // "none"
+    std::string fe_pad_mode;   // "zero"
+    std::string fe_mel_norm;   // "htk"
+    float       fe_log_clamp_min = 1e-5f;
+    float       fe_mel_lower_hz  = 125.0f;
+    float       fe_mel_upper_hz  = 7500.0f;
 };
 
-transcribe_status read_medasr_hparams(const gguf_context * gguf,
-                                      MedAsrHParams &      hp);
+transcribe_status read_medasr_hparams(const gguf_context * gguf, MedAsrHParams & hp);
 
 // ---------------------------------------------------------------------------
 // Weight slots
@@ -82,14 +81,14 @@ transcribe_status read_medasr_hparams(const gguf_context * gguf,
 // Subsampling: Linear(128 -> 512) -> ReLU -> Conv1d(512, 512, k=5, s=2)
 // -> ReLU -> Conv1d(512, 256, k=5, s=2) -> ReLU -> Linear(256 -> 512).
 struct MedAsrSubsampling {
-    ggml_tensor * dense0_w = nullptr; // [n_mels=128, d_model=512]
-    ggml_tensor * dense0_b = nullptr; // [d_model]
-    ggml_tensor * conv0_w  = nullptr; // [k=5, in=d_model, out=d_model]
-    ggml_tensor * conv0_b  = nullptr; // [d_model]
-    ggml_tensor * conv1_w  = nullptr; // [k=5, in=d_model, out=sub_channels=256]
-    ggml_tensor * conv1_b  = nullptr; // [sub_channels]
-    ggml_tensor * dense1_w = nullptr; // [sub_channels, d_model]
-    ggml_tensor * dense1_b = nullptr; // [d_model]
+    ggml_tensor * dense0_w = nullptr;  // [n_mels=128, d_model=512]
+    ggml_tensor * dense0_b = nullptr;  // [d_model]
+    ggml_tensor * conv0_w  = nullptr;  // [k=5, in=d_model, out=d_model]
+    ggml_tensor * conv0_b  = nullptr;  // [d_model]
+    ggml_tensor * conv1_w  = nullptr;  // [k=5, in=d_model, out=sub_channels=256]
+    ggml_tensor * conv1_b  = nullptr;  // [sub_channels]
+    ggml_tensor * dense1_w = nullptr;  // [sub_channels, d_model]
+    ggml_tensor * dense1_b = nullptr;  // [d_model]
 };
 
 // One Conformer block. All encoder LNs are bias=false, all linears and
@@ -98,26 +97,26 @@ struct MedAsrSubsampling {
 struct MedAsrBlock {
     // Macaron FF1.
     ggml_tensor * norm_ff1_w = nullptr;
-    ggml_tensor * ff1_up_w   = nullptr; // [d_model, d_ff]
-    ggml_tensor * ff1_down_w = nullptr; // [d_ff, d_model]
+    ggml_tensor * ff1_up_w   = nullptr;  // [d_model, d_ff]
+    ggml_tensor * ff1_down_w = nullptr;  // [d_ff, d_model]
 
     // Self-attention (RoPE, no positional bias).
     ggml_tensor * norm_attn_w = nullptr;
-    ggml_tensor * attn_q_w    = nullptr; // [d_model, d_model]
+    ggml_tensor * attn_q_w    = nullptr;  // [d_model, d_model]
     ggml_tensor * attn_k_w    = nullptr;
     ggml_tensor * attn_v_w    = nullptr;
     ggml_tensor * attn_o_w    = nullptr;
 
     // Conv module (BatchNorm post-depthwise).
     ggml_tensor * norm_conv_w   = nullptr;
-    ggml_tensor * conv_pw1_w    = nullptr; // [k=1, in=d_model, out=2*d_model]
-    ggml_tensor * conv_dw_w     = nullptr; // [k=conv_kernel, 1, d_model]
+    ggml_tensor * conv_pw1_w    = nullptr;  // [k=1, in=d_model, out=2*d_model]
+    ggml_tensor * conv_dw_w     = nullptr;  // [k=conv_kernel, 1, d_model]
     // Fused BatchNorm parameters: scale = w / sqrt(var + eps),
     //                            bias  = b - mean * scale.
     // Fused once at load time from conv_bn.{weight,bias,running_mean,running_var}.
-    ggml_tensor * conv_bn_scale = nullptr; // [d_model]
-    ggml_tensor * conv_bn_bias  = nullptr; // [d_model]
-    ggml_tensor * conv_pw2_w    = nullptr; // [k=1, d_model, d_model]
+    ggml_tensor * conv_bn_scale = nullptr;  // [d_model]
+    ggml_tensor * conv_bn_bias  = nullptr;  // [d_model]
+    ggml_tensor * conv_pw2_w    = nullptr;  // [k=1, d_model, d_model]
 
     // Macaron FF2.
     ggml_tensor * norm_ff2_w = nullptr;
@@ -130,20 +129,20 @@ struct MedAsrBlock {
 
 // CTC head: Conv1d(d_model -> vocab, k=1) with bias.
 struct MedAsrCtcHead {
-    ggml_tensor * proj_w = nullptr; // [k=1, in=d_model, out=vocab]
-                                    //   or [d_model, vocab] post-load
-    ggml_tensor * proj_b = nullptr; // [vocab]
+    ggml_tensor * proj_w = nullptr;  // [k=1, in=d_model, out=vocab]
+                                     //   or [d_model, vocab] post-load
+    ggml_tensor * proj_b = nullptr;  // [vocab]
 };
 
 struct MedAsrWeights {
     // Baked frontend buffers (always present).
-    ggml_tensor * frontend_mel_filterbank = nullptr; // [n_mels, n_freq] f32
-    ggml_tensor * frontend_window         = nullptr; // [win_length] f32
+    ggml_tensor * frontend_mel_filterbank = nullptr;  // [n_mels, n_freq] f32
+    ggml_tensor * frontend_window         = nullptr;  // [win_length] f32
 
-    MedAsrSubsampling          subsampling;
-    std::vector<MedAsrBlock>   blocks;
-    ggml_tensor *              enc_out_norm_w = nullptr; // [d_model]
-    MedAsrCtcHead              ctc_head;
+    MedAsrSubsampling        subsampling;
+    std::vector<MedAsrBlock> blocks;
+    ggml_tensor *            enc_out_norm_w = nullptr;  // [d_model]
+    MedAsrCtcHead            ctc_head;
 
     // Host-side BatchNorm fusion outputs (per-layer scale/bias arrays,
     // sized [n_layers][d_model]). The fused conv_bn_{scale,bias} pointers
@@ -152,9 +151,7 @@ struct MedAsrWeights {
     std::vector<std::vector<float>> fused_bn_bias_storage;
 };
 
-transcribe_status build_medasr_weights(ggml_context *        ctx_meta,
-                                       const MedAsrHParams & hp,
-                                       MedAsrWeights &       weights);
+transcribe_status build_medasr_weights(ggml_context * ctx_meta, const MedAsrHParams & hp, MedAsrWeights & weights);
 
 // Fuse BatchNorm at load time. Reads raw bn.{weight,bias,running_mean,
 // running_var} from the GGUF, computes fused scale = w / sqrt(var + eps)
@@ -166,4 +163,4 @@ transcribe_status fuse_batch_norm(const gguf_context *  gguf_data,
                                   const MedAsrHParams & hp,
                                   MedAsrWeights &       weights);
 
-} // namespace transcribe::medasr
+}  // namespace transcribe::medasr
diff --git a/src/arch/moonshine/capabilities.cpp b/src/arch/moonshine/capabilities.cpp
index f2e2a2df..d66b4f5d 100644
--- a/src/arch/moonshine/capabilities.cpp
+++ b/src/arch/moonshine/capabilities.cpp
@@ -25,4 +25,4 @@ void apply_family_invariants(transcribe_model & model) {
     transcribe::set_feature(&model, TRANSCRIBE_FEATURE_CANCELLATION, true);
 }
 
-} // namespace transcribe::moonshine
+}  // namespace transcribe::moonshine
diff --git a/src/arch/moonshine/decoder.cpp b/src/arch/moonshine/decoder.cpp
index 1b366b71..9dfd4a57 100644
--- a/src/arch/moonshine/decoder.cpp
+++ b/src/arch/moonshine/decoder.cpp
@@ -20,14 +20,12 @@
 
 #include "decoder.h"
 
-#include "moonshine.h"
-#include "weights.h"
-
 #include "conformer/conformer.h"
+#include "ggml.h"
+#include "moonshine.h"
 #include "transcribe-debug.h"
 #include "transcribe-log.h"
-
-#include "ggml.h"
+#include "weights.h"
 
 #include <algorithm>
 #include <cmath>
@@ -38,13 +36,15 @@ namespace transcribe::moonshine {
 namespace {
 
 namespace conf = transcribe::conformer;
-using conf::named;
 using conf::layer_norm;
+using conf::named;
 
 // Pad axis 0 (head_dim) of a [head_dim, ...] tensor to head_dim_padded.
 // No-op when pad == 0.
 ggml_tensor * pad_head_dim(ggml_context * ctx, ggml_tensor * t, int pad) {
-    if (pad <= 0) return t;
+    if (pad <= 0) {
+        return t;
+    }
     return ggml_pad(ctx, t, /*p0=*/pad, /*p1=*/0, /*p2=*/0, /*p3=*/0);
 }
 
@@ -52,13 +52,11 @@ ggml_tensor * pad_head_dim(ggml_context * ctx, ggml_tensor * t, int pad) {
 // (slice off trailing head_dim_padding rows on dim 0). The result is
 // non-contiguous; caller cont's it before downstream ops that need
 // contiguity.
-ggml_tensor * unpad_head_dim(ggml_context * ctx, ggml_tensor * t,
-                             int head_dim, int pad)
-{
-    if (pad <= 0) return t;
-    return ggml_view_3d(ctx, t,
-                        head_dim, t->ne[1], t->ne[2],
-                        t->nb[1], t->nb[2], 0);
+ggml_tensor * unpad_head_dim(ggml_context * ctx, ggml_tensor * t, int head_dim, int pad) {
+    if (pad <= 0) {
+        return t;
+    }
+    return ggml_view_3d(ctx, t, head_dim, t->ne[1], t->ne[2], t->nb[1], t->nb[2], 0);
 }
 
 // GPT-J / interleaved RoPE (rotate_half slices x[..., 0::2] / x[..., 1::2])
@@ -67,19 +65,14 @@ ggml_tensor * apply_partial_rope(ggml_context *           ctx,
                                  ggml_tensor *            x,
                                  ggml_tensor *            positions,
                                  const MoonshineHParams & hp,
-                                 int                      head_dim_rot)
-{
-    return ggml_rope_ext(
-        ctx, x, positions, /*c=*/nullptr,
-        head_dim_rot,
-        GGML_ROPE_TYPE_NORMAL,
-        /*n_ctx_orig=*/0,
-        hp.rope_theta,
-        /*freq_scale=*/1.0f,
-        /*ext_factor=*/0.0f,
-        /*attn_factor=*/1.0f,
-        /*beta_fast=*/32.0f,
-        /*beta_slow=*/1.0f);
+                                 int                      head_dim_rot) {
+    return ggml_rope_ext(ctx, x, positions, /*c=*/nullptr, head_dim_rot, GGML_ROPE_TYPE_NORMAL,
+                         /*n_ctx_orig=*/0, hp.rope_theta,
+                         /*freq_scale=*/1.0f,
+                         /*ext_factor=*/0.0f,
+                         /*attn_factor=*/1.0f,
+                         /*beta_fast=*/32.0f,
+                         /*beta_slow=*/1.0f);
 }
 
 // SwiGLU MLP: fc1 hidden->2·intermediate, split into [x_proj, gate],
@@ -88,28 +81,30 @@ ggml_tensor * apply_partial_rope(ggml_context *           ctx,
 // ne[0]/2 is x_proj, second is gate.
 ggml_tensor * ffn_decoder_swiglu(ggml_context * ctx,
                                  ggml_tensor *  x,
-                                 ggml_tensor *  fc1_w, ggml_tensor * fc1_b,
-                                 ggml_tensor *  fc2_w, ggml_tensor * fc2_b,
-                                 int            ffn_dim)
-{
+                                 ggml_tensor *  fc1_w,
+                                 ggml_tensor *  fc1_b,
+                                 ggml_tensor *  fc2_w,
+                                 ggml_tensor *  fc2_b,
+                                 int            ffn_dim) {
     ggml_tensor * h = ggml_mul_mat(ctx, fc1_w, x);
-    if (fc1_b != nullptr) h = ggml_add(ctx, h, fc1_b);
+    if (fc1_b != nullptr) {
+        h = ggml_add(ctx, h, fc1_b);
+    }
     // h ne = [2·ffn_dim, T] (innermost is the channel dim).
     const int64_t T          = h->ne[1];
     const size_t  el         = ggml_element_size(h);
     const size_t  half_bytes = static_cast<size_t>(ffn_dim) * el;
 
     // First half: x_proj = h[..., :ffn_dim]  -> [ffn_dim, T]
-    ggml_tensor * x_proj = ggml_view_2d(ctx, h, ffn_dim, T,
-                                        h->nb[1], 0);
+    ggml_tensor * x_proj = ggml_view_2d(ctx, h, ffn_dim, T, h->nb[1], 0);
     // Second half: gate   = h[..., ffn_dim:]
-    ggml_tensor * gate   = ggml_view_2d(ctx, h, ffn_dim, T,
-                                        h->nb[1], half_bytes);
+    ggml_tensor * gate   = ggml_view_2d(ctx, h, ffn_dim, T, h->nb[1], half_bytes);
 
-    ggml_tensor * y = ggml_mul(ctx, ggml_silu(ctx, ggml_cont(ctx, gate)),
-                                    ggml_cont(ctx, x_proj));
+    ggml_tensor * y = ggml_mul(ctx, ggml_silu(ctx, ggml_cont(ctx, gate)), ggml_cont(ctx, x_proj));
     ggml_tensor * o = ggml_mul_mat(ctx, fc2_w, y);
-    if (fc2_b != nullptr) o = ggml_add(ctx, o, fc2_b);
+    if (fc2_b != nullptr) {
+        o = ggml_add(ctx, o, fc2_b);
+    }
     return o;
 }
 
@@ -141,8 +136,7 @@ ggml_tensor * mha_self_cached(ggml_context *           ctx,
                               int                      n_past,
                               int                      n_tokens,
                               int                      n_kv,
-                              bool                     use_flash)
-{
+                              bool                     use_flash) {
     const int   head_dim     = d_model / n_heads;
     const int   head_dim_pad = hp.dec_head_dim_padded();
     const int   head_dim_rot = hp.dec_head_dim_rot();
@@ -178,44 +172,30 @@ ggml_tensor * mha_self_cached(ggml_context *           ctx,
         const size_t k_elem = ggml_element_size(kv_cache.self_k);
         const size_t v_elem = ggml_element_size(kv_cache.self_v);
 
-        ggml_tensor * k_dst = ggml_view_1d(
-            ctx, kv_cache.self_k,
-            static_cast<int64_t>(n_tokens) * d_model,
-            k_elem * static_cast<size_t>(
-                static_cast<int64_t>(il) * n_ctx * d_model +
-                static_cast<int64_t>(n_past) * d_model));
-        ggml_tensor * v_dst = ggml_view_1d(
-            ctx, kv_cache.self_v,
-            static_cast<int64_t>(n_tokens) * d_model,
-            v_elem * static_cast<size_t>(
-                static_cast<int64_t>(il) * n_ctx * d_model +
-                static_cast<int64_t>(n_past) * d_model));
+        ggml_tensor * k_dst = ggml_view_1d(ctx, kv_cache.self_k, static_cast<int64_t>(n_tokens) * d_model,
+                                           k_elem * static_cast<size_t>(static_cast<int64_t>(il) * n_ctx * d_model +
+                                                                        static_cast<int64_t>(n_past) * d_model));
+        ggml_tensor * v_dst = ggml_view_1d(ctx, kv_cache.self_v, static_cast<int64_t>(n_tokens) * d_model,
+                                           v_elem * static_cast<size_t>(static_cast<int64_t>(il) * n_ctx * d_model +
+                                                                        static_cast<int64_t>(n_past) * d_model));
 
         ggml_build_forward_expand(gf, ggml_cpy(ctx, K_rope, k_dst));
-        ggml_build_forward_expand(gf, ggml_cpy(ctx, Vcur,   v_dst));
+        ggml_build_forward_expand(gf, ggml_cpy(ctx, Vcur, v_dst));
     }
 
     // Read [head_dim, n_kv, n_heads] views over the cache for attention.
-    const size_t k_elem = ggml_element_size(kv_cache.self_k);
-    ggml_tensor * K = ggml_view_3d(
-        ctx, kv_cache.self_k,
-        head_dim, n_kv, n_heads,
-        k_elem * d_model,        // nb1: stride between positions (full d_model row)
-        k_elem * head_dim,       // nb2: stride between heads inside a position
-        k_elem * static_cast<size_t>(
-            static_cast<int64_t>(il) * n_ctx * d_model));
-
-    const size_t v_elem = ggml_element_size(kv_cache.self_v);
-    ggml_tensor * V = ggml_view_3d(
-        ctx, kv_cache.self_v,
-        head_dim, n_kv, n_heads,
-        v_elem * d_model,
-        v_elem * head_dim,
-        v_elem * static_cast<size_t>(
-            static_cast<int64_t>(il) * n_ctx * d_model));
+    const size_t  k_elem = ggml_element_size(kv_cache.self_k);
+    ggml_tensor * K      = ggml_view_3d(ctx, kv_cache.self_k, head_dim, n_kv, n_heads,
+                                        k_elem * d_model,   // nb1: stride between positions (full d_model row)
+                                        k_elem * head_dim,  // nb2: stride between heads inside a position
+                                        k_elem * static_cast<size_t>(static_cast<int64_t>(il) * n_ctx * d_model));
+
+    const size_t  v_elem = ggml_element_size(kv_cache.self_v);
+    ggml_tensor * V = ggml_view_3d(ctx, kv_cache.self_v, head_dim, n_kv, n_heads, v_elem * d_model, v_elem * head_dim,
+                                   v_elem * static_cast<size_t>(static_cast<int64_t>(il) * n_ctx * d_model));
 
     // Pad head_dim on Q, K, V before attention (HF behavior).
-    ggml_tensor * Q = pad_head_dim(ctx, Q_unpad, pad);
+    ggml_tensor * Q   = pad_head_dim(ctx, Q_unpad, pad);
     ggml_tensor * K_p = pad_head_dim(ctx, ggml_cont(ctx, K), pad);
     ggml_tensor * V_p = pad_head_dim(ctx, ggml_cont(ctx, V), pad);
 
@@ -229,8 +209,8 @@ ggml_tensor * mha_self_cached(ggml_context *           ctx,
     } else {
         ggml_tensor * kq      = ggml_mul_mat(ctx, K_p, Q);
         ggml_tensor * kq_soft = ggml_soft_max_ext(ctx, kq, mask, scale, 0.0f);
-        ggml_tensor * v_t = ggml_cont(ctx, ggml_permute(ctx, V_p, 1, 0, 2, 3));
-        o = ggml_mul_mat(ctx, v_t, kq_soft);
+        ggml_tensor * v_t     = ggml_cont(ctx, ggml_permute(ctx, V_p, 1, 0, 2, 3));
+        o                     = ggml_mul_mat(ctx, v_t, kq_soft);
         // o ne: [head_dim_pad, n_tokens, n_heads, 1]
     }
 
@@ -274,8 +254,7 @@ ggml_tensor * mha_self_step(ggml_context *           ctx,
                             int                      d_model,
                             int                      il,
                             int                      max_n_kv,
-                            bool                     use_flash)
-{
+                            bool                     use_flash) {
     const int   head_dim     = d_model / n_heads;
     const int   head_dim_pad = hp.dec_head_dim_padded();
     const int   head_dim_rot = hp.dec_head_dim_rot();
@@ -301,52 +280,33 @@ ggml_tensor * mha_self_step(ggml_context *           ctx,
     // we write one [d_model, 1] row at the kv_idx position. K_rope is the
     // post-RoPE K; V is the unrotated projection.
     {
-        const size_t k_elem = ggml_element_size(kv_cache.self_k);
-        const size_t v_elem = ggml_element_size(kv_cache.self_v);
-        const size_t layer_off_k = k_elem * static_cast<size_t>(
-            static_cast<int64_t>(il) * n_ctx * d_model);
-        const size_t layer_off_v = v_elem * static_cast<size_t>(
-            static_cast<int64_t>(il) * n_ctx * d_model);
-
-        ggml_tensor * k_layer = ggml_view_2d(
-            ctx, kv_cache.self_k,
-            d_model, n_ctx,
-            k_elem * d_model, layer_off_k);
-        ggml_tensor * v_layer = ggml_view_2d(
-            ctx, kv_cache.self_v,
-            d_model, n_ctx,
-            v_elem * d_model, layer_off_v);
+        const size_t k_elem      = ggml_element_size(kv_cache.self_k);
+        const size_t v_elem      = ggml_element_size(kv_cache.self_v);
+        const size_t layer_off_k = k_elem * static_cast<size_t>(static_cast<int64_t>(il) * n_ctx * d_model);
+        const size_t layer_off_v = v_elem * static_cast<size_t>(static_cast<int64_t>(il) * n_ctx * d_model);
+
+        ggml_tensor * k_layer = ggml_view_2d(ctx, kv_cache.self_k, d_model, n_ctx, k_elem * d_model, layer_off_k);
+        ggml_tensor * v_layer = ggml_view_2d(ctx, kv_cache.self_v, d_model, n_ctx, v_elem * d_model, layer_off_v);
 
         // K_rope is [head_dim, n_heads, 1, 1] contiguous → reshape to [d_model, 1].
-        ggml_tensor * K_row = ggml_reshape_2d(ctx, ggml_cont(ctx, K_rope),
-                                              d_model, 1);
+        ggml_tensor * K_row = ggml_reshape_2d(ctx, ggml_cont(ctx, K_rope), d_model, 1);
         ggml_tensor * V_row = ggml_reshape_2d(ctx, Vcur, d_model, 1);
 
-        ggml_build_forward_expand(
-            gf, ggml_set_rows(ctx, k_layer, K_row, kv_idx));
-        ggml_build_forward_expand(
-            gf, ggml_set_rows(ctx, v_layer, V_row, kv_idx));
+        ggml_build_forward_expand(gf, ggml_set_rows(ctx, k_layer, K_row, kv_idx));
+        ggml_build_forward_expand(gf, ggml_set_rows(ctx, v_layer, V_row, kv_idx));
     }
 
     // Static read across [0, max_n_kv); mask zeros valid positions and
     // -inf's the rest, so flash-attn ignores empty/future slots.
-    const size_t k_elem = ggml_element_size(kv_cache.self_k);
-    ggml_tensor * K = ggml_view_3d(
-        ctx, kv_cache.self_k,
-        head_dim, max_n_kv, n_heads,
-        k_elem * d_model,
-        k_elem * head_dim,
-        k_elem * static_cast<size_t>(
-            static_cast<int64_t>(il) * n_ctx * d_model));
-
-    const size_t v_elem = ggml_element_size(kv_cache.self_v);
-    ggml_tensor * V = ggml_view_3d(
-        ctx, kv_cache.self_v,
-        head_dim, max_n_kv, n_heads,
-        v_elem * d_model,
-        v_elem * head_dim,
-        v_elem * static_cast<size_t>(
-            static_cast<int64_t>(il) * n_ctx * d_model));
+    const size_t  k_elem = ggml_element_size(kv_cache.self_k);
+    ggml_tensor * K =
+        ggml_view_3d(ctx, kv_cache.self_k, head_dim, max_n_kv, n_heads, k_elem * d_model, k_elem * head_dim,
+                     k_elem * static_cast<size_t>(static_cast<int64_t>(il) * n_ctx * d_model));
+
+    const size_t  v_elem = ggml_element_size(kv_cache.self_v);
+    ggml_tensor * V =
+        ggml_view_3d(ctx, kv_cache.self_v, head_dim, max_n_kv, n_heads, v_elem * d_model, v_elem * head_dim,
+                     v_elem * static_cast<size_t>(static_cast<int64_t>(il) * n_ctx * d_model));
 
     // Pad head_dim on Q, K, V before attention (HF behavior).
     ggml_tensor * Q   = pad_head_dim(ctx, Q_unpad, pad);
@@ -362,7 +322,7 @@ ggml_tensor * mha_self_step(ggml_context *           ctx,
         ggml_tensor * kq      = ggml_mul_mat(ctx, K_p, Q);
         ggml_tensor * kq_soft = ggml_soft_max_ext(ctx, kq, mask, scale, 0.0f);
         ggml_tensor * v_t     = ggml_cont(ctx, ggml_permute(ctx, V_p, 1, 0, 2, 3));
-        o = ggml_mul_mat(ctx, v_t, kq_soft);
+        o                     = ggml_mul_mat(ctx, v_t, kq_soft);
     }
 
     if (pad > 0) {
@@ -388,54 +348,41 @@ ggml_tensor * mha_cross_cached(ggml_context *           ctx,
                                int                      d_model,
                                int                      il,
                                int                      T_enc,
-                               bool                     use_flash)
-{
-    const int   head_dim     = d_model / n_heads;
-    const int   head_dim_pad = hp.dec_head_dim_padded();
-    const int   pad          = head_dim_pad - head_dim;
+                               bool                     use_flash) {
+    const int     head_dim     = d_model / n_heads;
+    const int     head_dim_pad = hp.dec_head_dim_padded();
+    const int     pad          = head_dim_pad - head_dim;
     // Unpadded scale (see comment in mha_self_cached).
-    const float scale        = 1.0f / std::sqrt(static_cast<float>(head_dim));
-    const int64_t n_tokens   = x->ne[1];
+    const float   scale        = 1.0f / std::sqrt(static_cast<float>(head_dim));
+    const int64_t n_tokens     = x->ne[1];
 
     ggml_tensor * Qcur = ggml_mul_mat(ctx, q_w, x);
-    ggml_tensor * Q = ggml_reshape_3d(ctx, Qcur, head_dim, n_heads, n_tokens);
-    Q = ggml_permute(ctx, Q, 0, 2, 1, 3);
-    Q = ggml_cont(ctx, Q);
-    Q = pad_head_dim(ctx, Q, pad);
+    ggml_tensor * Q    = ggml_reshape_3d(ctx, Qcur, head_dim, n_heads, n_tokens);
+    Q                  = ggml_permute(ctx, Q, 0, 2, 1, 3);
+    Q                  = ggml_cont(ctx, Q);
+    Q                  = pad_head_dim(ctx, Q, pad);
 
-    const size_t k_elem = ggml_element_size(kv_cache.cross_k);
-    ggml_tensor * K = ggml_view_3d(
-        ctx, kv_cache.cross_k,
-        head_dim, T_enc, n_heads,
-        k_elem * d_model,
-        k_elem * head_dim,
-        k_elem * static_cast<size_t>(
-            static_cast<int64_t>(il) * T_enc * d_model));
+    const size_t  k_elem = ggml_element_size(kv_cache.cross_k);
+    ggml_tensor * K = ggml_view_3d(ctx, kv_cache.cross_k, head_dim, T_enc, n_heads, k_elem * d_model, k_elem * head_dim,
+                                   k_elem * static_cast<size_t>(static_cast<int64_t>(il) * T_enc * d_model));
 
-    const size_t v_elem = ggml_element_size(kv_cache.cross_v);
-    ggml_tensor * V = ggml_view_3d(
-        ctx, kv_cache.cross_v,
-        head_dim, T_enc, n_heads,
-        v_elem * d_model,
-        v_elem * head_dim,
-        v_elem * static_cast<size_t>(
-            static_cast<int64_t>(il) * T_enc * d_model));
+    const size_t  v_elem = ggml_element_size(kv_cache.cross_v);
+    ggml_tensor * V = ggml_view_3d(ctx, kv_cache.cross_v, head_dim, T_enc, n_heads, v_elem * d_model, v_elem * head_dim,
+                                   v_elem * static_cast<size_t>(static_cast<int64_t>(il) * T_enc * d_model));
 
     ggml_tensor * K_p = pad_head_dim(ctx, ggml_cont(ctx, K), pad);
     ggml_tensor * V_p = pad_head_dim(ctx, ggml_cont(ctx, V), pad);
 
     ggml_tensor * o;
     if (use_flash) {
-        o = ggml_flash_attn_ext(ctx, Q, K_p, V_p, /*mask=*/nullptr,
-                                scale, 0.0f, 0.0f);
+        o = ggml_flash_attn_ext(ctx, Q, K_p, V_p, /*mask=*/nullptr, scale, 0.0f, 0.0f);
         o = ggml_permute(ctx, o, 0, 2, 1, 3);
         o = ggml_cont(ctx, o);
     } else {
         ggml_tensor * kq      = ggml_mul_mat(ctx, K_p, Q);
-        ggml_tensor * kq_soft = ggml_soft_max_ext(ctx, kq, /*mask=*/nullptr,
-                                                  scale, 0.0f);
-        ggml_tensor * v_t = ggml_cont(ctx, ggml_permute(ctx, V_p, 1, 0, 2, 3));
-        o = ggml_mul_mat(ctx, v_t, kq_soft);
+        ggml_tensor * kq_soft = ggml_soft_max_ext(ctx, kq, /*mask=*/nullptr, scale, 0.0f);
+        ggml_tensor * v_t     = ggml_cont(ctx, ggml_permute(ctx, V_p, 1, 0, 2, 3));
+        o                     = ggml_mul_mat(ctx, v_t, kq_soft);
     }
 
     if (pad > 0) {
@@ -449,21 +396,19 @@ ggml_tensor * mha_cross_cached(ggml_context *           ctx,
     return o;
 }
 
-} // namespace
+}  // namespace
 
 // Cross-KV precompute graph.
 DecoderBuild build_cross_kv_graph(ggml_context *           ctx,
                                   const MoonshineWeights & w,
                                   const MoonshineHParams & hp,
                                   MoonshineKvCache &       kv_cache,
-                                  int                      T_enc)
-{
-    DecoderBuild db {};
+                                  int                      T_enc) {
+    DecoderBuild db{};
 
     if (ctx == nullptr || T_enc <= 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine cross_kv: invalid arg (ctx=%p, T_enc=%d)",
-                     static_cast<void *>(ctx), T_enc);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine cross_kv: invalid arg (ctx=%p, T_enc=%d)",
+                static_cast<void *>(ctx), T_enc);
         return db;
     }
 
@@ -477,8 +422,7 @@ DecoderBuild build_cross_kv_graph(ggml_context *           ctx,
 
     db.graph = ggml_new_graph_custom(ctx, 4096, false);
     if (db.graph == nullptr) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine cross_kv: ggml_new_graph_custom failed");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine cross_kv: ggml_new_graph_custom failed");
         return db;
     }
 
@@ -494,16 +438,10 @@ DecoderBuild build_cross_kv_graph(ggml_context *           ctx,
         const size_t k_elem = ggml_element_size(kv_cache.cross_k);
         const size_t v_elem = ggml_element_size(kv_cache.cross_v);
 
-        ggml_tensor * k_dst = ggml_view_1d(
-            ctx, kv_cache.cross_k,
-            static_cast<int64_t>(T_enc) * d_model,
-            k_elem * static_cast<size_t>(
-                static_cast<int64_t>(il) * T_enc * d_model));
-        ggml_tensor * v_dst = ggml_view_1d(
-            ctx, kv_cache.cross_v,
-            static_cast<int64_t>(T_enc) * d_model,
-            v_elem * static_cast<size_t>(
-                static_cast<int64_t>(il) * T_enc * d_model));
+        ggml_tensor * k_dst = ggml_view_1d(ctx, kv_cache.cross_k, static_cast<int64_t>(T_enc) * d_model,
+                                           k_elem * static_cast<size_t>(static_cast<int64_t>(il) * T_enc * d_model));
+        ggml_tensor * v_dst = ggml_view_1d(ctx, kv_cache.cross_v, static_cast<int64_t>(T_enc) * d_model,
+                                           v_elem * static_cast<size_t>(static_cast<int64_t>(il) * T_enc * d_model));
 
         ggml_build_forward_expand(db.graph, ggml_cpy(ctx, Kcross, k_dst));
         ggml_build_forward_expand(db.graph, ggml_cpy(ctx, Vcross, v_dst));
@@ -521,22 +459,19 @@ DecoderBuild build_decoder_graph_kv(ggml_context *           ctx,
                                     int                      n_past,
                                     int                      T_enc,
                                     bool                     skip_log_softmax,
-                                    bool                     use_flash)
-{
-    DecoderBuild db {};
+                                    bool                     use_flash) {
+    DecoderBuild db{};
 
     if (ctx == nullptr || n_tokens <= 0 || T_enc <= 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine decoder_kv: invalid arg "
-                     "(ctx=%p, n_tokens=%d, T_enc=%d)",
-                     static_cast<void *>(ctx), n_tokens, T_enc);
+                "moonshine decoder_kv: invalid arg "
+                "(ctx=%p, n_tokens=%d, T_enc=%d)",
+                static_cast<void *>(ctx), n_tokens, T_enc);
         return db;
     }
     const int n_kv = n_past + n_tokens;
     if (n_kv > kv_cache.n_ctx) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine decoder_kv: n_kv=%d exceeds n_ctx=%d",
-                     n_kv, kv_cache.n_ctx);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine decoder_kv: n_kv=%d exceeds n_ctx=%d", n_kv, kv_cache.n_ctx);
         return db;
     }
 
@@ -557,7 +492,7 @@ DecoderBuild build_decoder_graph_kv(ggml_context *           ctx,
     // single token attends to its full live cache window with no
     // masking needed.
     ggml_tensor * causal_mask = nullptr;
-    const bool need_mask = (n_tokens > 1);
+    const bool    need_mask   = (n_tokens > 1);
     if (need_mask) {
         db.causal_mask_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, n_kv, n_tokens);
         named(db.causal_mask_in, "dec.causal_mask");
@@ -566,8 +501,7 @@ DecoderBuild build_decoder_graph_kv(ggml_context *           ctx,
     }
 
     // ---- Token embedding ----
-    ggml_tensor * tok_emb = ggml_get_rows(ctx, w.dec_top.token_embd_w,
-                                          db.token_ids_in);
+    ggml_tensor * tok_emb = ggml_get_rows(ctx, w.dec_top.token_embd_w, db.token_ids_in);
     named(tok_emb, "dec.token_emb");
     if (n_past == 0) {
         transcribe::debug::mark_tensor_for_dump(tok_emb);
@@ -590,8 +524,7 @@ DecoderBuild build_decoder_graph_kv(ggml_context *           ctx,
 
     db.graph = ggml_new_graph_custom(ctx, 8192, false);
     if (db.graph == nullptr) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine decoder_kv: ggml_new_graph_custom failed");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine decoder_kv: ggml_new_graph_custom failed");
         return db;
     }
 
@@ -602,27 +535,19 @@ DecoderBuild build_decoder_graph_kv(ggml_context *           ctx,
 
         {
             ggml_tensor * y = layer_norm(ctx, x, b.norm_self_w, /*beta=*/nullptr);
-            y = mha_self_cached(
-                ctx, db.graph, y, kv_cache, db.pos_ids_in, causal_mask,
-                b.self_q_w, b.self_k_w, b.self_v_w, b.self_out_w,
-                hp, n_heads, d_model,
-                i, n_past, n_tokens, n_kv, use_flash);
+            y = mha_self_cached(ctx, db.graph, y, kv_cache, db.pos_ids_in, causal_mask, b.self_q_w, b.self_k_w,
+                                b.self_v_w, b.self_out_w, hp, n_heads, d_model, i, n_past, n_tokens, n_kv, use_flash);
             x = ggml_add(ctx, x, y);
         }
         {
             ggml_tensor * y = layer_norm(ctx, x, b.norm_cross_w, /*beta=*/nullptr);
-            y = mha_cross_cached(
-                ctx, y, kv_cache,
-                b.cross_q_w, b.cross_out_w,
-                hp, n_heads, d_model, i, T_enc, use_flash);
+            y = mha_cross_cached(ctx, y, kv_cache, b.cross_q_w, b.cross_out_w, hp, n_heads, d_model, i, T_enc,
+                                 use_flash);
             x = ggml_add(ctx, x, y);
         }
         {
             ggml_tensor * y = layer_norm(ctx, x, b.norm_ffn_w, /*beta=*/nullptr);
-            y = ffn_decoder_swiglu(ctx, y,
-                                   b.ffn_fc1_w, b.ffn_fc1_b,
-                                   b.ffn_fc2_w, b.ffn_fc2_b,
-                                   hp.dec_ffn_dim);
+            y = ffn_decoder_swiglu(ctx, y, b.ffn_fc1_w, b.ffn_fc1_b, b.ffn_fc2_w, b.ffn_fc2_b, hp.dec_ffn_dim);
             x = ggml_add(ctx, x, y);
         }
 
@@ -672,12 +597,9 @@ DecoderBuild build_decoder_graph_kv(ggml_context *           ctx,
         ggml_tensor * last_logits = logits;
         if (n_tokens > 1) {
             const int64_t vocab     = logits->ne[0];
-            const size_t  row_bytes = ggml_element_size(logits) *
-                                      static_cast<size_t>(vocab);
-            last_logits = ggml_view_2d(ctx, logits,
-                                       vocab, /*n=*/1,
-                                       row_bytes,
-                                       row_bytes * static_cast<size_t>(n_tokens - 1));
+            const size_t  row_bytes = ggml_element_size(logits) * static_cast<size_t>(vocab);
+            last_logits =
+                ggml_view_2d(ctx, logits, vocab, /*n=*/1, row_bytes, row_bytes * static_cast<size_t>(n_tokens - 1));
             last_logits = ggml_cont(ctx, last_logits);
         }
         db.argmax_out = ggml_argmax(ctx, last_logits);
@@ -698,21 +620,17 @@ StepBuild build_step_graph(ggml_context *           ctx,
                            MoonshineKvCache &       kv_cache,
                            int                      max_n_kv,
                            int                      T_enc,
-                           bool                     use_flash)
-{
-    StepBuild sb {};
+                           bool                     use_flash) {
+    StepBuild sb{};
     sb.max_n_kv = max_n_kv;
 
     if (ctx == nullptr || max_n_kv <= 0 || T_enc <= 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine step: invalid arg (max_n_kv=%d, T_enc=%d)",
-                     max_n_kv, T_enc);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine step: invalid arg (max_n_kv=%d, T_enc=%d)", max_n_kv, T_enc);
         return sb;
     }
     if (max_n_kv > kv_cache.n_ctx) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine step: max_n_kv=%d exceeds kv_cache.n_ctx=%d",
-                     max_n_kv, kv_cache.n_ctx);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine step: max_n_kv=%d exceeds kv_cache.n_ctx=%d", max_n_kv,
+                kv_cache.n_ctx);
         return sb;
     }
 
@@ -750,27 +668,19 @@ StepBuild build_step_graph(ggml_context *           ctx,
 
         {
             ggml_tensor * y = layer_norm(ctx, x, b.norm_self_w, /*beta=*/nullptr);
-            y = mha_self_step(
-                ctx, sb.graph, y, kv_cache, sb.pos_id_in, sb.kv_idx_in, sb.mask_in,
-                b.self_q_w, b.self_k_w, b.self_v_w, b.self_out_w,
-                hp, n_heads, d_model,
-                i, max_n_kv, use_flash);
+            y = mha_self_step(ctx, sb.graph, y, kv_cache, sb.pos_id_in, sb.kv_idx_in, sb.mask_in, b.self_q_w,
+                              b.self_k_w, b.self_v_w, b.self_out_w, hp, n_heads, d_model, i, max_n_kv, use_flash);
             x = ggml_add(ctx, x, y);
         }
         {
             ggml_tensor * y = layer_norm(ctx, x, b.norm_cross_w, /*beta=*/nullptr);
-            y = mha_cross_cached(
-                ctx, y, kv_cache,
-                b.cross_q_w, b.cross_out_w,
-                hp, n_heads, d_model, i, T_enc, use_flash);
+            y = mha_cross_cached(ctx, y, kv_cache, b.cross_q_w, b.cross_out_w, hp, n_heads, d_model, i, T_enc,
+                                 use_flash);
             x = ggml_add(ctx, x, y);
         }
         {
             ggml_tensor * y = layer_norm(ctx, x, b.norm_ffn_w, /*beta=*/nullptr);
-            y = ffn_decoder_swiglu(ctx, y,
-                                   b.ffn_fc1_w, b.ffn_fc1_b,
-                                   b.ffn_fc2_w, b.ffn_fc2_b,
-                                   hp.dec_ffn_dim);
+            y = ffn_decoder_swiglu(ctx, y, b.ffn_fc1_w, b.ffn_fc1_b, b.ffn_fc2_w, b.ffn_fc2_b, hp.dec_ffn_dim);
             x = ggml_add(ctx, x, y);
         }
     }
@@ -792,29 +702,39 @@ StepBuild build_step_graph(ggml_context *           ctx,
 namespace {
 
 // Slice off head-dim padding on a 4D tensor [head_dim_pad, a, b, c] → keep B.
-ggml_tensor * unpad_head_dim_4d(ggml_context * ctx, ggml_tensor * t,
-                                int head_dim, int pad) {
-    if (pad <= 0) return t;
-    return ggml_view_4d(ctx, t, head_dim, t->ne[1], t->ne[2], t->ne[3],
-                        t->nb[1], t->nb[2], t->nb[3], 0);
+ggml_tensor * unpad_head_dim_4d(ggml_context * ctx, ggml_tensor * t, int head_dim, int pad) {
+    if (pad <= 0) {
+        return t;
+    }
+    return ggml_view_4d(ctx, t, head_dim, t->ne[1], t->ne[2], t->ne[3], t->nb[1], t->nb[2], t->nb[3], 0);
 }
 
 // Batched self-attention step (partial RoPE + head-dim pad). x: [d_model, B].
-ggml_tensor * mha_self_step_batched(
-    ggml_context * ctx, ggml_cgraph * gf, ggml_tensor * x,
-    MoonshineKvCache & kv_cache, ggml_tensor * pos_ids, ggml_tensor * kv_idx,
-    ggml_tensor * mask,
-    ggml_tensor * q_w, ggml_tensor * k_w, ggml_tensor * v_w, ggml_tensor * out_w,
-    const MoonshineHParams & hp, int n_heads, int d_model, int il, int max_n_kv, int B)
-{
-    const int   head_dim     = d_model / n_heads;
-    const int   head_dim_pad = hp.dec_head_dim_padded();
-    const int   head_dim_rot = hp.dec_head_dim_rot();
-    const int   pad          = head_dim_pad - head_dim;
-    const int64_t n_ctx      = kv_cache.n_ctx;
-    const float scale        = 1.0f / std::sqrt(static_cast<float>(head_dim));
-    const size_t k_elem = ggml_element_size(kv_cache.self_k);
-    const size_t v_elem = ggml_element_size(kv_cache.self_v);
+ggml_tensor * mha_self_step_batched(ggml_context *           ctx,
+                                    ggml_cgraph *            gf,
+                                    ggml_tensor *            x,
+                                    MoonshineKvCache &       kv_cache,
+                                    ggml_tensor *            pos_ids,
+                                    ggml_tensor *            kv_idx,
+                                    ggml_tensor *            mask,
+                                    ggml_tensor *            q_w,
+                                    ggml_tensor *            k_w,
+                                    ggml_tensor *            v_w,
+                                    ggml_tensor *            out_w,
+                                    const MoonshineHParams & hp,
+                                    int                      n_heads,
+                                    int                      d_model,
+                                    int                      il,
+                                    int                      max_n_kv,
+                                    int                      B) {
+    const int     head_dim     = d_model / n_heads;
+    const int     head_dim_pad = hp.dec_head_dim_padded();
+    const int     head_dim_rot = hp.dec_head_dim_rot();
+    const int     pad          = head_dim_pad - head_dim;
+    const int64_t n_ctx        = kv_cache.n_ctx;
+    const float   scale        = 1.0f / std::sqrt(static_cast<float>(head_dim));
+    const size_t  k_elem       = ggml_element_size(kv_cache.self_k);
+    const size_t  v_elem       = ggml_element_size(kv_cache.self_v);
 
     ggml_tensor * Q = ggml_mul_mat(ctx, q_w, x);  // [d_model, B]
     ggml_tensor * K = ggml_mul_mat(ctx, k_w, x);
@@ -829,90 +749,94 @@ ggml_tensor * mha_self_step_batched(
 
     // Batched KV write: slab [d_model, n_ctx, B].
     {
-        const size_t off_k = k_elem * static_cast<size_t>(il) * n_ctx * d_model * B;
-        const size_t off_v = v_elem * static_cast<size_t>(il) * n_ctx * d_model * B;
-        ggml_tensor * k_layer = ggml_view_3d(ctx, kv_cache.self_k,
-            d_model, n_ctx, B, k_elem * d_model, k_elem * d_model * n_ctx, off_k);
-        ggml_tensor * v_layer = ggml_view_3d(ctx, kv_cache.self_v,
-            d_model, n_ctx, B, v_elem * d_model, v_elem * d_model * n_ctx, off_v);
+        const size_t  off_k = k_elem * static_cast<size_t>(il) * n_ctx * d_model * B;
+        const size_t  off_v = v_elem * static_cast<size_t>(il) * n_ctx * d_model * B;
+        ggml_tensor * k_layer =
+            ggml_view_3d(ctx, kv_cache.self_k, d_model, n_ctx, B, k_elem * d_model, k_elem * d_model * n_ctx, off_k);
+        ggml_tensor * v_layer =
+            ggml_view_3d(ctx, kv_cache.self_v, d_model, n_ctx, B, v_elem * d_model, v_elem * d_model * n_ctx, off_v);
         ggml_tensor * K_row = ggml_reshape_3d(ctx, ggml_cont(ctx, K), d_model, 1, B);
         ggml_tensor * V_row = ggml_reshape_3d(ctx, ggml_cont(ctx, V), d_model, 1, B);
         ggml_build_forward_expand(gf, ggml_set_rows(ctx, k_layer, K_row, kv_idx));
         ggml_build_forward_expand(gf, ggml_set_rows(ctx, v_layer, V_row, kv_idx));
     }
 
-    const size_t off_k = k_elem * static_cast<size_t>(il) * n_ctx * d_model * B;
-    const size_t off_v = v_elem * static_cast<size_t>(il) * n_ctx * d_model * B;
-    ggml_tensor * K_att = ggml_view_4d(ctx, kv_cache.self_k,
-        head_dim, max_n_kv, n_heads, B,
-        k_elem * d_model, k_elem * head_dim, k_elem * d_model * n_ctx, off_k);
-    ggml_tensor * V_att = ggml_view_4d(ctx, kv_cache.self_v,
-        head_dim, max_n_kv, n_heads, B,
-        v_elem * d_model, v_elem * head_dim, v_elem * d_model * n_ctx, off_v);
+    const size_t  off_k = k_elem * static_cast<size_t>(il) * n_ctx * d_model * B;
+    const size_t  off_v = v_elem * static_cast<size_t>(il) * n_ctx * d_model * B;
+    ggml_tensor * K_att = ggml_view_4d(ctx, kv_cache.self_k, head_dim, max_n_kv, n_heads, B, k_elem * d_model,
+                                       k_elem * head_dim, k_elem * d_model * n_ctx, off_k);
+    ggml_tensor * V_att = ggml_view_4d(ctx, kv_cache.self_v, head_dim, max_n_kv, n_heads, B, v_elem * d_model,
+                                       v_elem * head_dim, v_elem * d_model * n_ctx, off_v);
 
     // Q for flash: [head_dim, n_heads, B] -> [head_dim, 1, n_heads, B].
     ggml_tensor * Q_att = ggml_cont(ctx, ggml_permute(ctx, Q, 0, 2, 3, 1));
-    ggml_tensor * Qp = pad_head_dim(ctx, Q_att, pad);
-    ggml_tensor * Kp = pad_head_dim(ctx, ggml_cont(ctx, K_att), pad);
-    ggml_tensor * Vp = pad_head_dim(ctx, ggml_cont(ctx, V_att), pad);
+    ggml_tensor * Qp    = pad_head_dim(ctx, Q_att, pad);
+    ggml_tensor * Kp    = pad_head_dim(ctx, ggml_cont(ctx, K_att), pad);
+    ggml_tensor * Vp    = pad_head_dim(ctx, ggml_cont(ctx, V_att), pad);
 
     ggml_tensor * o = ggml_flash_attn_ext(ctx, Qp, Kp, Vp, mask, scale, 0.0f, 0.0f);
     // o = [head_dim_pad, n_heads, 1, B] -> unpad -> [head_dim, n_heads, 1, B].
-    o = ggml_cont(ctx, unpad_head_dim_4d(ctx, o, head_dim, pad));
-    o = ggml_reshape_2d(ctx, o, d_model, B);
+    o               = ggml_cont(ctx, unpad_head_dim_4d(ctx, o, head_dim, pad));
+    o               = ggml_reshape_2d(ctx, o, d_model, B);
 
     o = ggml_mul_mat(ctx, out_w, o);
     return o;
 }
 
 // Batched cross-attention step (no RoPE, head-dim pad, cross-pad mask).
-ggml_tensor * mha_cross_step_batched(
-    ggml_context * ctx, ggml_tensor * x, MoonshineKvCache & kv_cache,
-    ggml_tensor * cross_mask, ggml_tensor * q_w, ggml_tensor * out_w,
-    const MoonshineHParams & hp, int n_heads, int d_model, int il, int T_enc_max, int B)
-{
-    const int   head_dim     = d_model / n_heads;
-    const int   head_dim_pad = hp.dec_head_dim_padded();
-    const int   pad          = head_dim_pad - head_dim;
-    const float scale        = 1.0f / std::sqrt(static_cast<float>(head_dim));
-    const size_t k_elem = ggml_element_size(kv_cache.cross_k);
-    const size_t v_elem = ggml_element_size(kv_cache.cross_v);
-
-    ggml_tensor * Q = ggml_mul_mat(ctx, q_w, x);  // [d_model, B]
-    Q = ggml_reshape_3d(ctx, Q, head_dim, n_heads, B);
+ggml_tensor * mha_cross_step_batched(ggml_context *           ctx,
+                                     ggml_tensor *            x,
+                                     MoonshineKvCache &       kv_cache,
+                                     ggml_tensor *            cross_mask,
+                                     ggml_tensor *            q_w,
+                                     ggml_tensor *            out_w,
+                                     const MoonshineHParams & hp,
+                                     int                      n_heads,
+                                     int                      d_model,
+                                     int                      il,
+                                     int                      T_enc_max,
+                                     int                      B) {
+    const int    head_dim     = d_model / n_heads;
+    const int    head_dim_pad = hp.dec_head_dim_padded();
+    const int    pad          = head_dim_pad - head_dim;
+    const float  scale        = 1.0f / std::sqrt(static_cast<float>(head_dim));
+    const size_t k_elem       = ggml_element_size(kv_cache.cross_k);
+    const size_t v_elem       = ggml_element_size(kv_cache.cross_v);
+
+    ggml_tensor * Q     = ggml_mul_mat(ctx, q_w, x);  // [d_model, B]
+    Q                   = ggml_reshape_3d(ctx, Q, head_dim, n_heads, B);
     ggml_tensor * Q_att = ggml_cont(ctx, ggml_permute(ctx, Q, 0, 2, 3, 1));
-    ggml_tensor * Qp = pad_head_dim(ctx, Q_att, pad);
-
-    const size_t off_k = k_elem * static_cast<size_t>(il) * T_enc_max * d_model * B;
-    const size_t off_v = v_elem * static_cast<size_t>(il) * T_enc_max * d_model * B;
-    ggml_tensor * K = ggml_view_4d(ctx, kv_cache.cross_k,
-        head_dim, T_enc_max, n_heads, B,
-        k_elem * d_model, k_elem * head_dim, k_elem * d_model * T_enc_max, off_k);
-    ggml_tensor * V = ggml_view_4d(ctx, kv_cache.cross_v,
-        head_dim, T_enc_max, n_heads, B,
-        v_elem * d_model, v_elem * head_dim, v_elem * d_model * T_enc_max, off_v);
-    ggml_tensor * Kp = pad_head_dim(ctx, ggml_cont(ctx, K), pad);
-    ggml_tensor * Vp = pad_head_dim(ctx, ggml_cont(ctx, V), pad);
+    ggml_tensor * Qp    = pad_head_dim(ctx, Q_att, pad);
+
+    const size_t  off_k = k_elem * static_cast<size_t>(il) * T_enc_max * d_model * B;
+    const size_t  off_v = v_elem * static_cast<size_t>(il) * T_enc_max * d_model * B;
+    ggml_tensor * K     = ggml_view_4d(ctx, kv_cache.cross_k, head_dim, T_enc_max, n_heads, B, k_elem * d_model,
+                                       k_elem * head_dim, k_elem * d_model * T_enc_max, off_k);
+    ggml_tensor * V     = ggml_view_4d(ctx, kv_cache.cross_v, head_dim, T_enc_max, n_heads, B, v_elem * d_model,
+                                       v_elem * head_dim, v_elem * d_model * T_enc_max, off_v);
+    ggml_tensor * Kp    = pad_head_dim(ctx, ggml_cont(ctx, K), pad);
+    ggml_tensor * Vp    = pad_head_dim(ctx, ggml_cont(ctx, V), pad);
 
     ggml_tensor * o = ggml_flash_attn_ext(ctx, Qp, Kp, Vp, cross_mask, scale, 0.0f, 0.0f);
-    o = ggml_cont(ctx, unpad_head_dim_4d(ctx, o, head_dim, pad));
-    o = ggml_reshape_2d(ctx, o, d_model, B);
+    o               = ggml_cont(ctx, unpad_head_dim_4d(ctx, o, head_dim, pad));
+    o               = ggml_reshape_2d(ctx, o, d_model, B);
 
     o = ggml_mul_mat(ctx, out_w, o);
     return o;
 }
 
-} // namespace
+}  // namespace
 
 DecoderBuild build_cross_kv_graph_batched(ggml_context *           ctx,
                                           const MoonshineWeights & w,
                                           const MoonshineHParams & hp,
                                           MoonshineKvCache &       kv_cache,
                                           int                      T_enc_max,
-                                          int                      n_batch)
-{
-    DecoderBuild db {};
-    if (ctx == nullptr || T_enc_max <= 0 || n_batch <= 0) return db;
+                                          int                      n_batch) {
+    DecoderBuild db{};
+    if (ctx == nullptr || T_enc_max <= 0 || n_batch <= 0) {
+        return db;
+    }
 
     const int d_model = hp.dec_d_model;
     const int B       = n_batch;
@@ -922,23 +846,25 @@ DecoderBuild build_cross_kv_graph_batched(ggml_context *           ctx,
     ggml_set_input(db.encoder_out_in);
 
     db.graph = ggml_new_graph_custom(ctx, 8192, false);
-    if (db.graph == nullptr) return db;
+    if (db.graph == nullptr) {
+        return db;
+    }
 
     const size_t k_elem = ggml_element_size(kv_cache.cross_k);
     const size_t v_elem = ggml_element_size(kv_cache.cross_v);
 
     const int n_layers = static_cast<int>(w.dec_blocks.size());
     for (int il = 0; il < n_layers; ++il) {
-        const auto & blk = w.dec_blocks[il];
-        ggml_tensor * Kc = ggml_mul_mat(ctx, blk.cross_k_w, db.encoder_out_in);
-        ggml_tensor * Vc = ggml_mul_mat(ctx, blk.cross_v_w, db.encoder_out_in);
+        const auto &  blk   = w.dec_blocks[il];
+        ggml_tensor * Kc    = ggml_mul_mat(ctx, blk.cross_k_w, db.encoder_out_in);
+        ggml_tensor * Vc    = ggml_mul_mat(ctx, blk.cross_v_w, db.encoder_out_in);
         // [d_model, T_enc_max, B].
-        const size_t off_k = k_elem * static_cast<size_t>(il) * T_enc_max * d_model * B;
-        const size_t off_v = v_elem * static_cast<size_t>(il) * T_enc_max * d_model * B;
-        ggml_tensor * k_dst = ggml_view_3d(ctx, kv_cache.cross_k,
-            d_model, T_enc_max, B, k_elem * d_model, k_elem * d_model * T_enc_max, off_k);
-        ggml_tensor * v_dst = ggml_view_3d(ctx, kv_cache.cross_v,
-            d_model, T_enc_max, B, v_elem * d_model, v_elem * d_model * T_enc_max, off_v);
+        const size_t  off_k = k_elem * static_cast<size_t>(il) * T_enc_max * d_model * B;
+        const size_t  off_v = v_elem * static_cast<size_t>(il) * T_enc_max * d_model * B;
+        ggml_tensor * k_dst = ggml_view_3d(ctx, kv_cache.cross_k, d_model, T_enc_max, B, k_elem * d_model,
+                                           k_elem * d_model * T_enc_max, off_k);
+        ggml_tensor * v_dst = ggml_view_3d(ctx, kv_cache.cross_v, d_model, T_enc_max, B, v_elem * d_model,
+                                           v_elem * d_model * T_enc_max, off_v);
         ggml_build_forward_expand(db.graph, ggml_cpy(ctx, Kc, k_dst));
         ggml_build_forward_expand(db.graph, ggml_cpy(ctx, Vc, v_dst));
     }
@@ -952,12 +878,13 @@ StepBuildBatched build_step_graph_batched(ggml_context *           ctx,
                                           int                      max_n_kv,
                                           int                      T_enc_max,
                                           int                      n_batch,
-                                          bool                     use_flash)
-{
-    StepBuildBatched sb {};
+                                          bool                     use_flash) {
+    StepBuildBatched sb{};
     sb.max_n_kv = max_n_kv;
     sb.n_batch  = n_batch;
-    if (ctx == nullptr || max_n_kv <= 0 || T_enc_max <= 0 || n_batch <= 0) return sb;
+    if (ctx == nullptr || max_n_kv <= 0 || T_enc_max <= 0 || n_batch <= 0) {
+        return sb;
+    }
     if (!use_flash) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine step(batched): requires flash path");
         return sb;
@@ -968,18 +895,25 @@ StepBuildBatched build_step_graph_batched(ggml_context *           ctx,
     const int B       = n_batch;
 
     sb.token_ids_in = ggml_new_tensor_1d(ctx, GGML_TYPE_I32, B);
-    ggml_set_name(sb.token_ids_in, "step.token_ids"); ggml_set_input(sb.token_ids_in);
+    ggml_set_name(sb.token_ids_in, "step.token_ids");
+    ggml_set_input(sb.token_ids_in);
     sb.pos_ids_in = ggml_new_tensor_1d(ctx, GGML_TYPE_I32, B);
-    ggml_set_name(sb.pos_ids_in, "step.pos_ids"); ggml_set_input(sb.pos_ids_in);
+    ggml_set_name(sb.pos_ids_in, "step.pos_ids");
+    ggml_set_input(sb.pos_ids_in);
     sb.kv_idx_in = ggml_new_tensor_2d(ctx, GGML_TYPE_I64, 1, B);
-    ggml_set_name(sb.kv_idx_in, "step.kv_idx"); ggml_set_input(sb.kv_idx_in);
+    ggml_set_name(sb.kv_idx_in, "step.kv_idx");
+    ggml_set_input(sb.kv_idx_in);
     sb.self_mask_in = ggml_new_tensor_4d(ctx, GGML_TYPE_F16, max_n_kv, 1, 1, B);
-    ggml_set_name(sb.self_mask_in, "step.self_mask"); ggml_set_input(sb.self_mask_in);
+    ggml_set_name(sb.self_mask_in, "step.self_mask");
+    ggml_set_input(sb.self_mask_in);
     sb.cross_mask_in = ggml_new_tensor_4d(ctx, GGML_TYPE_F16, T_enc_max, 1, 1, B);
-    ggml_set_name(sb.cross_mask_in, "step.cross_mask"); ggml_set_input(sb.cross_mask_in);
+    ggml_set_name(sb.cross_mask_in, "step.cross_mask");
+    ggml_set_input(sb.cross_mask_in);
 
     sb.graph = ggml_new_graph_custom(ctx, 16384, false);
-    if (sb.graph == nullptr) return sb;
+    if (sb.graph == nullptr) {
+        return sb;
+    }
 
     ggml_tensor * x = ggml_get_rows(ctx, w.dec_top.token_embd_w, sb.token_ids_in);
 
@@ -988,35 +922,32 @@ StepBuildBatched build_step_graph_batched(ggml_context *           ctx,
         const auto & b = w.dec_blocks[i];
         {
             ggml_tensor * y = layer_norm(ctx, x, b.norm_self_w, /*beta=*/nullptr);
-            y = mha_self_step_batched(
-                ctx, sb.graph, y, kv_cache, sb.pos_ids_in, sb.kv_idx_in, sb.self_mask_in,
-                b.self_q_w, b.self_k_w, b.self_v_w, b.self_out_w,
-                hp, n_heads, d_model, i, max_n_kv, B);
+            y = mha_self_step_batched(ctx, sb.graph, y, kv_cache, sb.pos_ids_in, sb.kv_idx_in, sb.self_mask_in,
+                                      b.self_q_w, b.self_k_w, b.self_v_w, b.self_out_w, hp, n_heads, d_model, i,
+                                      max_n_kv, B);
             x = ggml_add(ctx, x, y);
         }
         {
             ggml_tensor * y = layer_norm(ctx, x, b.norm_cross_w, /*beta=*/nullptr);
-            y = mha_cross_step_batched(
-                ctx, y, kv_cache, sb.cross_mask_in, b.cross_q_w, b.cross_out_w,
-                hp, n_heads, d_model, i, T_enc_max, B);
+            y = mha_cross_step_batched(ctx, y, kv_cache, sb.cross_mask_in, b.cross_q_w, b.cross_out_w, hp, n_heads,
+                                       d_model, i, T_enc_max, B);
             x = ggml_add(ctx, x, y);
         }
         {
             ggml_tensor * y = layer_norm(ctx, x, b.norm_ffn_w, /*beta=*/nullptr);
-            y = ffn_decoder_swiglu(ctx, y, b.ffn_fc1_w, b.ffn_fc1_b,
-                                   b.ffn_fc2_w, b.ffn_fc2_b, hp.dec_ffn_dim);
+            y = ffn_decoder_swiglu(ctx, y, b.ffn_fc1_w, b.ffn_fc1_b, b.ffn_fc2_w, b.ffn_fc2_b, hp.dec_ffn_dim);
             x = ggml_add(ctx, x, y);
         }
     }
 
-    x = layer_norm(ctx, x, w.dec_top.final_norm_w, /*beta=*/nullptr);
+    x                    = layer_norm(ctx, x, w.dec_top.final_norm_w, /*beta=*/nullptr);
     ggml_tensor * logits = ggml_mul_mat(ctx, w.dec_top.token_embd_w, x);  // tied head
 
-    sb.argmax_out = ggml_argmax(ctx, logits);  // [B]
+    sb.argmax_out = ggml_argmax(ctx, logits);                             // [B]
     ggml_set_name(sb.argmax_out, "step.argmax");
     ggml_set_output(sb.argmax_out);
     ggml_build_forward_expand(sb.graph, sb.argmax_out);
     return sb;
 }
 
-} // namespace transcribe::moonshine
+}  // namespace transcribe::moonshine
diff --git a/src/arch/moonshine/decoder.h b/src/arch/moonshine/decoder.h
index 07ace35f..e9ebf3c7 100644
--- a/src/arch/moonshine/decoder.h
+++ b/src/arch/moonshine/decoder.h
@@ -35,12 +35,12 @@ struct MoonshineWeights;
 struct MoonshineKvCache;
 
 struct DecoderDumps {
-    ggml_tensor * token_emb       = nullptr;   // dec.token_emb
-    ggml_tensor * embed_sum       = nullptr;   // dec.embed_sum (= token_emb)
-    std::vector<ggml_tensor *> block_outs;     // dec.block.{i}.out
-    ggml_tensor * out_before_head = nullptr;   // dec.out_before_head
-    ggml_tensor * logits_raw      = nullptr;   // dec.logits_raw
-    ggml_tensor * logits          = nullptr;   // dec.logits (log_softmax)
+    ggml_tensor *              token_emb = nullptr;        // dec.token_emb
+    ggml_tensor *              embed_sum = nullptr;        // dec.embed_sum (= token_emb)
+    std::vector<ggml_tensor *> block_outs;                 // dec.block.{i}.out
+    ggml_tensor *              out_before_head = nullptr;  // dec.out_before_head
+    ggml_tensor *              logits_raw      = nullptr;  // dec.logits_raw
+    ggml_tensor *              logits          = nullptr;  // dec.logits (log_softmax)
 };
 
 struct DecoderBuild {
@@ -49,10 +49,10 @@ struct DecoderBuild {
     ggml_tensor * encoder_out_in = nullptr;  // [d_model, T_enc] f32 (cross_kv graph only)
     ggml_tensor * causal_mask_in = nullptr;  // [n_kv, n_tokens] f32 (n_tokens>1 only)
 
-    ggml_tensor * out         = nullptr;     // logits or log-softmax depending on flag
-    ggml_tensor * argmax_out  = nullptr;     // [n_tokens] i32, set when skip_log_softmax
+    ggml_tensor * out        = nullptr;      // logits or log-softmax depending on flag
+    ggml_tensor * argmax_out = nullptr;      // [n_tokens] i32, set when skip_log_softmax
 
-    DecoderDumps  dumps {};
+    DecoderDumps  dumps{};
     ggml_cgraph * graph = nullptr;
 };
 
@@ -149,4 +149,4 @@ StepBuildBatched build_step_graph_batched(ggml_context *           ctx,
                                           int                      n_batch,
                                           bool                     use_flash = true);
 
-} // namespace transcribe::moonshine
+}  // namespace transcribe::moonshine
diff --git a/src/arch/moonshine/encoder.cpp b/src/arch/moonshine/encoder.cpp
index d7996152..ad4b1e54 100644
--- a/src/arch/moonshine/encoder.cpp
+++ b/src/arch/moonshine/encoder.cpp
@@ -12,33 +12,31 @@
 
 #include "encoder.h"
 
-#include "moonshine.h"
-#include "weights.h"
-
 #include "conformer/conformer.h"
+#include "ggml.h"
+#include "moonshine.h"
 #include "transcribe-debug.h"
 #include "transcribe-log.h"
-
-#include "ggml.h"
+#include "weights.h"
 
 #include <cmath>
-#include <cstdlib>
 #include <cstdio>
+#include <cstdlib>
 
 namespace transcribe::moonshine {
 
 namespace {
 
 namespace conf = transcribe::conformer;
-using conf::named;
 using conf::layer_norm;
+using conf::named;
 
-ggml_tensor * add_conv1d_bias(ggml_context * ctx,
-                              ggml_tensor *  conv_out,
-                              ggml_tensor *  bias_1d) {
-    if (bias_1d == nullptr) return conv_out;
+ggml_tensor * add_conv1d_bias(ggml_context * ctx, ggml_tensor * conv_out, ggml_tensor * bias_1d) {
+    if (bias_1d == nullptr) {
+        return conv_out;
+    }
     const int64_t channels = bias_1d->ne[0];
-    ggml_tensor * bias_4d = ggml_reshape_4d(ctx, bias_1d, 1, channels, 1, 1);
+    ggml_tensor * bias_4d  = ggml_reshape_4d(ctx, bias_1d, 1, channels, 1, 1);
     return ggml_add(ctx, conv_out, bias_4d);
 }
 
@@ -52,17 +50,13 @@ ggml_tensor * apply_partial_rope(ggml_context *           ctx,
                                  const MoonshineHParams & hp,
                                  int                      head_dim_rot,
                                  int                      n_ctx_orig) {
-    return ggml_rope_ext(
-        ctx, x, positions, /*c=*/nullptr,
-        head_dim_rot,
-        GGML_ROPE_TYPE_NORMAL,
-        n_ctx_orig,
-        hp.rope_theta,
-        /*freq_scale=*/1.0f,
-        /*ext_factor=*/0.0f,
-        /*attn_factor=*/1.0f,
-        /*beta_fast=*/32.0f,
-        /*beta_slow=*/1.0f);
+    return ggml_rope_ext(ctx, x, positions, /*c=*/nullptr, head_dim_rot, GGML_ROPE_TYPE_NORMAL, n_ctx_orig,
+                         hp.rope_theta,
+                         /*freq_scale=*/1.0f,
+                         /*ext_factor=*/0.0f,
+                         /*attn_factor=*/1.0f,
+                         /*beta_fast=*/32.0f,
+                         /*beta_slow=*/1.0f);
 }
 
 // Encoder MHSA with partial RoPE on q/k and head_dim padding.
@@ -80,8 +74,7 @@ ggml_tensor * mha_encoder(ggml_context *           ctx,
                           const MoonshineHParams & hp,
                           int                      n_heads,
                           int                      d_model,
-                          bool                     use_flash)
-{
+                          bool                     use_flash) {
     const int     head_dim     = d_model / n_heads;
     const int     head_dim_pad = hp.enc_head_dim_padded();
     const int     head_dim_rot = hp.enc_head_dim_rot();
@@ -111,7 +104,7 @@ ggml_tensor * mha_encoder(ggml_context *           ctx,
     // Permute to [head_dim, T, n_heads, 1] then make contiguous and
     // pad axis 0 (head_dim) to head_dim_padded if required.
     auto to_attn_layout = [&](ggml_tensor * t) -> ggml_tensor * {
-        t = ggml_permute(ctx, t, 0, 2, 1, 3);   // [head_dim, T, n_heads, 1]
+        t = ggml_permute(ctx, t, 0, 2, 1, 3);  // [head_dim, T, n_heads, 1]
         t = ggml_cont(ctx, t);
         if (pad > 0) {
             t = ggml_pad(ctx, t, pad, 0, 0, 0);
@@ -124,8 +117,7 @@ ggml_tensor * mha_encoder(ggml_context *           ctx,
 
     ggml_tensor * o;
     if (use_flash) {
-        o = ggml_flash_attn_ext(ctx, q, k, v, /*mask=*/nullptr,
-                                scale, 0.0f, 0.0f);
+        o = ggml_flash_attn_ext(ctx, q, k, v, /*mask=*/nullptr, scale, 0.0f, 0.0f);
         // ggml_flash_attn_ext output: [head_dim_pad, n_heads, T, 1]
         // (reduces along the K sequence axis). Rearrange to
         // [head_dim_pad, T, n_heads, 1] for the slice-and-merge below.
@@ -133,19 +125,16 @@ ggml_tensor * mha_encoder(ggml_context *           ctx,
         o = ggml_cont(ctx, o);
     } else {
         ggml_tensor * kq      = ggml_mul_mat(ctx, k, q);
-        ggml_tensor * kq_soft = ggml_soft_max_ext(ctx, kq, /*mask=*/nullptr,
-                                                  scale, 0.0f);
-        ggml_tensor * v_t = ggml_cont(ctx, ggml_permute(ctx, v, 1, 0, 2, 3));
-        o = ggml_mul_mat(ctx, v_t, kq_soft);
+        ggml_tensor * kq_soft = ggml_soft_max_ext(ctx, kq, /*mask=*/nullptr, scale, 0.0f);
+        ggml_tensor * v_t     = ggml_cont(ctx, ggml_permute(ctx, v, 1, 0, 2, 3));
+        o                     = ggml_mul_mat(ctx, v_t, kq_soft);
         // o shape: [head_dim_pad, T, n_heads, 1]
     }
 
     // Slice off head_dim padding before merging heads (HF slices
     // [..., :head_dim] before the n_heads*head_dim merge).
     if (pad > 0) {
-        o = ggml_view_3d(ctx, o,
-                         head_dim, T, n_heads,
-                         o->nb[1], o->nb[2], 0);
+        o = ggml_view_3d(ctx, o, head_dim, T, n_heads, o->nb[1], o->nb[2], 0);
         o = ggml_cont(ctx, o);
     }
 
@@ -161,14 +150,19 @@ ggml_tensor * mha_encoder(ggml_context *           ctx,
 // Encoder MLP: fc1 (with bias) -> GELU(erf) -> fc2 (with bias).
 ggml_tensor * ffn_encoder(ggml_context * ctx,
                           ggml_tensor *  x,
-                          ggml_tensor *  fc1_w, ggml_tensor * fc1_b,
-                          ggml_tensor *  fc2_w, ggml_tensor * fc2_b)
-{
+                          ggml_tensor *  fc1_w,
+                          ggml_tensor *  fc1_b,
+                          ggml_tensor *  fc2_w,
+                          ggml_tensor *  fc2_b) {
     ggml_tensor * h = ggml_mul_mat(ctx, fc1_w, x);
-    if (fc1_b != nullptr) h = ggml_add(ctx, h, fc1_b);
-    h = ggml_gelu_erf(ctx, h);
+    if (fc1_b != nullptr) {
+        h = ggml_add(ctx, h, fc1_b);
+    }
+    h               = ggml_gelu_erf(ctx, h);
     ggml_tensor * o = ggml_mul_mat(ctx, fc2_w, h);
-    if (fc2_b != nullptr) o = ggml_add(ctx, o, fc2_b);
+    if (fc2_b != nullptr) {
+        o = ggml_add(ctx, o, fc2_b);
+    }
     return o;
 }
 
@@ -179,21 +173,17 @@ ggml_tensor * build_block(ggml_context *            ctx,
                           const MoonshineHParams &  hp,
                           int                       n_heads,
                           int                       d_model,
-                          bool                      use_flash)
-{
+                          bool                      use_flash) {
     {
         ggml_tensor * y = layer_norm(ctx, x, b.norm_attn_w, /*beta=*/nullptr);
-        y = mha_encoder(ctx, y, pos_ids,
-                        b.attn_q_w, b.attn_k_w, b.attn_v_w, b.attn_out_w,
-                        hp, n_heads, d_model, use_flash);
+        y = mha_encoder(ctx, y, pos_ids, b.attn_q_w, b.attn_k_w, b.attn_v_w, b.attn_out_w, hp, n_heads, d_model,
+                        use_flash);
         x = ggml_add(ctx, x, y);
     }
     {
         ggml_tensor * y = layer_norm(ctx, x, b.norm_ffn_w, /*beta=*/nullptr);
-        y = ffn_encoder(ctx, y,
-                        b.ffn_fc1_w, b.ffn_fc1_b,
-                        b.ffn_fc2_w, b.ffn_fc2_b);
-        x = ggml_add(ctx, x, y);
+        y               = ffn_encoder(ctx, y, b.ffn_fc1_w, b.ffn_fc1_b, b.ffn_fc2_w, b.ffn_fc2_b);
+        x               = ggml_add(ctx, x, y);
     }
     return x;
 }
@@ -201,26 +191,27 @@ ggml_tensor * build_block(ggml_context *            ctx,
 // Number of frames after a single Conv1d layer with no padding:
 //   T_out = floor((T_in - K) / stride) + 1
 int conv1d_t_out(int T_in, int K, int stride) {
-    if (T_in < K) return 0;
+    if (T_in < K) {
+        return 0;
+    }
     return (T_in - K) / stride + 1;
 }
 
-} // namespace
+}  // namespace
 
 int encoder_t_enc(const MoonshineHParams & hp, int n_samples) {
-    if (n_samples <= 0 ||
-        hp.conv_kernel_sizes.size() < 3 || hp.conv_strides.size() < 3)
-    {
+    if (n_samples <= 0 || hp.conv_kernel_sizes.size() < 3 || hp.conv_strides.size() < 3) {
+        return 0;
+    }
+    const int t1 = conv1d_t_out(n_samples, hp.conv_kernel_sizes[0], hp.conv_strides[0]);
+    if (t1 <= 0) {
         return 0;
     }
-    const int t1 = conv1d_t_out(n_samples,
-                                hp.conv_kernel_sizes[0], hp.conv_strides[0]);
-    if (t1 <= 0) return 0;
-    const int t2 = conv1d_t_out(t1,
-                                hp.conv_kernel_sizes[1], hp.conv_strides[1]);
-    if (t2 <= 0) return 0;
-    const int t3 = conv1d_t_out(t2,
-                                hp.conv_kernel_sizes[2], hp.conv_strides[2]);
+    const int t2 = conv1d_t_out(t1, hp.conv_kernel_sizes[1], hp.conv_strides[1]);
+    if (t2 <= 0) {
+        return 0;
+    }
+    const int t3 = conv1d_t_out(t2, hp.conv_kernel_sizes[2], hp.conv_strides[2]);
     return t3;
 }
 
@@ -228,14 +219,12 @@ EncoderBuild build_encoder_graph(ggml_context *           ctx,
                                  const MoonshineWeights & w,
                                  const MoonshineHParams & hp,
                                  int                      n_samples,
-                                 bool                     use_flash)
-{
-    EncoderBuild eb {};
+                                 bool                     use_flash) {
+    EncoderBuild eb{};
 
     if (ctx == nullptr || n_samples <= 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine encoder: invalid arg (ctx=%p, n_samples=%d)",
-                     static_cast<void *>(ctx), n_samples);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine encoder: invalid arg (ctx=%p, n_samples=%d)",
+                static_cast<void *>(ctx), n_samples);
         return eb;
     }
 
@@ -245,14 +234,17 @@ EncoderBuild build_encoder_graph(ggml_context *           ctx,
 
     if (T_enc <= 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine encoder: input too short (n_samples=%d "
-                     "produces T_enc<=0)", n_samples);
+                "moonshine encoder: input too short (n_samples=%d "
+                "produces T_enc<=0)",
+                n_samples);
         return eb;
     }
 
     // ---- audio input ----
     eb.audio_in = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, n_samples);
-    if (eb.audio_in == nullptr) return eb;
+    if (eb.audio_in == nullptr) {
+        return eb;
+    }
     named(eb.audio_in, "enc.audio.in");
     ggml_set_input(eb.audio_in);
     eb.dumps.audio_in = eb.audio_in;
@@ -289,10 +281,10 @@ EncoderBuild build_encoder_graph(ggml_context *           ctx,
     {
         const int64_t C  = w.enc_stem.gn_w->ne[0];
         const int64_t T1 = x->ne[1];
-        x = ggml_reshape_4d(ctx, x, /*ne0=*/C, /*ne1=*/T1, /*ne2=*/1, /*ne3=*/1);
-        x = ggml_group_norm(ctx, x, /*n_groups=*/hp.conv_groupnorm_num_groups,
-                            /*eps=*/hp.conv_groupnorm_eps);
-        x = ggml_reshape_2d(ctx, x, C, T1);
+        x                = ggml_reshape_4d(ctx, x, /*ne0=*/C, /*ne1=*/T1, /*ne2=*/1, /*ne3=*/1);
+        x                = ggml_group_norm(ctx, x, /*n_groups=*/hp.conv_groupnorm_num_groups,
+                                           /*eps=*/hp.conv_groupnorm_eps);
+        x                = ggml_reshape_2d(ctx, x, C, T1);
     }
     x = ggml_mul(ctx, x, w.enc_stem.gn_w);
     x = ggml_add(ctx, x, w.enc_stem.gn_b);
@@ -334,8 +326,7 @@ EncoderBuild build_encoder_graph(ggml_context *           ctx,
     const int n_blocks = static_cast<int>(w.enc_blocks.size());
     eb.dumps.block_outs.reserve(static_cast<size_t>(n_blocks));
     for (int i = 0; i < n_blocks; ++i) {
-        x = build_block(ctx, x, eb.pos_ids_in, w.enc_blocks[i], hp,
-                        n_heads, d_model, use_flash);
+        x = build_block(ctx, x, eb.pos_ids_in, w.enc_blocks[i], hp, n_heads, d_model, use_flash);
 
         char bname[64];
         std::snprintf(bname, sizeof(bname), "enc.block.%d.out", i);
@@ -356,8 +347,7 @@ EncoderBuild build_encoder_graph(ggml_context *           ctx,
 
     eb.graph = ggml_new_graph_custom(ctx, 8192, false);
     if (eb.graph == nullptr) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine encoder: ggml_new_graph_custom failed");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine encoder: ggml_new_graph_custom failed");
         return eb;
     }
     ggml_build_forward_expand(eb.graph, eb.out);
@@ -365,4 +355,4 @@ EncoderBuild build_encoder_graph(ggml_context *           ctx,
     return eb;
 }
 
-} // namespace transcribe::moonshine
+}  // namespace transcribe::moonshine
diff --git a/src/arch/moonshine/encoder.h b/src/arch/moonshine/encoder.h
index 4f52141e..2388d56f 100644
--- a/src/arch/moonshine/encoder.h
+++ b/src/arch/moonshine/encoder.h
@@ -28,15 +28,15 @@ struct MoonshineHParams;
 struct MoonshineWeights;
 
 struct EncoderDumps {
-    ggml_tensor * audio_in     = nullptr;
-    ggml_tensor * conv1_out    = nullptr;   // tanh(conv0(audio))
-    ggml_tensor * groupnorm_out = nullptr;
-    ggml_tensor * conv2_out    = nullptr;   // gelu(conv1(.))
-    ggml_tensor * conv3_out    = nullptr;   // gelu(conv2(.)) (block input)
-    ggml_tensor * rope_cos     = nullptr;
-    ggml_tensor * rope_sin     = nullptr;
+    ggml_tensor *              audio_in      = nullptr;
+    ggml_tensor *              conv1_out     = nullptr;  // tanh(conv0(audio))
+    ggml_tensor *              groupnorm_out = nullptr;
+    ggml_tensor *              conv2_out     = nullptr;  // gelu(conv1(.))
+    ggml_tensor *              conv3_out     = nullptr;  // gelu(conv2(.)) (block input)
+    ggml_tensor *              rope_cos      = nullptr;
+    ggml_tensor *              rope_sin      = nullptr;
     std::vector<ggml_tensor *> block_outs;
-    ggml_tensor * final_out    = nullptr;
+    ggml_tensor *              final_out = nullptr;
 };
 
 struct EncoderBuild {
@@ -53,7 +53,7 @@ struct EncoderBuild {
     // Output: final encoder hidden state [d_model, T_enc] f32.
     ggml_tensor * out = nullptr;
 
-    EncoderDumps  dumps {};
+    EncoderDumps  dumps{};
     ggml_cgraph * graph = nullptr;
 
     // Number of encoder frames produced for the supplied n_samples.
@@ -79,4 +79,4 @@ EncoderBuild build_encoder_graph(ggml_context *           compute_ctx,
                                  int                      n_samples,
                                  bool                     use_flash = true);
 
-} // namespace transcribe::moonshine
+}  // namespace transcribe::moonshine
diff --git a/src/arch/moonshine/model.cpp b/src/arch/moonshine/model.cpp
index dde59f6b..13e26f3d 100644
--- a/src/arch/moonshine/model.cpp
+++ b/src/arch/moonshine/model.cpp
@@ -5,12 +5,13 @@
 // `do_sample=False, num_beams=1, max_length=194`; there are no
 // suppress_tokens, no language tokens, no temperature fallback.
 
-#include "moonshine.h"
-
 #include "decoder.h"
 #include "encoder.h"
-#include "weights.h"
-
+#include "ggml-alloc.h"
+#include "ggml-backend.h"
+#include "ggml.h"
+#include "gguf.h"
+#include "moonshine.h"
 #include "transcribe-arch.h"
 #include "transcribe-batch-util.h"
 #include "transcribe-debug.h"
@@ -20,11 +21,7 @@
 #include "transcribe-loader.h"
 #include "transcribe-log.h"
 #include "transcribe-meta.h"
-
-#include "ggml.h"
-#include "ggml-alloc.h"
-#include "ggml-backend.h"
-#include "gguf.h"
+#include "weights.h"
 
 #include <algorithm>
 #include <cmath>
@@ -42,7 +39,7 @@ namespace transcribe::moonshine {
 
 extern const Arch arch;
 
-static_assert(std::is_base_of_v<transcribe_model,   MoonshineModel>);
+static_assert(std::is_base_of_v<transcribe_model, MoonshineModel>);
 static_assert(std::is_base_of_v<transcribe_session, MoonshineSession>);
 
 MoonshineSession::~MoonshineSession() {
@@ -66,9 +63,7 @@ MoonshineModel::~MoonshineModel() {
         ggml_backend_buffer_free(backend_buffer);
         backend_buffer = nullptr;
     }
-    for (auto it = plan.scheduler_list.rbegin();
-         it != plan.scheduler_list.rend(); ++it)
-    {
+    for (auto it = plan.scheduler_list.rbegin(); it != plan.scheduler_list.rend(); ++it) {
         ggml_backend_free(*it);
     }
     plan.scheduler_list.clear();
@@ -87,12 +82,12 @@ MoonshineModel::~MoonshineModel() {
 // (dec_max_position_embeddings tokens) covers at ~4 output tokens/sec (~48 s
 // for 194 tokens). 0 means unknown/unbounded. Advisory only — does not reject.
 constexpr int k_tokens_per_sec = 4;  // rough speech-rate estimate; advisory only
+
 int64_t moonshine_max_audio_ms(const MoonshineHParams & hp) {
     if (hp.dec_max_position_embeddings <= 0) {
         return 0;
     }
-    return static_cast<int64_t>(hp.dec_max_position_embeddings) * 1000 /
-           k_tokens_per_sec;
+    return static_cast<int64_t>(hp.dec_max_position_embeddings) * 1000 / k_tokens_per_sec;
 }
 
 // KV cache initialization.
@@ -102,17 +97,17 @@ bool kv_cache_init(MoonshineKvCache & cache,
                    int                T_enc,
                    int                d_model,
                    int                n_layer,
-                   ggml_type          kv_type)
-{
+                   ggml_type          kv_type) {
     if (kv_type != GGML_TYPE_F16 && kv_type != GGML_TYPE_F32) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine kv_cache: unsupported kv_type=%d "
-                     "(only F16/F32)", static_cast<int>(kv_type));
+                "moonshine kv_cache: unsupported kv_type=%d "
+                "(only F16/F32)",
+                static_cast<int>(kv_type));
         return false;
     }
 
-    const size_t ctx_size = 4 * ggml_tensor_overhead() + 256;
-    ggml_init_params params { ctx_size, nullptr, /*no_alloc=*/true };
+    const size_t     ctx_size = 4 * ggml_tensor_overhead() + 256;
+    ggml_init_params params{ ctx_size, nullptr, /*no_alloc=*/true };
     cache.ctx = ggml_init(params);
     if (cache.ctx == nullptr) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine kv_cache: ggml_init failed");
@@ -127,8 +122,8 @@ bool kv_cache_init(MoonshineKvCache & cache,
     cache.cross_k = ggml_new_tensor_1d(cache.ctx, kv_type, cross_elements);
     cache.cross_v = ggml_new_tensor_1d(cache.ctx, kv_type, cross_elements);
 
-    ggml_set_name(cache.self_k,  "kv_self_k");
-    ggml_set_name(cache.self_v,  "kv_self_v");
+    ggml_set_name(cache.self_k, "kv_self_k");
+    ggml_set_name(cache.self_v, "kv_self_v");
     ggml_set_name(cache.cross_k, "kv_cross_k");
     ggml_set_name(cache.cross_v, "kv_cross_v");
 
@@ -157,11 +152,11 @@ bool kv_cache_init_batched(MoonshineKvCache & cache,
                            int                d_model,
                            int                n_layer,
                            int                n_batch,
-                           ggml_type          kv_type)
-{
+                           ggml_type          kv_type) {
     if (n_batch <= 1) {
-        if (!kv_cache_init(cache, backend, n_ctx, T_enc, d_model, n_layer, kv_type))
+        if (!kv_cache_init(cache, backend, n_ctx, T_enc, d_model, n_layer, kv_type)) {
             return false;
+        }
         cache.n_batch = 1;
         return true;
     }
@@ -169,31 +164,37 @@ bool kv_cache_init_batched(MoonshineKvCache & cache,
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine kv_cache(batched): unsupported kv_type");
         return false;
     }
-    const size_t ctx_size = 4 * ggml_tensor_overhead() + 256;
-    ggml_init_params params { ctx_size, nullptr, /*no_alloc=*/true };
+    const size_t     ctx_size = 4 * ggml_tensor_overhead() + 256;
+    ggml_init_params params{ ctx_size, nullptr, /*no_alloc=*/true };
     cache.ctx = ggml_init(params);
-    if (cache.ctx == nullptr) return false;
+    if (cache.ctx == nullptr) {
+        return false;
+    }
 
-    const int64_t self_elements =
-        static_cast<int64_t>(d_model) * n_layer * n_ctx * n_batch;
-    const int64_t cross_elements =
-        static_cast<int64_t>(d_model) * n_layer * T_enc * n_batch;
-    cache.self_k  = ggml_new_tensor_1d(cache.ctx, kv_type, self_elements);
-    cache.self_v  = ggml_new_tensor_1d(cache.ctx, kv_type, self_elements);
-    cache.cross_k = ggml_new_tensor_1d(cache.ctx, kv_type, cross_elements);
-    cache.cross_v = ggml_new_tensor_1d(cache.ctx, kv_type, cross_elements);
-    ggml_set_name(cache.self_k,  "kv_self_k");
-    ggml_set_name(cache.self_v,  "kv_self_v");
+    const int64_t self_elements  = static_cast<int64_t>(d_model) * n_layer * n_ctx * n_batch;
+    const int64_t cross_elements = static_cast<int64_t>(d_model) * n_layer * T_enc * n_batch;
+    cache.self_k                 = ggml_new_tensor_1d(cache.ctx, kv_type, self_elements);
+    cache.self_v                 = ggml_new_tensor_1d(cache.ctx, kv_type, self_elements);
+    cache.cross_k                = ggml_new_tensor_1d(cache.ctx, kv_type, cross_elements);
+    cache.cross_v                = ggml_new_tensor_1d(cache.ctx, kv_type, cross_elements);
+    ggml_set_name(cache.self_k, "kv_self_k");
+    ggml_set_name(cache.self_v, "kv_self_v");
     ggml_set_name(cache.cross_k, "kv_cross_k");
     ggml_set_name(cache.cross_v, "kv_cross_v");
 
     cache.buffer = ggml_backend_alloc_ctx_tensors(cache.ctx, backend);
     if (cache.buffer == nullptr) {
-        ggml_free(cache.ctx); cache.ctx = nullptr; return false;
+        ggml_free(cache.ctx);
+        cache.ctx = nullptr;
+        return false;
     }
     ggml_backend_buffer_clear(cache.buffer, 0);
-    cache.n_ctx = n_ctx; cache.T_enc = T_enc; cache.n = 0; cache.head = 0;
-    cache.n_batch = n_batch; cache.cross_populated = false;
+    cache.n_ctx           = n_ctx;
+    cache.T_enc           = T_enc;
+    cache.n               = 0;
+    cache.head            = 0;
+    cache.n_batch         = n_batch;
+    cache.cross_populated = false;
     return true;
 }
 
@@ -201,114 +202,104 @@ namespace {
 
 constexpr const char k_default_variant[] = "moonshine";
 
-extern transcribe_status load        (Loader &, const transcribe_model_load_params *,
-                                      transcribe_model **);
-extern transcribe_status init_context(transcribe_model *, const transcribe_session_params *,
-                                      transcribe_session **);
-extern transcribe_status run         (transcribe_session *, const float *, int,
-                                      const transcribe_run_params *);
-
-transcribe_status load(
-    Loader &                          loader,
-    const transcribe_model_load_params *   params,
-    transcribe_model **               out_model)
-{
+extern transcribe_status load(Loader &, const transcribe_model_load_params *, transcribe_model **);
+extern transcribe_status init_context(transcribe_model *, const transcribe_session_params *, transcribe_session **);
+extern transcribe_status run(transcribe_session *, const float *, int, const transcribe_run_params *);
+
+transcribe_status load(Loader & loader, const transcribe_model_load_params * params, transcribe_model ** out_model) {
     const int64_t t_load_start = ggml_time_us();
 
-    auto m = std::make_unique<MoonshineModel>();
+    auto m       = std::make_unique<MoonshineModel>();
     m->arch      = &arch;
     m->t_load_us = 0;
 
-    m->variant = loader.variant().empty() ? k_default_variant
-                                          : loader.variant();
+    m->variant = loader.variant().empty() ? k_default_variant : loader.variant();
     m->backend.clear();
 
     apply_family_invariants(*m);
     m->caps.n_languages = 0;
     m->caps.languages   = nullptr;
 
-    if (auto st = read_capability_kv(loader.gguf(), m->caps); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_languages_kv (loader.gguf(), *m);       st != TRANSCRIBE_OK) return st;
+    if (auto st = read_capability_kv(loader.gguf(), m->caps); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_languages_kv(loader.gguf(), *m); st != TRANSCRIBE_OK) {
+        return st;
+    }
 
-    if (auto st = m->tok.load(loader.gguf());                 st != TRANSCRIBE_OK) return st;
-    if (auto st = read_moonshine_hparams(loader.gguf(), m->hparams); st != TRANSCRIBE_OK) return st;
+    if (auto st = m->tok.load(loader.gguf()); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_moonshine_hparams(loader.gguf(), m->hparams); st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Publish the advisory window now that the decoder position cap is known
     // (first point it's available after hparams).
     m->caps.max_audio_ms = moonshine_max_audio_ms(m->hparams);
 
     // Reopen GGUF with no_alloc to wire weight slots.
-    gguf_init_params init_params {};
-    init_params.no_alloc = true;
-    init_params.ctx      = &m->ctx_meta;
+    gguf_init_params init_params{};
+    init_params.no_alloc     = true;
+    init_params.ctx          = &m->ctx_meta;
     gguf_context * gguf_data = gguf_init_from_file(loader.path().c_str(), init_params);
-    if (gguf_data == nullptr) return TRANSCRIBE_ERR_GGUF;
+    if (gguf_data == nullptr) {
+        return TRANSCRIBE_ERR_GGUF;
+    }
 
-    if (auto st = build_moonshine_weights(m->ctx_meta, m->hparams, m->weights);
-        st != TRANSCRIBE_OK)
-    {
+    if (auto st = build_moonshine_weights(m->ctx_meta, m->hparams, m->weights); st != TRANSCRIBE_OK) {
         gguf_free(gguf_data);
         return st;
     }
 
-    const transcribe_backend_request backend_req =
-        (params != nullptr) ? params->backend : TRANSCRIBE_BACKEND_AUTO;
-    if (auto st = transcribe::load_common::init_backends(
-            backend_req, (params != nullptr) ? params->gpu_device : 0, "moonshine", m->plan); st != TRANSCRIBE_OK)
-    {
+    const transcribe_backend_request backend_req = (params != nullptr) ? params->backend : TRANSCRIBE_BACKEND_AUTO;
+    if (auto st = transcribe::load_common::init_backends(backend_req, (params != nullptr) ? params->gpu_device : 0,
+                                                         "moonshine", m->plan);
+        st != TRANSCRIBE_OK) {
         gguf_free(gguf_data);
         return st;
     }
-    m->backend = ggml_backend_name(m->plan.primary);
+    m->backend         = ggml_backend_name(m->plan.primary);
     m->primary_backend = m->plan.primary;
 
-    ggml_backend_buffer_t weights_buffer =
-        ggml_backend_alloc_ctx_tensors(m->ctx_meta, m->plan.primary);
+    ggml_backend_buffer_t weights_buffer = ggml_backend_alloc_ctx_tensors(m->ctx_meta, m->plan.primary);
     if (weights_buffer == nullptr) {
         gguf_free(gguf_data);
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine: ggml_backend_alloc_ctx_tensors failed");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine: ggml_backend_alloc_ctx_tensors failed");
         return TRANSCRIBE_ERR_GGUF;
     }
     m->backend_buffer = weights_buffer;
-    ggml_backend_buffer_set_usage(weights_buffer,
-                                  GGML_BACKEND_BUFFER_USAGE_WEIGHTS);
+    ggml_backend_buffer_set_usage(weights_buffer, GGML_BACKEND_BUFFER_USAGE_WEIGHTS);
 
-    if (auto st = transcribe::load_common::stream_tensor_data(
-            loader.path(), gguf_data, m->ctx_meta, "moonshine");
-        st != TRANSCRIBE_OK)
-    {
+    if (auto st = transcribe::load_common::stream_tensor_data(loader.path(), gguf_data, m->ctx_meta, "moonshine");
+        st != TRANSCRIBE_OK) {
         gguf_free(gguf_data);
         return st;
     }
     gguf_free(gguf_data);
 
     m->t_load_us = ggml_time_us() - t_load_start;
-    *out_model = m.release();
+    *out_model   = m.release();
     return TRANSCRIBE_OK;
 }
 
-transcribe_status init_context(
-    transcribe_model *                model,
-    const transcribe_session_params * params,
-    transcribe_session **             out_ctx)
-{
+transcribe_status init_context(transcribe_model *                model,
+                               const transcribe_session_params * params,
+                               transcribe_session **             out_ctx) {
     if (model->arch != &arch) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
-    auto cc = std::make_unique<MoonshineSession>();
+    auto cc       = std::make_unique<MoonshineSession>();
     cc->model     = model;
     cc->n_threads = params->n_threads;
     cc->kv_type   = params->kv_type;
 
     // See MoonshineSession for why decoder FA is Metal-only-off.
-    auto * cm = static_cast<MoonshineModel *>(model);
-    const bool is_metal =
-        (cm->plan.primary_kind == transcribe::BackendKind::Metal);
+    auto *     cm         = static_cast<MoonshineModel *>(model);
+    const bool is_metal   = (cm->plan.primary_kind == transcribe::BackendKind::Metal);
     cc->encoder_use_flash = true;
     cc->decoder_use_flash = !is_metal;
-    transcribe::flash::apply_env_overrides(
-        cc->encoder_use_flash, cc->decoder_use_flash);
+    transcribe::flash::apply_env_overrides(cc->encoder_use_flash, cc->decoder_use_flash);
 
     *out_ctx = cc.release();
     return TRANSCRIBE_OK;
@@ -324,11 +315,11 @@ bool ensure_compute_ctx(MoonshineSession * cc, size_t mem_size) {
         ggml_free(cc->compute_ctx);
         cc->compute_ctx = nullptr;
     }
-    ggml_init_params init_params {};
+    ggml_init_params init_params{};
     init_params.mem_size   = mem_size;
     init_params.mem_buffer = nullptr;
     init_params.no_alloc   = true;
-    cc->compute_ctx = ggml_init(init_params);
+    cc->compute_ctx        = ggml_init(init_params);
     return cc->compute_ctx != nullptr;
 }
 
@@ -336,21 +327,19 @@ bool ensure_compute_ctx(MoonshineSession * cc, size_t mem_size) {
 // mask input tensor when the prompt pass needs one. Cohere uses the
 // same trick.
 ggml_tensor * find_tensor_by_name(ggml_context * gctx, const char * name) {
-    for (ggml_tensor * t = ggml_get_first_tensor(gctx); t != nullptr;
-         t = ggml_get_next_tensor(gctx, t))
-    {
-        if (std::strcmp(t->name, name) == 0) return t;
+    for (ggml_tensor * t = ggml_get_first_tensor(gctx); t != nullptr; t = ggml_get_next_tensor(gctx, t)) {
+        if (std::strcmp(t->name, name) == 0) {
+            return t;
+        }
     }
     return nullptr;
 }
 
-transcribe_status run(
-    transcribe_session *      session,
-    const float *             pcm,
-    int                       n_samples,
-    const transcribe_run_params * params)
-{
-    (void)params;
+transcribe_status run(transcribe_session *          session,
+                      const float *                 pcm,
+                      int                           n_samples,
+                      const transcribe_run_params * params) {
+    (void) params;
 
     if (session == nullptr || pcm == nullptr || n_samples <= 0) {
         return TRANSCRIBE_ERR_INVALID_ARG;
@@ -360,7 +349,9 @@ transcribe_status run(
     if (cm == nullptr || cm->plan.scheduler_list.empty()) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
-    if (cc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
+    if (cc->poll_abort()) {
+        return TRANSCRIBE_ERR_ABORTED;
+    }
 
     transcribe::debug::init();
     cc->clear_result();
@@ -370,35 +361,36 @@ transcribe_status run(
     // Phase timers. Moonshine has no mel/STFT (raw PCM passthrough), so
     // t_mel_us stays 0; t_encode_us covers encoder graph + cross-KV
     // precompute, t_decode_us covers prompt pass + step loop.
-    cc->t_mel_us    = 0;
-    cc->t_encode_us = 0;
-    cc->t_decode_us = 0;
+    cc->t_mel_us                 = 0;
+    cc->t_encode_us              = 0;
+    cc->t_decode_us              = 0;
     const int64_t t_encode_start = ggml_time_us();
 
     ggml_type resolved_kv = GGML_TYPE_COUNT;
-    if (cc->kv_type == TRANSCRIBE_KV_TYPE_F32) resolved_kv = GGML_TYPE_F32;
-    if (cc->kv_type == TRANSCRIBE_KV_TYPE_F16) resolved_kv = GGML_TYPE_F16;
+    if (cc->kv_type == TRANSCRIBE_KV_TYPE_F32) {
+        resolved_kv = GGML_TYPE_F32;
+    }
+    if (cc->kv_type == TRANSCRIBE_KV_TYPE_F16) {
+        resolved_kv = GGML_TYPE_F16;
+    }
 
     // ----- Encoder: build + compute -----
     if (!ensure_compute_ctx(cc, 8 * 1024 * 1024)) {
         transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "moonshine run: compute context allocation failed (encoder) — "
-            "out of memory.");
+                            "moonshine run: compute context allocation failed (encoder) — "
+                            "out of memory.");
         return TRANSCRIBE_ERR_OOM;
     }
 
-    EncoderBuild eb = build_encoder_graph(
-        cc->compute_ctx, cm->weights, hp, n_samples, cc->encoder_use_flash);
+    EncoderBuild eb = build_encoder_graph(cc->compute_ctx, cm->weights, hp, n_samples, cc->encoder_use_flash);
     if (eb.audio_in == nullptr || eb.out == nullptr || eb.graph == nullptr) {
         return TRANSCRIBE_ERR_GGUF;
     }
     const int T_enc = eb.T_enc;
 
     if (cc->sched == nullptr) {
-        cc->sched = ggml_backend_sched_new(
-            cm->plan.scheduler_list.data(), nullptr,
-            static_cast<int>(cm->plan.scheduler_list.size()),
-            16384, false, true);
+        cc->sched = ggml_backend_sched_new(cm->plan.scheduler_list.data(), nullptr,
+                                           static_cast<int>(cm->plan.scheduler_list.size()), 16384, false, true);
         if (cc->sched == nullptr) {
             log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine run: ggml_backend_sched_new failed");
             return TRANSCRIBE_ERR_GGUF;
@@ -407,17 +399,17 @@ transcribe_status run(
     ggml_backend_sched_reset(cc->sched);
     if (!ggml_backend_sched_alloc_graph(cc->sched, eb.graph)) {
         transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "moonshine run: encoder graph allocation failed — out of memory.");
+                            "moonshine run: encoder graph allocation failed — out of memory.");
         return TRANSCRIBE_ERR_OOM;
     }
 
-    ggml_backend_tensor_set(eb.audio_in, pcm,
-                            0, static_cast<size_t>(n_samples) * sizeof(float));
+    ggml_backend_tensor_set(eb.audio_in, pcm, 0, static_cast<size_t>(n_samples) * sizeof(float));
     {
         std::vector<int32_t> enc_pos_ids(static_cast<size_t>(T_enc));
-        for (int i = 0; i < T_enc; ++i) enc_pos_ids[i] = i;
-        ggml_backend_tensor_set(eb.pos_ids_in, enc_pos_ids.data(), 0,
-                                enc_pos_ids.size() * sizeof(int32_t));
+        for (int i = 0; i < T_enc; ++i) {
+            enc_pos_ids[i] = i;
+        }
+        ggml_backend_tensor_set(eb.pos_ids_in, enc_pos_ids.data(), 0, enc_pos_ids.size() * sizeof(int32_t));
     }
 
     apply_thread_policy(cc);
@@ -428,13 +420,15 @@ transcribe_status run(
     }
 
     auto try_dump = [](const char * name, ggml_tensor * t, const char * stage) {
-        if (t != nullptr) transcribe::debug::dump_tensor(name, t, stage);
+        if (t != nullptr) {
+            transcribe::debug::dump_tensor(name, t, stage);
+        }
     };
-    try_dump("enc.audio.in",      eb.dumps.audio_in,      "encoder.audio.in");
-    try_dump("enc.conv1.out",     eb.dumps.conv1_out,     "encoder.conv1");
+    try_dump("enc.audio.in", eb.dumps.audio_in, "encoder.audio.in");
+    try_dump("enc.conv1.out", eb.dumps.conv1_out, "encoder.conv1");
     try_dump("enc.groupnorm.out", eb.dumps.groupnorm_out, "encoder.groupnorm");
-    try_dump("enc.conv2.out",     eb.dumps.conv2_out,     "encoder.conv2");
-    try_dump("enc.conv3.out",     eb.dumps.conv3_out,     "encoder.conv3");
+    try_dump("enc.conv2.out", eb.dumps.conv2_out, "encoder.conv2");
+    try_dump("enc.conv3.out", eb.dumps.conv3_out, "encoder.conv3");
     for (size_t i = 0; i < eb.dumps.block_outs.size(); ++i) {
         char bname[64], stage[64];
         std::snprintf(bname, sizeof(bname), "enc.block.%zu.out", i);
@@ -446,11 +440,9 @@ transcribe_status run(
     // Read encoder output to host buffer (for re-upload into the
     // cross_kv graph's input tensor — it lives in a fresh compute_ctx).
     const int d_model = hp.dec_d_model;
-    cc->enc_T = T_enc;
-    cc->enc_host.assign(static_cast<size_t>(d_model) *
-                        static_cast<size_t>(T_enc), 0.0f);
-    ggml_backend_tensor_get(eb.out, cc->enc_host.data(), 0,
-                            cc->enc_host.size() * sizeof(float));
+    cc->enc_T         = T_enc;
+    cc->enc_host.assign(static_cast<size_t>(d_model) * static_cast<size_t>(T_enc), 0.0f);
+    ggml_backend_tensor_get(eb.out, cc->enc_host.data(), 0, cc->enc_host.size() * sizeof(float));
 
     // ----- KV cache init -----
     {
@@ -458,17 +450,15 @@ transcribe_status run(
             cc->kv_cache.free();
         }
         if (cc->kv_cache.buffer == nullptr) {
-            const int n_ctx = hp.dec_max_position_embeddings > 0
-                            ? hp.dec_max_position_embeddings : 512;
+            const int n_ctx      = hp.dec_max_position_embeddings > 0 ? hp.dec_max_position_embeddings : 512;
             ggml_type cache_type = resolved_kv;
             // Default the cache to F32 to match moonshine's reference regime.
-            if (cache_type == GGML_TYPE_COUNT) cache_type = GGML_TYPE_F32;
-            if (!kv_cache_init(cc->kv_cache, cm->plan.primary,
-                               n_ctx, T_enc, d_model, hp.dec_n_layers,
-                               cache_type))
-            {
+            if (cache_type == GGML_TYPE_COUNT) {
+                cache_type = GGML_TYPE_F32;
+            }
+            if (!kv_cache_init(cc->kv_cache, cm->plan.primary, n_ctx, T_enc, d_model, hp.dec_n_layers, cache_type)) {
                 transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                    "moonshine run: KV cache allocation failed — out of memory.");
+                                    "moonshine run: KV cache allocation failed — out of memory.");
                 return TRANSCRIBE_ERR_OOM;
             }
         } else {
@@ -482,27 +472,22 @@ transcribe_status run(
     {
         if (!ensure_compute_ctx(cc, 4 * 1024 * 1024)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "moonshine run: compute context allocation failed (cross_kv) — "
-                "out of memory.");
+                                "moonshine run: compute context allocation failed (cross_kv) — "
+                                "out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
-        DecoderBuild cross_db = build_cross_kv_graph(
-            cc->compute_ctx, cm->weights, hp, cc->kv_cache, T_enc);
+        DecoderBuild cross_db = build_cross_kv_graph(cc->compute_ctx, cm->weights, hp, cc->kv_cache, T_enc);
         if (cross_db.graph == nullptr) {
             return TRANSCRIBE_ERR_GGUF;
         }
         ggml_backend_sched_reset(cc->sched);
         if (!ggml_backend_sched_alloc_graph(cc->sched, cross_db.graph)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "moonshine run: cross_kv graph allocation failed — out of memory.");
+                                "moonshine run: cross_kv graph allocation failed — out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
-        ggml_backend_tensor_set(cross_db.encoder_out_in,
-                                cc->enc_host.data(), 0,
-                                cc->enc_host.size() * sizeof(float));
-        if (ggml_backend_sched_graph_compute(cc->sched, cross_db.graph)
-            != GGML_STATUS_SUCCESS)
-        {
+        ggml_backend_tensor_set(cross_db.encoder_out_in, cc->enc_host.data(), 0, cc->enc_host.size() * sizeof(float));
+        if (ggml_backend_sched_graph_compute(cc->sched, cross_db.graph) != GGML_STATUS_SUCCESS) {
             log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine run: cross_kv compute failed");
             return TRANSCRIBE_ERR_GGUF;
         }
@@ -513,61 +498,53 @@ transcribe_status run(
 
     // ----- Greedy decoder loop -----
     const int64_t t_decode_start = ggml_time_us();
-    const int decoder_start = hp.decoder_start_token_id;   // 1
-    const int eos           = hp.eos_token_id;             // 2
-    const int max_pos       = hp.dec_max_position_embeddings;
+    const int     decoder_start  = hp.decoder_start_token_id;  // 1
+    const int     eos            = hp.eos_token_id;            // 2
+    const int     max_pos        = hp.dec_max_position_embeddings;
 
     std::vector<int32_t> generated_ids;
-    int next_token = -1;
-    int n_past     = 0;
+    int                  next_token = -1;
+    int                  n_past     = 0;
 
-    auto run_step = [&](int n_tokens, int n_past_in,
-                        int token_id_first, bool dump_prompt,
-                        const char * mid_gen_dump_name)
-                       -> transcribe_status {
+    auto run_step = [&](int n_tokens, int n_past_in, int token_id_first, bool dump_prompt,
+                        const char * mid_gen_dump_name) -> transcribe_status {
         // Build a fresh compute_ctx + step graph. With dump_prompt=true
         // the graph emits the full log_softmax tensor so the dumper can
         // capture dec.logits; otherwise we skip log_softmax (argmax is
         // invariant) and read raw logits.
         if (!ensure_compute_ctx(cc, 4 * 1024 * 1024)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "moonshine run: compute context allocation failed (step) — "
-                "out of memory.");
+                                "moonshine run: compute context allocation failed (step) — "
+                                "out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
-        const bool skip_log_softmax = !dump_prompt;
-        DecoderBuild db = build_decoder_graph_kv(
-            cc->compute_ctx, cm->weights, hp, cc->kv_cache,
-            n_tokens, n_past_in, T_enc,
-            skip_log_softmax, cc->decoder_use_flash);
+        const bool   skip_log_softmax = !dump_prompt;
+        DecoderBuild db = build_decoder_graph_kv(cc->compute_ctx, cm->weights, hp, cc->kv_cache, n_tokens, n_past_in,
+                                                 T_enc, skip_log_softmax, cc->decoder_use_flash);
         if (db.out == nullptr || db.graph == nullptr) {
             return TRANSCRIBE_ERR_GGUF;
         }
         ggml_backend_sched_reset(cc->sched);
         if (!ggml_backend_sched_alloc_graph(cc->sched, db.graph)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "moonshine run: step graph allocation failed — out of memory.");
+                                "moonshine run: step graph allocation failed — out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
         // Upload tokens + position ids.
         std::vector<int32_t> token_ids(static_cast<size_t>(n_tokens));
-        std::vector<int32_t> pos_ids  (static_cast<size_t>(n_tokens));
+        std::vector<int32_t> pos_ids(static_cast<size_t>(n_tokens));
         for (int i = 0; i < n_tokens; ++i) {
-            token_ids[i] = (i == 0) ? token_id_first
-                                    : 0 /* unused: caller batches one token */;
-            pos_ids  [i] = n_past_in + i;
+            token_ids[i] = (i == 0) ? token_id_first : 0 /* unused: caller batches one token */;
+            pos_ids[i]   = n_past_in + i;
         }
-        ggml_backend_tensor_set(db.token_ids_in, token_ids.data(),
-                                0, token_ids.size() * sizeof(int32_t));
-        ggml_backend_tensor_set(db.pos_ids_in, pos_ids.data(),
-                                0, pos_ids.size() * sizeof(int32_t));
+        ggml_backend_tensor_set(db.token_ids_in, token_ids.data(), 0, token_ids.size() * sizeof(int32_t));
+        ggml_backend_tensor_set(db.pos_ids_in, pos_ids.data(), 0, pos_ids.size() * sizeof(int32_t));
         // Causal mask only when n_tokens > 1 (every step is single-token).
         if (n_tokens > 1) {
             ggml_tensor * m = find_tensor_by_name(cc->compute_ctx, "dec.causal_mask");
             if (m != nullptr) {
-                const int n_kv = n_past_in + n_tokens;
-                std::vector<float> mask(static_cast<size_t>(n_kv) * n_tokens,
-                                        -1e9f);
+                const int          n_kv = n_past_in + n_tokens;
+                std::vector<float> mask(static_cast<size_t>(n_kv) * n_tokens, -1e9f);
                 for (int q = 0; q < n_tokens; ++q) {
                     for (int k = 0; k < n_kv; ++k) {
                         if (k <= q + n_past_in) {
@@ -575,23 +552,18 @@ transcribe_status run(
                         }
                     }
                 }
-                ggml_backend_tensor_set(m, mask.data(), 0,
-                                        mask.size() * sizeof(float));
+                ggml_backend_tensor_set(m, mask.data(), 0, mask.size() * sizeof(float));
             }
         }
 
-        if (ggml_backend_sched_graph_compute(cc->sched, db.graph)
-            != GGML_STATUS_SUCCESS)
-        {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "moonshine run: decoder compute failed (n_past=%d)",
-                         n_past_in);
+        if (ggml_backend_sched_graph_compute(cc->sched, db.graph) != GGML_STATUS_SUCCESS) {
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine run: decoder compute failed (n_past=%d)", n_past_in);
             return TRANSCRIBE_ERR_GGUF;
         }
 
         if (dump_prompt) {
-            try_dump("dec.token_emb",       db.dumps.token_emb,       "decoder.embedding");
-            try_dump("dec.embed_sum",       db.dumps.embed_sum,       "decoder.embed_sum");
+            try_dump("dec.token_emb", db.dumps.token_emb, "decoder.embedding");
+            try_dump("dec.embed_sum", db.dumps.embed_sum, "decoder.embed_sum");
             for (size_t i = 0; i < db.dumps.block_outs.size(); ++i) {
                 char bname[64], stage[64];
                 std::snprintf(bname, sizeof(bname), "dec.block.%zu.out", i);
@@ -599,8 +571,8 @@ transcribe_status run(
                 try_dump(bname, db.dumps.block_outs[i], stage);
             }
             try_dump("dec.out_before_head", db.dumps.out_before_head, "decoder.output_before_head");
-            try_dump("dec.logits_raw",      db.dumps.logits_raw,      "decoder.logits_raw");
-            try_dump("dec.logits",          db.dumps.logits,          "decoder.logits");
+            try_dump("dec.logits_raw", db.dumps.logits_raw, "decoder.logits_raw");
+            try_dump("dec.logits", db.dumps.logits, "decoder.logits");
         } else if (mid_gen_dump_name != nullptr) {
             // Reference dumper writes pre-softmax logits at gen step 20
             // under the name dec.logits_raw.gen20. The C++ step graph's
@@ -614,22 +586,21 @@ transcribe_status run(
         // argmax in C against the downloaded vocab row.
         if (db.argmax_out != nullptr) {
             int32_t argmax_id = 0;
-            ggml_backend_tensor_get(db.argmax_out, &argmax_id,
-                                    0, sizeof(int32_t));
+            ggml_backend_tensor_get(db.argmax_out, &argmax_id, 0, sizeof(int32_t));
             next_token = argmax_id;
         } else {
-            const int64_t vocab_size = db.out->ne[0];
-            const int64_t last_T     = (ggml_n_dims(db.out) == 1) ? 1 : db.out->ne[1];
-            std::vector<float> logits_host(static_cast<size_t>(vocab_size) *
-                                           static_cast<size_t>(last_T));
-            ggml_backend_tensor_get(db.out, logits_host.data(), 0,
-                                    logits_host.size() * sizeof(float));
-            const float * last_logits = logits_host.data() +
-                                        static_cast<size_t>(last_T - 1) * vocab_size;
-            int best_idx = 0;
-            float best_v = last_logits[0];
+            const int64_t      vocab_size = db.out->ne[0];
+            const int64_t      last_T     = (ggml_n_dims(db.out) == 1) ? 1 : db.out->ne[1];
+            std::vector<float> logits_host(static_cast<size_t>(vocab_size) * static_cast<size_t>(last_T));
+            ggml_backend_tensor_get(db.out, logits_host.data(), 0, logits_host.size() * sizeof(float));
+            const float * last_logits = logits_host.data() + static_cast<size_t>(last_T - 1) * vocab_size;
+            int           best_idx    = 0;
+            float         best_v      = last_logits[0];
             for (int j = 1; j < static_cast<int>(vocab_size); ++j) {
-                if (last_logits[j] > best_v) { best_v = last_logits[j]; best_idx = j; }
+                if (last_logits[j] > best_v) {
+                    best_v   = last_logits[j];
+                    best_idx = j;
+                }
             }
             next_token = best_idx;
         }
@@ -645,8 +616,7 @@ transcribe_status run(
                            /*token_id_first=*/decoder_start,
                            /*dump_prompt=*/true,
                            /*mid_gen_dump_name=*/nullptr);
-        st != TRANSCRIBE_OK)
-    {
+        st != TRANSCRIBE_OK) {
         return st;
     }
     if (next_token != eos) {
@@ -664,12 +634,10 @@ transcribe_status run(
     //   CPU (or debug, which needs the mid-gen dump path): per-step
     //     run_step with build_decoder_graph_kv.
     constexpr int k_mid_gen_step = 20;
-    const bool primary_is_gpu =
-        cm->plan.primary_kind != transcribe::BackendKind::Cpu &&
-        cm->plan.primary_kind != transcribe::BackendKind::Accel &&
-        cm->plan.primary_kind != transcribe::BackendKind::Unknown;
-    const bool use_step_graph = primary_is_gpu &&
-                                !transcribe::debug::enabled();
+    const bool    primary_is_gpu = cm->plan.primary_kind != transcribe::BackendKind::Cpu &&
+                                   cm->plan.primary_kind != transcribe::BackendKind::Accel &&
+                                   cm->plan.primary_kind != transcribe::BackendKind::Unknown;
+    const bool    use_step_graph = primary_is_gpu && !transcribe::debug::enabled();
 
     if (use_step_graph) {
         // ---------- Static-graph step path (GPU) ----------
@@ -677,44 +645,48 @@ transcribe_status run(
         // moonshine's max_pos is ~194, so a 1024 floor would waste 5×
         // attention bandwidth per step).
         int max_n_kv = 64;
-        while (max_n_kv < max_pos) max_n_kv *= 2;
-        if (max_n_kv > cc->kv_cache.n_ctx) max_n_kv = cc->kv_cache.n_ctx;
+        while (max_n_kv < max_pos) {
+            max_n_kv *= 2;
+        }
+        if (max_n_kv > cc->kv_cache.n_ctx) {
+            max_n_kv = cc->kv_cache.n_ctx;
+        }
 
         if (!ensure_compute_ctx(cc, 8 * 1024 * 1024)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "moonshine run: compute context allocation failed (step) — "
-                "out of memory.");
+                                "moonshine run: compute context allocation failed (step) — "
+                                "out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
-        StepBuild sb = build_step_graph(
-            cc->compute_ctx, cm->weights, hp, cc->kv_cache,
-            max_n_kv, T_enc, cc->decoder_use_flash);
+        StepBuild sb =
+            build_step_graph(cc->compute_ctx, cm->weights, hp, cc->kv_cache, max_n_kv, T_enc, cc->decoder_use_flash);
         if (sb.graph == nullptr || sb.argmax_out == nullptr) {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "moonshine run: build_step_graph failed");
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine run: build_step_graph failed");
             return TRANSCRIBE_ERR_GGUF;
         }
         ggml_backend_sched_reset(cc->sched);
         if (!ggml_backend_sched_alloc_graph(cc->sched, sb.graph)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "moonshine run: step graph allocation failed — out of memory.");
+                                "moonshine run: step graph allocation failed — out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
 
         // Mask buffer: [0, n_past) populated by the prompt pass start
         // attendable; remaining slots -inf until each step flips its
         // newly-written position to attendable.
-        const ggml_fp16_t mask_zero    = ggml_fp32_to_fp16(0.0f);
-        const ggml_fp16_t mask_neg_inf = ggml_fp32_to_fp16(-INFINITY);
+        const ggml_fp16_t        mask_zero    = ggml_fp32_to_fp16(0.0f);
+        const ggml_fp16_t        mask_neg_inf = ggml_fp32_to_fp16(-INFINITY);
         std::vector<ggml_fp16_t> step_mask(max_n_kv, mask_neg_inf);
-        for (int p = 0; p < n_past; ++p) step_mask[p] = mask_zero;
+        for (int p = 0; p < n_past; ++p) {
+            step_mask[p] = mask_zero;
+        }
 
         while (next_token != eos && n_past < max_pos) {
-            if (cc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
+            if (cc->poll_abort()) {
+                return TRANSCRIBE_ERR_ABORTED;
+            }
             if (n_past + 1 > max_n_kv) {
-                log_msg(TRANSCRIBE_LOG_LEVEL_INFO,
-                             "moonshine run: hit max_n_kv=%d at n_past=%d",
-                             max_n_kv, n_past);
+                log_msg(TRANSCRIBE_LOG_LEVEL_INFO, "moonshine run: hit max_n_kv=%d at n_past=%d", max_n_kv, n_past);
                 break;
             }
 
@@ -722,20 +694,15 @@ transcribe_status run(
             int32_t pos_val   = n_past;
             int64_t kv_val    = n_past;
             ggml_backend_tensor_set(sb.token_id_in, &token_val, 0, sizeof(int32_t));
-            ggml_backend_tensor_set(sb.pos_id_in,   &pos_val,   0, sizeof(int32_t));
-            ggml_backend_tensor_set(sb.kv_idx_in,   &kv_val,    0, sizeof(int64_t));
+            ggml_backend_tensor_set(sb.pos_id_in, &pos_val, 0, sizeof(int32_t));
+            ggml_backend_tensor_set(sb.kv_idx_in, &kv_val, 0, sizeof(int64_t));
 
             step_mask[n_past] = mask_zero;
             ggml_backend_tensor_set(sb.mask_in, step_mask.data(), 0,
-                                    static_cast<size_t>(max_n_kv) *
-                                    sizeof(ggml_fp16_t));
-
-            if (ggml_backend_sched_graph_compute(cc->sched, sb.graph)
-                != GGML_STATUS_SUCCESS)
-            {
-                log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                             "moonshine run: step compute failed (n_past=%d)",
-                             n_past);
+                                    static_cast<size_t>(max_n_kv) * sizeof(ggml_fp16_t));
+
+            if (ggml_backend_sched_graph_compute(cc->sched, sb.graph) != GGML_STATUS_SUCCESS) {
+                log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine run: step compute failed (n_past=%d)", n_past);
                 return TRANSCRIBE_ERR_GGUF;
             }
 
@@ -747,26 +714,29 @@ transcribe_status run(
             ggml_backend_tensor_get(sb.argmax_out, &argmax_id, 0, sizeof(int32_t));
             next_token = argmax_id;
 
-            if (next_token != eos) generated_ids.push_back(next_token);
+            if (next_token != eos) {
+                generated_ids.push_back(next_token);
+            }
         }
     } else {
         // ---------- Dynamic-graph step path (CPU / debug) ----------
         while (next_token != eos && n_past < max_pos) {
-            if (cc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
+            if (cc->poll_abort()) {
+                return TRANSCRIBE_ERR_ABORTED;
+            }
 
             // The mid-generation dump fires when the cache holds 20 tokens
             // (= prompt + 19 generated, so this step predicts the 21st
             // token = generated_ids[19]) — matching the reference dumper's
             // gen_step_n=20 contract.
-            const bool is_mid_gen = (n_past == k_mid_gen_step);
-            const char * dump_name = is_mid_gen ? "dec.logits_raw.gen20" : nullptr;
+            const bool   is_mid_gen = (n_past == k_mid_gen_step);
+            const char * dump_name  = is_mid_gen ? "dec.logits_raw.gen20" : nullptr;
 
             if (auto st = run_step(/*n_tokens=*/1, /*n_past=*/n_past,
                                    /*token_id_first=*/next_token,
                                    /*dump_prompt=*/false,
                                    /*mid_gen_dump_name=*/dump_name);
-                st != TRANSCRIBE_OK)
-            {
+                st != TRANSCRIBE_OK) {
                 return st;
             }
             if (next_token != eos) {
@@ -780,20 +750,18 @@ transcribe_status run(
     // and WARN.
     if (next_token != eos) {
         cc->was_truncated = true;
-        transcribe::log_msg(
-            TRANSCRIBE_LOG_LEVEL_WARN,
-            "moonshine run: output truncated at %d tokens — decode reached the "
-            "position cap (%d) before end-of-stream; the transcript may be "
-            "incomplete. This model is intended for short utterances. See "
-            "transcribe_capabilities.max_audio_ms.",
-            static_cast<int>(generated_ids.size()), max_pos);
+        transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_WARN,
+                            "moonshine run: output truncated at %d tokens — decode reached the "
+                            "position cap (%d) before end-of-stream; the transcript may be "
+                            "incomplete. This model is intended for short utterances. See "
+                            "transcribe_capabilities.max_audio_ms.",
+                            static_cast<int>(generated_ids.size()), max_pos);
     }
 
     cc->t_decode_us = ggml_time_us() - t_decode_start;
 
     if (!generated_ids.empty()) {
-        std::string full = cm->tok.decode(generated_ids.data(),
-                                          static_cast<int>(generated_ids.size()));
+        std::string full = cm->tok.decode(generated_ids.data(), static_cast<int>(generated_ids.size()));
         // SentencePiece-style BPE leading ▁ → ' '; the decode helper
         // already replaces those, but the very first token typically
         // produces a leading space. Trim it.
@@ -817,8 +785,7 @@ transcribe_status run(
     }
 
     // Truncation is a hard status; the partial transcript stays readable.
-    return cc->was_truncated ? TRANSCRIBE_ERR_OUTPUT_TRUNCATED
-                             : TRANSCRIBE_OK;
+    return cc->was_truncated ? TRANSCRIBE_ERR_OUTPUT_TRUNCATED : TRANSCRIBE_OK;
 }
 
 // Offline batched decode (transcribe_run_batch). Mirrors src/arch/cohere +
@@ -827,53 +794,61 @@ transcribe_status run(
 // path, so on Metal (decoder flash OFF — head_dim_padded unsupported) it falls
 // back to serial; engages on Vulkan/CUDA.
 
-transcribe_status encode_one_to_host(
-    MoonshineSession * cc, MoonshineModel * cm,
-    const float * pcm, int n_samples,
-    std::vector<float> & enc_out, int & T_enc_out, int64_t & enc_us)
-{
-    if (pcm == nullptr || n_samples <= 0) return TRANSCRIBE_ERR_INVALID_ARG;
+transcribe_status encode_one_to_host(MoonshineSession *   cc,
+                                     MoonshineModel *     cm,
+                                     const float *        pcm,
+                                     int                  n_samples,
+                                     std::vector<float> & enc_out,
+                                     int &                T_enc_out,
+                                     int64_t &            enc_us) {
+    if (pcm == nullptr || n_samples <= 0) {
+        return TRANSCRIBE_ERR_INVALID_ARG;
+    }
     const auto & hp = cm->hparams;
 
     if (!ensure_compute_ctx(cc, 8 * 1024 * 1024)) {
         transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "moonshine encode: compute context allocation failed — "
-            "out of memory.");
+                            "moonshine encode: compute context allocation failed — "
+                            "out of memory.");
         return TRANSCRIBE_ERR_OOM;
     }
-    EncoderBuild eb = build_encoder_graph(
-        cc->compute_ctx, cm->weights, hp, n_samples, cc->encoder_use_flash);
-    if (eb.audio_in == nullptr || eb.out == nullptr || eb.graph == nullptr)
+    EncoderBuild eb = build_encoder_graph(cc->compute_ctx, cm->weights, hp, n_samples, cc->encoder_use_flash);
+    if (eb.audio_in == nullptr || eb.out == nullptr || eb.graph == nullptr) {
         return TRANSCRIBE_ERR_GGUF;
+    }
     const int T_enc = eb.T_enc;
-    if (T_enc <= 0) return TRANSCRIBE_ERR_GGUF;
+    if (T_enc <= 0) {
+        return TRANSCRIBE_ERR_GGUF;
+    }
 
     if (cc->sched == nullptr) {
-        cc->sched = ggml_backend_sched_new(
-            cm->plan.scheduler_list.data(), nullptr,
-            static_cast<int>(cm->plan.scheduler_list.size()), 16384, false, true);
-        if (cc->sched == nullptr) return TRANSCRIBE_ERR_GGUF;
+        cc->sched = ggml_backend_sched_new(cm->plan.scheduler_list.data(), nullptr,
+                                           static_cast<int>(cm->plan.scheduler_list.size()), 16384, false, true);
+        if (cc->sched == nullptr) {
+            return TRANSCRIBE_ERR_GGUF;
+        }
     }
     ggml_backend_sched_reset(cc->sched);
     if (!ggml_backend_sched_alloc_graph(cc->sched, eb.graph)) {
         transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "moonshine encode: encoder graph allocation failed — out of memory.");
+                            "moonshine encode: encoder graph allocation failed — out of memory.");
         return TRANSCRIBE_ERR_OOM;
     }
 
-    ggml_backend_tensor_set(eb.audio_in, pcm, 0,
-                            static_cast<size_t>(n_samples) * sizeof(float));
+    ggml_backend_tensor_set(eb.audio_in, pcm, 0, static_cast<size_t>(n_samples) * sizeof(float));
     {
         std::vector<int32_t> enc_pos_ids(static_cast<size_t>(T_enc));
-        for (int i = 0; i < T_enc; ++i) enc_pos_ids[i] = i;
-        ggml_backend_tensor_set(eb.pos_ids_in, enc_pos_ids.data(), 0,
-                                enc_pos_ids.size() * sizeof(int32_t));
+        for (int i = 0; i < T_enc; ++i) {
+            enc_pos_ids[i] = i;
+        }
+        ggml_backend_tensor_set(eb.pos_ids_in, enc_pos_ids.data(), 0, enc_pos_ids.size() * sizeof(int32_t));
     }
     apply_thread_policy(cc);
 
     const int64_t t0 = ggml_time_us();
-    if (ggml_backend_sched_graph_compute(cc->sched, eb.graph) != GGML_STATUS_SUCCESS)
+    if (ggml_backend_sched_graph_compute(cc->sched, eb.graph) != GGML_STATUS_SUCCESS) {
         return TRANSCRIBE_ERR_GGUF;
+    }
     enc_us += ggml_time_us() - t0;
 
     const int d_model = hp.dec_d_model;
@@ -883,76 +858,84 @@ transcribe_status encode_one_to_host(
     return TRANSCRIBE_OK;
 }
 
-transcribe_status run_batch_serial(MoonshineSession * cc,
-                                   const float * const * pcm,
-                                   const int * n_samples, int n,
+transcribe_status run_batch_serial(MoonshineSession *            cc,
+                                   const float * const *         pcm,
+                                   const int *                   n_samples,
+                                   int                           n,
                                    const transcribe_run_params * params) {
     for (int i = 0; i < n; ++i) {
-        if (cc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
-        const transcribe_status st =
-            (pcm[i] == nullptr || n_samples[i] <= 0)
-                ? TRANSCRIBE_ERR_INVALID_ARG
-                : run(cc, pcm[i], n_samples[i], params);
+        if (cc->poll_abort()) {
+            return TRANSCRIBE_ERR_ABORTED;
+        }
+        const transcribe_status st = (pcm[i] == nullptr || n_samples[i] <= 0) ? TRANSCRIBE_ERR_INVALID_ARG :
+                                                                                run(cc, pcm[i], n_samples[i], params);
         if (st == TRANSCRIBE_OK) {
             cc->batch_results.push_back(cc->capture_result(st));
         } else {
-            transcribe_session::ResultSet rs; rs.status = st;
+            transcribe_session::ResultSet rs;
+            rs.status = st;
             cc->batch_results.push_back(std::move(rs));
         }
     }
     return TRANSCRIBE_OK;
 }
 
-transcribe_status run_batch(
-    transcribe_session *          session,
-    const float * const *         pcm,
-    const int *                   n_samples,
-    int                           n,
-    const transcribe_run_params * params)
-{
-    if (session == nullptr || pcm == nullptr || n_samples == nullptr || n <= 0)
+transcribe_status run_batch(transcribe_session *          session,
+                            const float * const *         pcm,
+                            const int *                   n_samples,
+                            int                           n,
+                            const transcribe_run_params * params) {
+    if (session == nullptr || pcm == nullptr || n_samples == nullptr || n <= 0) {
         return TRANSCRIBE_ERR_INVALID_ARG;
+    }
     auto * cc = static_cast<MoonshineSession *>(session);
     auto * cm = static_cast<MoonshineModel *>(cc->model);
-    if (cm == nullptr || cm->plan.scheduler_list.empty())
+    if (cm == nullptr || cm->plan.scheduler_list.empty()) {
         return TRANSCRIBE_ERR_INVALID_ARG;
+    }
 
-    const bool primary_is_gpu =
-        cm->plan.primary_kind != transcribe::BackendKind::Cpu &&
-        cm->plan.primary_kind != transcribe::BackendKind::Accel &&
-        cm->plan.primary_kind != transcribe::BackendKind::Unknown;
+    const bool primary_is_gpu = cm->plan.primary_kind != transcribe::BackendKind::Cpu &&
+                                cm->plan.primary_kind != transcribe::BackendKind::Accel &&
+                                cm->plan.primary_kind != transcribe::BackendKind::Unknown;
     // The batched path always uses flash (unconditional), even on Metal where
     // single-shot defaults decoder flash OFF (base's head_dim_padded=56
     // CPU-spills): at B>1 flash still beats serial (tiny ~1.7×, base ~1.17×).
-    if (n == 1 || !primary_is_gpu || transcribe::debug::enabled())
+    if (n == 1 || !primary_is_gpu || transcribe::debug::enabled()) {
         return run_batch_serial(cc, pcm, n_samples, n, params);
+    }
 
     transcribe::debug::init();
-    const auto & hp = cm->hparams;
-    const int d_model = hp.dec_d_model;
-    const int n_layer = hp.dec_n_layers;
-    const int decoder_start = hp.decoder_start_token_id;
-    const int32_t eos = hp.eos_token_id;
-    const int max_pos = hp.dec_max_position_embeddings;
+    const auto &  hp            = cm->hparams;
+    const int     d_model       = hp.dec_d_model;
+    const int     n_layer       = hp.dec_n_layers;
+    const int     decoder_start = hp.decoder_start_token_id;
+    const int32_t eos           = hp.eos_token_id;
+    const int     max_pos       = hp.dec_max_position_embeddings;
 
     // ----- Serial per-utterance encoder (no mel; raw PCM) -----
-    std::vector<char> valid(n, 0);
+    std::vector<char>               valid(n, 0);
     std::vector<std::vector<float>> enc_hosts(n);
-    std::vector<int> T_enc(n, 0);
-    int T_enc_max = 0;
-    int64_t enc_us = 0;
+    std::vector<int>                T_enc(n, 0);
+    int                             T_enc_max = 0;
+    int64_t                         enc_us    = 0;
     for (int b = 0; b < n; ++b) {
-        if (cc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
-        if (pcm[b] == nullptr || n_samples[b] <= 0) continue;
-        if (encode_one_to_host(cc, cm, pcm[b], n_samples[b],
-                               enc_hosts[b], T_enc[b], enc_us) != TRANSCRIBE_OK
-            || T_enc[b] <= 0) continue;
-        valid[b] = 1;
+        if (cc->poll_abort()) {
+            return TRANSCRIBE_ERR_ABORTED;
+        }
+        if (pcm[b] == nullptr || n_samples[b] <= 0) {
+            continue;
+        }
+        if (encode_one_to_host(cc, cm, pcm[b], n_samples[b], enc_hosts[b], T_enc[b], enc_us) != TRANSCRIBE_OK ||
+            T_enc[b] <= 0) {
+            continue;
+        }
+        valid[b]  = 1;
         T_enc_max = std::max(T_enc_max, T_enc[b]);
     }
     if (T_enc_max <= 0) {
         for (int b = 0; b < n; ++b) {
-            transcribe_session::ResultSet rs; rs.status = TRANSCRIBE_ERR_INVALID_ARG;
+            transcribe_session::ResultSet rs;
+            rs.status = TRANSCRIBE_ERR_INVALID_ARG;
             cc->batch_results.push_back(std::move(rs));
         }
         return TRANSCRIBE_OK;
@@ -960,27 +943,32 @@ transcribe_status run_batch(
 
     // ----- Batched KV cache -----
     int max_n_kv = 64;
-    while (max_n_kv < max_pos) max_n_kv *= 2;
+    while (max_n_kv < max_pos) {
+        max_n_kv *= 2;
+    }
     // Match serial run(): default the cache to F32 (AUTO), F16 only on
     // explicit request. moonshine's reference regime is F32, and ggml's
     // Metal backend lacks a working kernel_pad_f16 for the head-dim pad.
     ggml_type kv_type = GGML_TYPE_F32;
-    if (cc->kv_type == TRANSCRIBE_KV_TYPE_F16) kv_type = GGML_TYPE_F16;
+    if (cc->kv_type == TRANSCRIBE_KV_TYPE_F16) {
+        kv_type = GGML_TYPE_F16;
+    }
     if (cc->kv_cache.buffer != nullptr &&
-        (cc->kv_cache.n_batch != n || cc->kv_cache.T_enc != T_enc_max ||
-         cc->kv_cache.n_ctx != max_n_kv))
+        (cc->kv_cache.n_batch != n || cc->kv_cache.T_enc != T_enc_max || cc->kv_cache.n_ctx != max_n_kv)) {
         cc->kv_cache.free();
+    }
     if (cc->kv_cache.buffer == nullptr) {
-        if (!kv_cache_init_batched(cc->kv_cache, cm->plan.primary,
-                                   max_n_kv, T_enc_max, d_model, n_layer, n, kv_type)) {
+        if (!kv_cache_init_batched(cc->kv_cache, cm->plan.primary, max_n_kv, T_enc_max, d_model, n_layer, n, kv_type)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "moonshine run_batch: batched KV cache allocation failed — "
-                "out of memory.");
+                                "moonshine run_batch: batched KV cache allocation failed — "
+                                "out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
     } else {
         ggml_backend_buffer_clear(cc->kv_cache.buffer, 0);
-        cc->kv_cache.n = 0; cc->kv_cache.head = 0; cc->kv_cache.cross_populated = false;
+        cc->kv_cache.n               = 0;
+        cc->kv_cache.head            = 0;
+        cc->kv_cache.cross_populated = false;
     }
 
     const int64_t t_dec0 = ggml_time_us();
@@ -989,31 +977,33 @@ transcribe_status run_batch(
     {
         if (!ensure_compute_ctx(cc, 8 * 1024 * 1024)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "moonshine run_batch: compute context allocation failed "
-                "(cross_kv) — out of memory.");
+                                "moonshine run_batch: compute context allocation failed "
+                                "(cross_kv) — out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
-        DecoderBuild cross = build_cross_kv_graph_batched(
-            cc->compute_ctx, cm->weights, hp, cc->kv_cache, T_enc_max, n);
-        if (cross.graph == nullptr) return TRANSCRIBE_ERR_GGUF;
+        DecoderBuild cross = build_cross_kv_graph_batched(cc->compute_ctx, cm->weights, hp, cc->kv_cache, T_enc_max, n);
+        if (cross.graph == nullptr) {
+            return TRANSCRIBE_ERR_GGUF;
+        }
         ggml_backend_sched_reset(cc->sched);
         if (!ggml_backend_sched_alloc_graph(cc->sched, cross.graph)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "moonshine run_batch: cross_kv graph allocation failed — "
-                "out of memory.");
+                                "moonshine run_batch: cross_kv graph allocation failed — "
+                                "out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
         std::vector<float> packed(static_cast<size_t>(d_model) * T_enc_max * n, 0.0f);
         for (int b = 0; b < n; ++b) {
-            if (!valid[b]) continue;
-            std::memcpy(packed.data() + static_cast<size_t>(b) * T_enc_max * d_model,
-                        enc_hosts[b].data(),
+            if (!valid[b]) {
+                continue;
+            }
+            std::memcpy(packed.data() + static_cast<size_t>(b) * T_enc_max * d_model, enc_hosts[b].data(),
                         static_cast<size_t>(d_model) * T_enc[b] * sizeof(float));
         }
-        ggml_backend_tensor_set(cross.encoder_out_in, packed.data(), 0,
-                                packed.size() * sizeof(float));
-        if (ggml_backend_sched_graph_compute(cc->sched, cross.graph) != GGML_STATUS_SUCCESS)
+        ggml_backend_tensor_set(cross.encoder_out_in, packed.data(), 0, packed.size() * sizeof(float));
+        if (ggml_backend_sched_graph_compute(cc->sched, cross.graph) != GGML_STATUS_SUCCESS) {
             return TRANSCRIBE_ERR_GGUF;
+        }
         cc->kv_cache.cross_populated = true;
     }
 
@@ -1021,35 +1011,36 @@ transcribe_status run_batch(
     // moonshine is the degenerate enc-dec case: a single decoder_start prompt
     // token and a fixed read window (self-KV spans the whole sequence, so
     // init_window == max_n_kv and the shared driver never grows it).
-    const ggml_fp16_t f16_zero = ggml_fp32_to_fp16(0.0f);
-    const ggml_fp16_t f16_ninf = ggml_fp32_to_fp16(-INFINITY);
+    const ggml_fp16_t        f16_zero = ggml_fp32_to_fp16(0.0f);
+    const ggml_fp16_t        f16_ninf = ggml_fp32_to_fp16(-INFINITY);
     std::vector<ggml_fp16_t> cmask(static_cast<size_t>(T_enc_max) * n, f16_ninf);
     for (int b = 0; b < n; ++b) {
-        const int real = valid[b] ? T_enc[b] : 1;
+        const int     real = valid[b] ? T_enc[b] : 1;
         ggml_fp16_t * base = cmask.data() + static_cast<size_t>(b) * T_enc_max;
         std::fill(base, base + std::min(real, T_enc_max), f16_zero);
     }
 
-    StepBuildBatched sb {};
-    auto rebuild = [&](int win, transcribe::EncDecStepIO & io) -> bool {
+    StepBuildBatched sb{};
+    auto             rebuild = [&](int win, transcribe::EncDecStepIO & io) -> bool {
         if (!ensure_compute_ctx(cc, 16 * 1024 * 1024)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "moonshine run_batch: compute context allocation failed "
-                "(step) — out of memory.");
+                                "moonshine run_batch: compute context allocation failed "
+                                "(step) — out of memory.");
+            return false;
+        }
+        sb = build_step_graph_batched(cc->compute_ctx, cm->weights, hp, cc->kv_cache, win, T_enc_max, n,
+                                      /*use_flash=*/true);
+        if (sb.graph == nullptr || sb.argmax_out == nullptr) {
             return false;
         }
-        sb = build_step_graph_batched(cc->compute_ctx, cm->weights, hp,
-                                      cc->kv_cache, win, T_enc_max, n, /*use_flash=*/true);
-        if (sb.graph == nullptr || sb.argmax_out == nullptr) return false;
         ggml_backend_sched_reset(cc->sched);
         if (!ggml_backend_sched_alloc_graph(cc->sched, sb.graph)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "moonshine run_batch: step graph allocation failed — "
-                "out of memory.");
+                                "moonshine run_batch: step graph allocation failed — "
+                                "out of memory.");
             return false;
         }
-        ggml_backend_tensor_set(sb.cross_mask_in, cmask.data(), 0,
-                                cmask.size() * sizeof(ggml_fp16_t));
+        ggml_backend_tensor_set(sb.cross_mask_in, cmask.data(), 0, cmask.size() * sizeof(ggml_fp16_t));
         io.token_ids = sb.token_ids_in;
         io.pos_ids   = sb.pos_ids_in;
         io.kv_idx    = sb.kv_idx_in;
@@ -1059,13 +1050,12 @@ transcribe_status run_batch(
         return true;
     };
 
-    const std::vector<int32_t> prompt_ids = { static_cast<int32_t>(decoder_start) };
+    const std::vector<int32_t>        prompt_ids = { static_cast<int32_t>(decoder_start) };
     std::vector<std::vector<int32_t>> generated(n);
-    std::vector<char> truncated;
+    std::vector<char>                 truncated;
     if (const transcribe_status st = transcribe::run_batched_encdec_step_loop(
             cc, cc->sched, rebuild, prompt_ids, /*prompt_len=*/1,
-            /*init_window=*/max_n_kv, /*max_new=*/max_pos, max_n_kv,
-            static_cast<int32_t>(eos), n, valid, generated,
+            /*init_window=*/max_n_kv, /*max_new=*/max_pos, max_n_kv, static_cast<int32_t>(eos), n, valid, generated,
             /*n_steps_out=*/nullptr, &truncated);
         st != TRANSCRIBE_OK) {
         return st;
@@ -1083,39 +1073,43 @@ transcribe_status run_batch(
         }
         if (n_truncated > 0) {
             cc->was_truncated = true;
-            transcribe::log_msg(
-                TRANSCRIBE_LOG_LEVEL_WARN,
-                "moonshine run_batch: %d of %d utterances truncated — decode "
-                "reached the position cap (%d) before end-of-stream; those "
-                "transcripts may be incomplete. This model is intended for "
-                "short utterances. See transcribe_capabilities.max_audio_ms.",
-                n_truncated, n, max_pos);
+            transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_WARN,
+                                "moonshine run_batch: %d of %d utterances truncated — decode "
+                                "reached the position cap (%d) before end-of-stream; those "
+                                "transcripts may be incomplete. This model is intended for "
+                                "short utterances. See transcribe_capabilities.max_audio_ms.",
+                                n_truncated, n, max_pos);
         }
     }
 
     // ----- Capture -----
-    const int valid_count = std::max(1, static_cast<int>(
-        std::count(valid.begin(), valid.end(), char(1))));
+    const int valid_count = std::max(1, static_cast<int>(std::count(valid.begin(), valid.end(), char(1))));
     for (int b = 0; b < n; ++b) {
         transcribe_session::ResultSet rs;
-        if (!valid[b]) { rs.status = TRANSCRIBE_ERR_INVALID_ARG;
-                         cc->batch_results.push_back(std::move(rs)); continue; }
-        std::string full = cm->tok.decode(generated[b].data(),
-                                          static_cast<int>(generated[b].size()));
-        if (!full.empty() && full.front() == ' ') full.erase(full.begin());
-        transcribe_session::SegmentEntry seg {};
-        seg.t0_ms = 0; seg.t1_ms = 0; seg.text = full;
+        if (!valid[b]) {
+            rs.status = TRANSCRIBE_ERR_INVALID_ARG;
+            cc->batch_results.push_back(std::move(rs));
+            continue;
+        }
+        std::string full = cm->tok.decode(generated[b].data(), static_cast<int>(generated[b].size()));
+        if (!full.empty() && full.front() == ' ') {
+            full.erase(full.begin());
+        }
+        transcribe_session::SegmentEntry seg{};
+        seg.t0_ms = 0;
+        seg.t1_ms = 0;
+        seg.text  = full;
         rs.segments.push_back(std::move(seg));
-        rs.full_text = full;
+        rs.full_text   = full;
         rs.result_kind = TRANSCRIBE_TIMESTAMPS_NONE;
-        rs.has_result = true; rs.status = TRANSCRIBE_OK;
+        rs.has_result  = true;
+        rs.status      = TRANSCRIBE_OK;
         // Per-utterance truncation parity with the single-shot path. Only
         // override an otherwise-OK status — never a worse one.
-        if (rs.status == TRANSCRIBE_OK &&
-            b < static_cast<int>(truncated.size()) && truncated[b]) {
+        if (rs.status == TRANSCRIBE_OK && b < static_cast<int>(truncated.size()) && truncated[b]) {
             rs.status = TRANSCRIBE_ERR_OUTPUT_TRUNCATED;
         }
-        rs.t_mel_us = 0;
+        rs.t_mel_us    = 0;
         rs.t_encode_us = enc_us / valid_count;
         rs.t_decode_us = dec_us / valid_count;
         cc->batch_results.push_back(std::move(rs));
@@ -1123,14 +1117,14 @@ transcribe_status run_batch(
 
     if (transcribe::env::flag("TRANSCRIBE_PERF_DEBUG")) {
         log_msg(TRANSCRIBE_LOG_LEVEL_DEBUG,
-            "moonshine run_batch: n=%d T_enc_max=%d max_n_kv=%d\n"
-            "  enc=%.1fms (serial x%d)  decode=%.1fms (batched)",
-            n, T_enc_max, max_n_kv, enc_us / 1000.0, n, dec_us / 1000.0);
+                "moonshine run_batch: n=%d T_enc_max=%d max_n_kv=%d\n"
+                "  enc=%.1fms (serial x%d)  decode=%.1fms (batched)",
+                n, T_enc_max, max_n_kv, enc_us / 1000.0, n, dec_us / 1000.0);
     }
     return TRANSCRIBE_OK;
 }
 
-} // namespace
+}  // namespace
 
 extern const Arch arch = {
     /* .name             = */ "moonshine",
@@ -1146,4 +1140,4 @@ extern const Arch arch = {
     /* .accepts_ext_kind = */ nullptr,
 };
 
-} // namespace transcribe::moonshine
+}  // namespace transcribe::moonshine
diff --git a/src/arch/moonshine/moonshine.h b/src/arch/moonshine/moonshine.h
index 8a7d85a6..23b91038 100644
--- a/src/arch/moonshine/moonshine.h
+++ b/src/arch/moonshine/moonshine.h
@@ -11,15 +11,14 @@
 
 #pragma once
 
+#include "ggml-backend.h"
+#include "ggml.h"
 #include "transcribe-backend.h"
-#include "transcribe-session.h"
 #include "transcribe-model.h"
+#include "transcribe-session.h"
 #include "transcribe-tokenizer.h"
 #include "weights.h"
 
-#include "ggml.h"
-#include "ggml-backend.h"
-
 #include <cstdint>
 #include <string>
 #include <vector>
@@ -48,19 +47,19 @@ void apply_family_invariants(transcribe_model & model);
 // ---------------------------------------------------------------------------
 
 struct MoonshineKvCache {
-    ggml_tensor * self_k = nullptr;
-    ggml_tensor * self_v = nullptr;
+    ggml_tensor * self_k  = nullptr;
+    ggml_tensor * self_v  = nullptr;
     ggml_tensor * cross_k = nullptr;
     ggml_tensor * cross_v = nullptr;
 
-    ggml_context * ctx = nullptr;
+    ggml_context *        ctx    = nullptr;
     ggml_backend_buffer_t buffer = nullptr;
 
-    int n_ctx = 0;     // max self-attn sequence length
-    int n     = 0;     // current self-attn fill
-    int head  = 0;     // write head for next step
-    int T_enc = 0;     // encoder frame count in cross cache (T_enc_max if batched)
-    int n_batch = 1;   // utterance batch width (>1 for the offline batched decoder)
+    int n_ctx   = 0;  // max self-attn sequence length
+    int n       = 0;  // current self-attn fill
+    int head    = 0;  // write head for next step
+    int T_enc   = 0;  // encoder frame count in cross cache (T_enc_max if batched)
+    int n_batch = 1;  // utterance batch width (>1 for the offline batched decoder)
 
     bool cross_populated = false;
 
@@ -73,14 +72,14 @@ struct MoonshineKvCache {
             ggml_free(ctx);
             ctx = nullptr;
         }
-        self_k = nullptr;
-        self_v = nullptr;
-        cross_k = nullptr;
-        cross_v = nullptr;
-        n = 0;
-        head = 0;
-        T_enc = 0;
-        n_batch = 1;
+        self_k          = nullptr;
+        self_v          = nullptr;
+        cross_k         = nullptr;
+        cross_v         = nullptr;
+        n               = 0;
+        head            = 0;
+        T_enc           = 0;
+        n_batch         = 1;
         cross_populated = false;
     }
 };
@@ -109,10 +108,10 @@ bool kv_cache_init_batched(MoonshineKvCache & cache,
 // ---------------------------------------------------------------------------
 
 struct MoonshineModel final : public transcribe_model {
-    Tokenizer         tok;
-    MoonshineHParams  hparams;
-    MoonshineWeights  weights;
-    ggml_context *    ctx_meta = nullptr;
+    Tokenizer        tok;
+    MoonshineHParams hparams;
+    MoonshineWeights weights;
+    ggml_context *   ctx_meta = nullptr;
 
     transcribe::BackendPlan plan;
     ggml_backend_buffer_t   backend_buffer = nullptr;
@@ -124,18 +123,17 @@ struct MoonshineModel final : public transcribe_model {
 };
 
 struct MoonshineSession final : public transcribe_session {
-    ggml_context *        compute_ctx = nullptr;
-    ggml_backend_sched_t  sched       = nullptr;
+    ggml_context *       compute_ctx = nullptr;
+    ggml_backend_sched_t sched       = nullptr;
 
     // Host-side mirror of the encoder output. Required because the
     // cross-KV graph runs in a fresh compute_ctx that does not share
     // tensor handles with the encoder graph.
     std::vector<float> enc_host;
-    int                enc_T = 0;   // number of encoder frames
+    int                enc_T = 0;  // number of encoder frames
 
     MoonshineKvCache kv_cache;
 
-
     // Flash-attention defaults — finalized per-backend in init_context.
     // Encoder: ON everywhere (~2x on long audio). Decoder: ON except Metal
     // (Vulkan ~15% faster: jfk q8_0 tiny 112→98, base 165→143 ms). Metal
@@ -150,4 +148,4 @@ struct MoonshineSession final : public transcribe_session {
     ~MoonshineSession() override;
 };
 
-} // namespace transcribe::moonshine
+}  // namespace transcribe::moonshine
diff --git a/src/arch/moonshine/weights.cpp b/src/arch/moonshine/weights.cpp
index 6da3b09f..c91c3e13 100644
--- a/src/arch/moonshine/weights.cpp
+++ b/src/arch/moonshine/weights.cpp
@@ -20,12 +20,11 @@
 
 #include "weights.h"
 
-#include "transcribe-meta.h"
-#include "transcribe-weights-util.h"
-#include "transcribe-log.h"
-
 #include "ggml.h"
 #include "gguf.h"
+#include "transcribe-log.h"
+#include "transcribe-meta.h"
+#include "transcribe-weights-util.h"
 
 #include <cstdio>
 #include <cstring>
@@ -42,10 +41,9 @@ transcribe_status read_optional_u32_kv(const gguf_context * gguf,
                                        const char *         key,
                                        const char *         error_tag,
                                        int32_t              default_value,
-                                       int32_t &            out)
-{
-    uint32_t value = 0;
-    const auto st = transcribe::read_uint32_kv(gguf, key, value);
+                                       int32_t &            out) {
+    uint32_t   value = 0;
+    const auto st    = transcribe::read_uint32_kv(gguf, key, value);
     if (st == transcribe::KvResult::Ok) {
         out = static_cast<int32_t>(value);
         return TRANSCRIBE_OK;
@@ -62,10 +60,9 @@ transcribe_status read_optional_f32_kv(const gguf_context * gguf,
                                        const char *         key,
                                        const char *         error_tag,
                                        float                default_value,
-                                       float &              out)
-{
-    float value = default_value;
-    const auto st = transcribe::read_float32_kv(gguf, key, value);
+                                       float &              out) {
+    float      value = default_value;
+    const auto st    = transcribe::read_float32_kv(gguf, key, value);
     if (st == transcribe::KvResult::Ok) {
         out = value;
         return TRANSCRIBE_OK;
@@ -79,12 +76,13 @@ transcribe_status read_optional_f32_kv(const gguf_context * gguf,
 }
 
 // uint32 array → vector<int32_t>. Used for the conv-stem shape lists.
-transcribe_status read_required_u32_array_kv(const gguf_context * gguf,
-                                             const char *         key,
-                                             const char *         error_tag,
-                                             std::vector<int32_t> & out)
-{
-    if (gguf == nullptr) return TRANSCRIBE_ERR_INVALID_ARG;
+transcribe_status read_required_u32_array_kv(const gguf_context *   gguf,
+                                             const char *           key,
+                                             const char *           error_tag,
+                                             std::vector<int32_t> & out) {
+    if (gguf == nullptr) {
+        return TRANSCRIBE_ERR_INVALID_ARG;
+    }
     const int64_t kid = gguf_find_key(gguf, key);
     if (kid < 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: missing required KV %s", error_tag, key);
@@ -96,85 +94,194 @@ transcribe_status read_required_u32_array_kv(const gguf_context * gguf,
     }
     const gguf_type elem_type = gguf_get_arr_type(gguf, kid);
     if (elem_type != GGUF_TYPE_UINT32 && elem_type != GGUF_TYPE_INT32) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "%s: KV %s array element type is not u32/i32 (got %d)",
-                     error_tag, key, static_cast<int>(elem_type));
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: KV %s array element type is not u32/i32 (got %d)", error_tag, key,
+                static_cast<int>(elem_type));
         return TRANSCRIBE_ERR_GGUF;
     }
-    const size_t n = gguf_get_arr_n(gguf, kid);
+    const size_t n    = gguf_get_arr_n(gguf, kid);
     const void * data = gguf_get_arr_data(gguf, kid);
     out.resize(n);
     if (elem_type == GGUF_TYPE_UINT32) {
         const uint32_t * src = static_cast<const uint32_t *>(data);
-        for (size_t i = 0; i < n; ++i) out[i] = static_cast<int32_t>(src[i]);
+        for (size_t i = 0; i < n; ++i) {
+            out[i] = static_cast<int32_t>(src[i]);
+        }
     } else {
         const int32_t * src = static_cast<const int32_t *>(data);
-        for (size_t i = 0; i < n; ++i) out[i] = src[i];
+        for (size_t i = 0; i < n; ++i) {
+            out[i] = src[i];
+        }
     }
     return TRANSCRIBE_OK;
 }
 
-} // namespace
+}  // namespace
 
 // ---------------------------------------------------------------------------
 // Hparams
 // ---------------------------------------------------------------------------
 
-transcribe_status read_moonshine_hparams(const gguf_context * gguf,
-                                         MoonshineHParams &   hp)
-{
+transcribe_status read_moonshine_hparams(const gguf_context * gguf, MoonshineHParams & hp) {
     if (gguf == nullptr) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
 
     // Encoder.
-    if (auto st = read_required_u32_kv(gguf, "stt.moonshine.encoder.n_layers",   kFamilyTag, hp.enc_n_layers);   st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.moonshine.encoder.d_model",    kFamilyTag, hp.enc_d_model);    st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.moonshine.encoder.n_heads",    kFamilyTag, hp.enc_n_heads);    st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_u32_kv(gguf, "stt.moonshine.encoder.n_kv_heads", kFamilyTag, hp.enc_n_heads, hp.enc_n_kv_heads); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.moonshine.encoder.ffn_dim",    kFamilyTag, hp.enc_ffn_dim);    st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.moonshine.encoder.activation", kFamilyTag, hp.enc_activation); st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_u32_kv(gguf, "stt.moonshine.encoder.n_layers", kFamilyTag, hp.enc_n_layers);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.moonshine.encoder.d_model", kFamilyTag, hp.enc_d_model);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.moonshine.encoder.n_heads", kFamilyTag, hp.enc_n_heads);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_u32_kv(gguf, "stt.moonshine.encoder.n_kv_heads", kFamilyTag, hp.enc_n_heads,
+                                       hp.enc_n_kv_heads);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.moonshine.encoder.ffn_dim", kFamilyTag, hp.enc_ffn_dim);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_string_kv(gguf, "stt.moonshine.encoder.activation", kFamilyTag, hp.enc_activation);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Decoder.
-    if (auto st = read_required_u32_kv(gguf, "stt.moonshine.decoder.n_layers",                kFamilyTag, hp.dec_n_layers);                st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.moonshine.decoder.d_model",                 kFamilyTag, hp.dec_d_model);                 st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.moonshine.decoder.n_heads",                 kFamilyTag, hp.dec_n_heads);                 st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_u32_kv(gguf, "stt.moonshine.decoder.n_kv_heads",              kFamilyTag, hp.dec_n_heads, hp.dec_n_kv_heads); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.moonshine.decoder.ffn_dim",                 kFamilyTag, hp.dec_ffn_dim);                 st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.moonshine.decoder.activation",           kFamilyTag, hp.dec_activation);              st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.moonshine.decoder.vocab_size",              kFamilyTag, hp.dec_vocab_size);              st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.moonshine.decoder.max_position_embeddings", kFamilyTag, hp.dec_max_position_embeddings); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_bool_kv(gguf, "stt.moonshine.decoder.tie_word_embeddings",    kFamilyTag, true, hp.dec_tie_word_embeddings); st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_u32_kv(gguf, "stt.moonshine.decoder.n_layers", kFamilyTag, hp.dec_n_layers);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.moonshine.decoder.d_model", kFamilyTag, hp.dec_d_model);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.moonshine.decoder.n_heads", kFamilyTag, hp.dec_n_heads);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_u32_kv(gguf, "stt.moonshine.decoder.n_kv_heads", kFamilyTag, hp.dec_n_heads,
+                                       hp.dec_n_kv_heads);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.moonshine.decoder.ffn_dim", kFamilyTag, hp.dec_ffn_dim);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_string_kv(gguf, "stt.moonshine.decoder.activation", kFamilyTag, hp.dec_activation);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.moonshine.decoder.vocab_size", kFamilyTag, hp.dec_vocab_size);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.moonshine.decoder.max_position_embeddings", kFamilyTag,
+                                       hp.dec_max_position_embeddings);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_bool_kv(gguf, "stt.moonshine.decoder.tie_word_embeddings", kFamilyTag, true,
+                                        hp.dec_tie_word_embeddings);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Special tokens.
-    if (auto st = read_required_u32_kv(gguf, "stt.moonshine.bos_token_id",           kFamilyTag, hp.bos_token_id);           st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.moonshine.eos_token_id",           kFamilyTag, hp.eos_token_id);           st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.moonshine.pad_token_id",           kFamilyTag, hp.pad_token_id);           st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.moonshine.decoder_start_token_id", kFamilyTag, hp.decoder_start_token_id); st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_u32_kv(gguf, "stt.moonshine.bos_token_id", kFamilyTag, hp.bos_token_id);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.moonshine.eos_token_id", kFamilyTag, hp.eos_token_id);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.moonshine.pad_token_id", kFamilyTag, hp.pad_token_id);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st =
+            read_required_u32_kv(gguf, "stt.moonshine.decoder_start_token_id", kFamilyTag, hp.decoder_start_token_id);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Attention / RoPE.
-    if (auto st = read_optional_f32_kv (gguf, "stt.moonshine.partial_rotary_factor",       kFamilyTag, 0.9f, hp.partial_rotary_factor); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_f32_kv (gguf, "stt.moonshine.rope_theta",                  kFamilyTag, 10000.0f, hp.rope_theta);        st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_bool_kv(gguf, "stt.moonshine.attention_bias",              kFamilyTag, false, hp.attention_bias);       st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_u32_kv (gguf, "stt.moonshine.pad_head_dim_to_multiple_of", kFamilyTag, 0, hp.pad_head_dim_multiple);    st != TRANSCRIBE_OK) return st;
+    if (auto st = read_optional_f32_kv(gguf, "stt.moonshine.partial_rotary_factor", kFamilyTag, 0.9f,
+                                       hp.partial_rotary_factor);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_f32_kv(gguf, "stt.moonshine.rope_theta", kFamilyTag, 10000.0f, hp.rope_theta);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_bool_kv(gguf, "stt.moonshine.attention_bias", kFamilyTag, false, hp.attention_bias);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_u32_kv(gguf, "stt.moonshine.pad_head_dim_to_multiple_of", kFamilyTag, 0,
+                                       hp.pad_head_dim_multiple);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Conv stem.
-    if (auto st = read_required_u32_array_kv(gguf, "stt.moonshine.conv_stem.channels",     kFamilyTag, hp.conv_channels);     st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_array_kv(gguf, "stt.moonshine.conv_stem.kernel_sizes", kFamilyTag, hp.conv_kernel_sizes); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_array_kv(gguf, "stt.moonshine.conv_stem.strides",      kFamilyTag, hp.conv_strides);      st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_u32_kv (gguf, "stt.moonshine.conv_stem.groupnorm_num_groups", kFamilyTag, 1, hp.conv_groupnorm_num_groups); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_f32_kv (gguf, "stt.moonshine.conv_stem.groupnorm_eps",        kFamilyTag, 1e-5f, hp.conv_groupnorm_eps);    st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_u32_array_kv(gguf, "stt.moonshine.conv_stem.channels", kFamilyTag, hp.conv_channels);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st =
+            read_required_u32_array_kv(gguf, "stt.moonshine.conv_stem.kernel_sizes", kFamilyTag, hp.conv_kernel_sizes);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_array_kv(gguf, "stt.moonshine.conv_stem.strides", kFamilyTag, hp.conv_strides);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_u32_kv(gguf, "stt.moonshine.conv_stem.groupnorm_num_groups", kFamilyTag, 1,
+                                       hp.conv_groupnorm_num_groups);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_f32_kv(gguf, "stt.moonshine.conv_stem.groupnorm_eps", kFamilyTag, 1e-5f,
+                                       hp.conv_groupnorm_eps);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Frontend.
-    if (auto st = read_required_string_kv(gguf, "stt.frontend.type",        kFamilyTag, hp.fe_type);        st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv   (gguf, "stt.frontend.sample_rate", kFamilyTag, hp.fe_sample_rate); st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_string_kv(gguf, "stt.frontend.type", kFamilyTag, hp.fe_type); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.sample_rate", kFamilyTag, hp.fe_sample_rate);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Capability flags. Re-read here for in-decoder convenience; the
     // shared read_capability_kv() (called later in the load path) also
     // updates the public transcribe_capabilities struct.
-    if (auto st = read_optional_bool_kv(gguf, "stt.capability.lang_detect", kFamilyTag, false, hp.cap_lang_detect); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_bool_kv(gguf, "stt.capability.translate",   kFamilyTag, false, hp.cap_translate);   st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_bool_kv(gguf, "stt.capability.timestamps",  kFamilyTag, false, hp.cap_timestamps);  st != TRANSCRIBE_OK) return st;
+    if (auto st = read_optional_bool_kv(gguf, "stt.capability.lang_detect", kFamilyTag, false, hp.cap_lang_detect);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_bool_kv(gguf, "stt.capability.translate", kFamilyTag, false, hp.cap_translate);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_bool_kv(gguf, "stt.capability.timestamps", kFamilyTag, false, hp.cap_timestamps);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // ----- Cross-field invariants -----
     if (hp.enc_n_layers <= 0 || hp.enc_d_model <= 0 || hp.enc_n_heads <= 0 || hp.enc_ffn_dim <= 0) {
@@ -182,100 +289,81 @@ transcribe_status read_moonshine_hparams(const gguf_context * gguf,
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.enc_d_model % hp.enc_n_heads != 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine: enc d_model (%d) not divisible by n_heads (%d)",
-                     hp.enc_d_model, hp.enc_n_heads);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine: enc d_model (%d) not divisible by n_heads (%d)", hp.enc_d_model,
+                hp.enc_n_heads);
         return TRANSCRIBE_ERR_GGUF;
     }
-    if (hp.dec_n_layers <= 0 || hp.dec_d_model <= 0 || hp.dec_n_heads <= 0 ||
-        hp.dec_ffn_dim <= 0 || hp.dec_max_position_embeddings <= 0 ||
-        hp.dec_vocab_size <= 0)
-    {
+    if (hp.dec_n_layers <= 0 || hp.dec_d_model <= 0 || hp.dec_n_heads <= 0 || hp.dec_ffn_dim <= 0 ||
+        hp.dec_max_position_embeddings <= 0 || hp.dec_vocab_size <= 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine: decoder hparams must be positive");
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.dec_d_model % hp.dec_n_heads != 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine: dec d_model (%d) not divisible by n_heads (%d)",
-                     hp.dec_d_model, hp.dec_n_heads);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine: dec d_model (%d) not divisible by n_heads (%d)", hp.dec_d_model,
+                hp.dec_n_heads);
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.enc_d_model != hp.dec_d_model) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine: encoder d_model (%d) != decoder d_model (%d); "
-                     "cross-attn would mismatch",
-                     hp.enc_d_model, hp.dec_d_model);
+                "moonshine: encoder d_model (%d) != decoder d_model (%d); "
+                "cross-attn would mismatch",
+                hp.enc_d_model, hp.dec_d_model);
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.enc_activation != "gelu") {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine: only \"gelu\" encoder activation is supported (got \"%s\")",
-                     hp.enc_activation.c_str());
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine: only \"gelu\" encoder activation is supported (got \"%s\")",
+                hp.enc_activation.c_str());
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.dec_activation != "silu") {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine: only \"silu\" decoder activation is supported (got \"%s\")",
-                     hp.dec_activation.c_str());
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine: only \"silu\" decoder activation is supported (got \"%s\")",
+                hp.dec_activation.c_str());
         return TRANSCRIBE_ERR_GGUF;
     }
     if (!hp.dec_tie_word_embeddings) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine: stt.moonshine.decoder.tie_word_embeddings=false "
-                     "is not supported (no separate lm_head tensor)");
+                "moonshine: stt.moonshine.decoder.tie_word_embeddings=false "
+                "is not supported (no separate lm_head tensor)");
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.attention_bias) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine: stt.moonshine.attention_bias=true is not supported "
-                     "(catalog has no attn bias slots)");
+                "moonshine: stt.moonshine.attention_bias=true is not supported "
+                "(catalog has no attn bias slots)");
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.partial_rotary_factor <= 0.0f || hp.partial_rotary_factor > 1.0f) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine: invalid partial_rotary_factor=%g (expected (0, 1])",
-                     hp.partial_rotary_factor);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine: invalid partial_rotary_factor=%g (expected (0, 1])",
+                hp.partial_rotary_factor);
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.fe_type != "raw") {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine: unsupported frontend type \"%s\" (only \"raw\")",
-                     hp.fe_type.c_str());
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine: unsupported frontend type \"%s\" (only \"raw\")",
+                hp.fe_type.c_str());
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.fe_sample_rate != 16000) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine: unsupported sample_rate=%d (only 16000 Hz)",
-                     hp.fe_sample_rate);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine: unsupported sample_rate=%d (only 16000 Hz)", hp.fe_sample_rate);
         return TRANSCRIBE_ERR_GGUF;
     }
-    if (hp.conv_channels.size() != 3 || hp.conv_kernel_sizes.size() != 3 ||
-        hp.conv_strides.size() != 3)
-    {
+    if (hp.conv_channels.size() != 3 || hp.conv_kernel_sizes.size() != 3 || hp.conv_strides.size() != 3) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine: conv stem expected 3 entries each "
-                     "(channels=%zu, kernel_sizes=%zu, strides=%zu)",
-                     hp.conv_channels.size(),
-                     hp.conv_kernel_sizes.size(),
-                     hp.conv_strides.size());
+                "moonshine: conv stem expected 3 entries each "
+                "(channels=%zu, kernel_sizes=%zu, strides=%zu)",
+                hp.conv_channels.size(), hp.conv_kernel_sizes.size(), hp.conv_strides.size());
         return TRANSCRIBE_ERR_GGUF;
     }
-    if (hp.conv_channels[0] != hp.enc_d_model ||
-        hp.conv_channels[2] != hp.enc_d_model)
-    {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine: conv stem channels [%d, %d, %d] disagree with enc_d_model=%d",
-                     hp.conv_channels[0], hp.conv_channels[1], hp.conv_channels[2],
-                     hp.enc_d_model);
+    if (hp.conv_channels[0] != hp.enc_d_model || hp.conv_channels[2] != hp.enc_d_model) {
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine: conv stem channels [%d, %d, %d] disagree with enc_d_model=%d",
+                hp.conv_channels[0], hp.conv_channels[1], hp.conv_channels[2], hp.enc_d_model);
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.conv_groupnorm_num_groups != 1) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine: only num_groups=1 GroupNorm is supported (got %d)",
-                     hp.conv_groupnorm_num_groups);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine: only num_groups=1 GroupNorm is supported (got %d)",
+                hp.conv_groupnorm_num_groups);
         return TRANSCRIBE_ERR_GGUF;
     }
-    if (hp.bos_token_id < 0 || hp.eos_token_id < 0 ||
-        hp.pad_token_id < 0 || hp.decoder_start_token_id < 0)
-    {
+    if (hp.bos_token_id < 0 || hp.eos_token_id < 0 || hp.pad_token_id < 0 || hp.decoder_start_token_id < 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine: special token IDs must be set");
         return TRANSCRIBE_ERR_GGUF;
     }
@@ -293,54 +381,53 @@ using transcribe::weights::lname;
 
 constexpr const char * kTag = kFamilyTag;
 
-#define GET_F32(slot, name, ...) \
-    do { \
-        ggml_tensor * _t = transcribe::weights::find_tensor( \
-            ctx_meta, (name), \
-            {GGML_TYPE_F32}, {__VA_ARGS__}, kTag); \
-        if (_t == nullptr) return TRANSCRIBE_ERR_GGUF; \
-        (slot) = _t; \
+#define GET_F32(slot, name, ...)                                                                          \
+    do {                                                                                                  \
+        ggml_tensor * _t =                                                                                \
+            transcribe::weights::find_tensor(ctx_meta, (name), { GGML_TYPE_F32 }, { __VA_ARGS__ }, kTag); \
+        if (_t == nullptr)                                                                                \
+            return TRANSCRIBE_ERR_GGUF;                                                                   \
+        (slot) = _t;                                                                                      \
     } while (0)
 
-#define GET_CONV(slot, name, ...) \
-    do { \
-        ggml_tensor * _t = transcribe::weights::find_tensor( \
-            ctx_meta, (name), \
-            {TRANSCRIBE_QUANT_CONV_TYPES}, \
-            {__VA_ARGS__}, kTag); \
-        if (_t == nullptr) return TRANSCRIBE_ERR_GGUF; \
-        (slot) = _t; \
+#define GET_CONV(slot, name, ...)                                                                              \
+    do {                                                                                                       \
+        ggml_tensor * _t = transcribe::weights::find_tensor(ctx_meta, (name), { TRANSCRIBE_QUANT_CONV_TYPES }, \
+                                                            { __VA_ARGS__ }, kTag);                            \
+        if (_t == nullptr)                                                                                     \
+            return TRANSCRIBE_ERR_GGUF;                                                                        \
+        (slot) = _t;                                                                                           \
     } while (0)
 
-#define GET_LIN(slot, name, ...) \
-    do { \
-        ggml_tensor * _t = transcribe::weights::find_tensor( \
-            ctx_meta, (name), \
-            {TRANSCRIBE_QUANT_LINEAR_TYPES}, \
-            {__VA_ARGS__}, kTag); \
-        if (_t == nullptr) return TRANSCRIBE_ERR_GGUF; \
-        (slot) = _t; \
+#define GET_LIN(slot, name, ...)                                                                                 \
+    do {                                                                                                         \
+        ggml_tensor * _t = transcribe::weights::find_tensor(ctx_meta, (name), { TRANSCRIBE_QUANT_LINEAR_TYPES }, \
+                                                            { __VA_ARGS__ }, kTag);                              \
+        if (_t == nullptr)                                                                                       \
+            return TRANSCRIBE_ERR_GGUF;                                                                          \
+        (slot) = _t;                                                                                             \
     } while (0)
 
-} // namespace
+}  // namespace
 
 transcribe_status build_moonshine_weights(ggml_context *           ctx_meta,
                                           const MoonshineHParams & hp,
-                                          MoonshineWeights &       weights)
-{
-    if (ctx_meta == nullptr) return TRANSCRIBE_ERR_INVALID_ARG;
-
-    const int64_t d_model     = hp.enc_d_model;
-    const int64_t enc_ff      = hp.enc_ffn_dim;
-    const int64_t dec_h       = hp.dec_d_model;
-    const int64_t dec_ff      = hp.dec_ffn_dim;
-    const int64_t vocab_size  = hp.dec_vocab_size;
-    const int64_t k0 = hp.conv_kernel_sizes[0];
-    const int64_t k1 = hp.conv_kernel_sizes[1];
-    const int64_t k2 = hp.conv_kernel_sizes[2];
-    const int64_t c0 = hp.conv_channels[0];     // enc_d_model
-    const int64_t c1 = hp.conv_channels[1];     // 2·enc_d_model on tiny
-    const int64_t c2 = hp.conv_channels[2];     // enc_d_model
+                                          MoonshineWeights &       weights) {
+    if (ctx_meta == nullptr) {
+        return TRANSCRIBE_ERR_INVALID_ARG;
+    }
+
+    const int64_t d_model    = hp.enc_d_model;
+    const int64_t enc_ff     = hp.enc_ffn_dim;
+    const int64_t dec_h      = hp.dec_d_model;
+    const int64_t dec_ff     = hp.dec_ffn_dim;
+    const int64_t vocab_size = hp.dec_vocab_size;
+    const int64_t k0         = hp.conv_kernel_sizes[0];
+    const int64_t k1         = hp.conv_kernel_sizes[1];
+    const int64_t k2         = hp.conv_kernel_sizes[2];
+    const int64_t c0         = hp.conv_channels[0];  // enc_d_model
+    const int64_t c1         = hp.conv_channels[1];  // 2·enc_d_model on tiny
+    const int64_t c2         = hp.conv_channels[2];  // enc_d_model
 
     // ----- encoder conv stem -----
     // PyTorch Conv1d weight is [out, in, K]; ggml ne is [K, in, out].
@@ -348,11 +435,11 @@ transcribe_status build_moonshine_weights(ggml_context *           ctx_meta,
     // Conv1d(bias=False)).
     GET_CONV(weights.enc_stem.conv0_w, "enc.conv.0.weight", k0, /*in=*/1, /*out=*/c0);
     GET_CONV(weights.enc_stem.conv1_w, "enc.conv.1.weight", k1, c0, c1);
-    GET_F32 (weights.enc_stem.conv1_b, "enc.conv.1.bias",   c1);
+    GET_F32(weights.enc_stem.conv1_b, "enc.conv.1.bias", c1);
     GET_CONV(weights.enc_stem.conv2_w, "enc.conv.2.weight", k2, c1, c2);
-    GET_F32 (weights.enc_stem.conv2_b, "enc.conv.2.bias",   c2);
-    GET_F32 (weights.enc_stem.gn_w,    "enc.conv.norm.weight", d_model);
-    GET_F32 (weights.enc_stem.gn_b,    "enc.conv.norm.bias",   d_model);
+    GET_F32(weights.enc_stem.conv2_b, "enc.conv.2.bias", c2);
+    GET_F32(weights.enc_stem.gn_w, "enc.conv.norm.weight", d_model);
+    GET_F32(weights.enc_stem.gn_b, "enc.conv.norm.bias", d_model);
 
     // ----- encoder top -----
     GET_F32(weights.enc_top.final_norm_w, "enc.final_norm.weight", d_model);
@@ -363,16 +450,16 @@ transcribe_status build_moonshine_weights(ggml_context *           ctx_meta,
         auto & b = weights.enc_blocks[i];
 
         GET_F32(b.norm_attn_w, lname("enc.blocks.%d.norm_attn.weight", i), d_model);
-        GET_LIN(b.attn_q_w,    lname("enc.blocks.%d.attn.q.weight",    i), d_model, d_model);
-        GET_LIN(b.attn_k_w,    lname("enc.blocks.%d.attn.k.weight",    i), d_model, d_model);
-        GET_LIN(b.attn_v_w,    lname("enc.blocks.%d.attn.v.weight",    i), d_model, d_model);
-        GET_LIN(b.attn_out_w,  lname("enc.blocks.%d.attn.out.weight",  i), d_model, d_model);
-
-        GET_F32(b.norm_ffn_w,  lname("enc.blocks.%d.norm_ffn.weight",  i), d_model);
-        GET_LIN(b.ffn_fc1_w,   lname("enc.blocks.%d.ffn.fc1.weight",   i), d_model, enc_ff);
-        GET_F32(b.ffn_fc1_b,   lname("enc.blocks.%d.ffn.fc1.bias",     i), enc_ff);
-        GET_LIN(b.ffn_fc2_w,   lname("enc.blocks.%d.ffn.fc2.weight",   i), enc_ff,  d_model);
-        GET_F32(b.ffn_fc2_b,   lname("enc.blocks.%d.ffn.fc2.bias",     i), d_model);
+        GET_LIN(b.attn_q_w, lname("enc.blocks.%d.attn.q.weight", i), d_model, d_model);
+        GET_LIN(b.attn_k_w, lname("enc.blocks.%d.attn.k.weight", i), d_model, d_model);
+        GET_LIN(b.attn_v_w, lname("enc.blocks.%d.attn.v.weight", i), d_model, d_model);
+        GET_LIN(b.attn_out_w, lname("enc.blocks.%d.attn.out.weight", i), d_model, d_model);
+
+        GET_F32(b.norm_ffn_w, lname("enc.blocks.%d.norm_ffn.weight", i), d_model);
+        GET_LIN(b.ffn_fc1_w, lname("enc.blocks.%d.ffn.fc1.weight", i), d_model, enc_ff);
+        GET_F32(b.ffn_fc1_b, lname("enc.blocks.%d.ffn.fc1.bias", i), enc_ff);
+        GET_LIN(b.ffn_fc2_w, lname("enc.blocks.%d.ffn.fc2.weight", i), enc_ff, d_model);
+        GET_F32(b.ffn_fc2_b, lname("enc.blocks.%d.ffn.fc2.bias", i), d_model);
     }
 
     // ----- decoder top (tied embed + final LN) -----
@@ -385,25 +472,25 @@ transcribe_status build_moonshine_weights(ggml_context *           ctx_meta,
         auto & b = weights.dec_blocks[i];
 
         // Self-attn (bias-less).
-        GET_F32(b.norm_self_w, lname("dec.blocks.%d.norm_self.weight",    i), dec_h);
-        GET_LIN(b.self_q_w,    lname("dec.blocks.%d.self_attn.q.weight",  i), dec_h, dec_h);
-        GET_LIN(b.self_k_w,    lname("dec.blocks.%d.self_attn.k.weight",  i), dec_h, dec_h);
-        GET_LIN(b.self_v_w,    lname("dec.blocks.%d.self_attn.v.weight",  i), dec_h, dec_h);
-        GET_LIN(b.self_out_w,  lname("dec.blocks.%d.self_attn.out.weight",i), dec_h, dec_h);
+        GET_F32(b.norm_self_w, lname("dec.blocks.%d.norm_self.weight", i), dec_h);
+        GET_LIN(b.self_q_w, lname("dec.blocks.%d.self_attn.q.weight", i), dec_h, dec_h);
+        GET_LIN(b.self_k_w, lname("dec.blocks.%d.self_attn.k.weight", i), dec_h, dec_h);
+        GET_LIN(b.self_v_w, lname("dec.blocks.%d.self_attn.v.weight", i), dec_h, dec_h);
+        GET_LIN(b.self_out_w, lname("dec.blocks.%d.self_attn.out.weight", i), dec_h, dec_h);
 
         // Cross-attn (bias-less).
-        GET_F32(b.norm_cross_w, lname("dec.blocks.%d.norm_cross.weight",     i), dec_h);
-        GET_LIN(b.cross_q_w,    lname("dec.blocks.%d.cross_attn.q.weight",   i), dec_h, dec_h);
-        GET_LIN(b.cross_k_w,    lname("dec.blocks.%d.cross_attn.k.weight",   i), dec_h, dec_h);
-        GET_LIN(b.cross_v_w,    lname("dec.blocks.%d.cross_attn.v.weight",   i), dec_h, dec_h);
-        GET_LIN(b.cross_out_w,  lname("dec.blocks.%d.cross_attn.out.weight", i), dec_h, dec_h);
+        GET_F32(b.norm_cross_w, lname("dec.blocks.%d.norm_cross.weight", i), dec_h);
+        GET_LIN(b.cross_q_w, lname("dec.blocks.%d.cross_attn.q.weight", i), dec_h, dec_h);
+        GET_LIN(b.cross_k_w, lname("dec.blocks.%d.cross_attn.k.weight", i), dec_h, dec_h);
+        GET_LIN(b.cross_v_w, lname("dec.blocks.%d.cross_attn.v.weight", i), dec_h, dec_h);
+        GET_LIN(b.cross_out_w, lname("dec.blocks.%d.cross_attn.out.weight", i), dec_h, dec_h);
 
         // SwiGLU MLP. fc1 packs [x_proj, gate]: hidden → 2·intermediate.
         GET_F32(b.norm_ffn_w, lname("dec.blocks.%d.norm_ffn.weight", i), dec_h);
-        GET_LIN(b.ffn_fc1_w,  lname("dec.blocks.%d.ffn.fc1.weight",  i), dec_h,  2 * dec_ff);
-        GET_F32(b.ffn_fc1_b,  lname("dec.blocks.%d.ffn.fc1.bias",    i), 2 * dec_ff);
-        GET_LIN(b.ffn_fc2_w,  lname("dec.blocks.%d.ffn.fc2.weight",  i), dec_ff, dec_h);
-        GET_F32(b.ffn_fc2_b,  lname("dec.blocks.%d.ffn.fc2.bias",    i), dec_h);
+        GET_LIN(b.ffn_fc1_w, lname("dec.blocks.%d.ffn.fc1.weight", i), dec_h, 2 * dec_ff);
+        GET_F32(b.ffn_fc1_b, lname("dec.blocks.%d.ffn.fc1.bias", i), 2 * dec_ff);
+        GET_LIN(b.ffn_fc2_w, lname("dec.blocks.%d.ffn.fc2.weight", i), dec_ff, dec_h);
+        GET_F32(b.ffn_fc2_b, lname("dec.blocks.%d.ffn.fc2.bias", i), dec_h);
     }
 
     return TRANSCRIBE_OK;
@@ -413,4 +500,4 @@ transcribe_status build_moonshine_weights(ggml_context *           ctx_meta,
 #undef GET_CONV
 #undef GET_LIN
 
-} // namespace transcribe::moonshine
+}  // namespace transcribe::moonshine
diff --git a/src/arch/moonshine/weights.h b/src/arch/moonshine/weights.h
index 76596285..65cb7617 100644
--- a/src/arch/moonshine/weights.h
+++ b/src/arch/moonshine/weights.h
@@ -66,24 +66,24 @@ namespace transcribe::moonshine {
 
 struct MoonshineHParams {
     // Encoder.
-    int32_t enc_n_layers     = 0;
-    int32_t enc_d_model      = 0;
-    int32_t enc_n_heads      = 0;
-    int32_t enc_n_kv_heads   = 0;   // moonshine has no GQA on tiny: == n_heads
-    int32_t enc_ffn_dim      = 0;   // intermediate_size
-    std::string enc_activation;     // "gelu"
+    int32_t     enc_n_layers   = 0;
+    int32_t     enc_d_model    = 0;
+    int32_t     enc_n_heads    = 0;
+    int32_t     enc_n_kv_heads = 0;  // moonshine has no GQA on tiny: == n_heads
+    int32_t     enc_ffn_dim    = 0;  // intermediate_size
+    std::string enc_activation;      // "gelu"
 
     // Decoder.
-    int32_t dec_n_layers     = 0;
-    int32_t dec_d_model      = 0;   // == enc_d_model on every shipped variant
-    int32_t dec_n_heads      = 0;
-    int32_t dec_n_kv_heads   = 0;
-    int32_t dec_ffn_dim      = 0;   // intermediate_size (fc1 emits 2·this)
-    int32_t dec_max_position_embeddings = 0;  // 194 for tiny; both target
-                                              // length cap and rope max-seq
-    int32_t dec_vocab_size   = 0;
-    std::string dec_activation;     // "silu"
-    bool    dec_tie_word_embeddings = true;
+    int32_t     dec_n_layers                = 0;
+    int32_t     dec_d_model                 = 0;  // == enc_d_model on every shipped variant
+    int32_t     dec_n_heads                 = 0;
+    int32_t     dec_n_kv_heads              = 0;
+    int32_t     dec_ffn_dim                 = 0;  // intermediate_size (fc1 emits 2·this)
+    int32_t     dec_max_position_embeddings = 0;  // 194 for tiny; both target
+                                                  // length cap and rope max-seq
+    int32_t     dec_vocab_size              = 0;
+    std::string dec_activation;                   // "silu"
+    bool        dec_tie_word_embeddings = true;
 
     // Special tokens.
     int32_t bos_token_id           = -1;  // 1, decoder_start
@@ -95,18 +95,18 @@ struct MoonshineHParams {
     float   partial_rotary_factor = 0.9f;
     float   rope_theta            = 10000.0f;
     bool    attention_bias        = false;
-    int32_t pad_head_dim_multiple = 0;   // 8 for tiny; 0 means "do not pad"
+    int32_t pad_head_dim_multiple = 0;  // 8 for tiny; 0 means "do not pad"
 
     // Conv stem (3-layer raw-PCM frontend).
-    std::vector<int32_t> conv_channels;     // [enc_d_model, 2·enc_d_model, enc_d_model]
-    std::vector<int32_t> conv_kernel_sizes; // [127, 7, 3]
-    std::vector<int32_t> conv_strides;      // [64, 3, 2]
-    int32_t conv_groupnorm_num_groups = 1;
-    float   conv_groupnorm_eps        = 1e-5f;
+    std::vector<int32_t> conv_channels;      // [enc_d_model, 2·enc_d_model, enc_d_model]
+    std::vector<int32_t> conv_kernel_sizes;  // [127, 7, 3]
+    std::vector<int32_t> conv_strides;       // [64, 3, 2]
+    int32_t              conv_groupnorm_num_groups = 1;
+    float                conv_groupnorm_eps        = 1e-5f;
 
     // Frontend (raw waveform — no mel).
-    std::string fe_type;            // "raw"
-    int32_t     fe_sample_rate = 0; // 16000
+    std::string fe_type;             // "raw"
+    int32_t     fe_sample_rate = 0;  // 16000
 
     // Capability flags read from stt.capability.*.
     bool cap_lang_detect = false;
@@ -115,6 +115,7 @@ struct MoonshineHParams {
 
     // Derived helpers.
     int32_t enc_head_dim() const { return enc_n_heads > 0 ? enc_d_model / enc_n_heads : 0; }
+
     int32_t dec_head_dim() const { return dec_n_heads > 0 ? dec_d_model / dec_n_heads : 0; }
 
     // Padded head dim used inside attention. HF Moonshine pads each
@@ -126,13 +127,18 @@ struct MoonshineHParams {
     int32_t enc_head_dim_padded() const {
         const int32_t hd = enc_head_dim();
         const int32_t m  = pad_head_dim_multiple;
-        if (m <= 0 || hd <= 0) return hd;
+        if (m <= 0 || hd <= 0) {
+            return hd;
+        }
         return ((hd + m - 1) / m) * m;
     }
+
     int32_t dec_head_dim_padded() const {
         const int32_t hd = dec_head_dim();
         const int32_t m  = pad_head_dim_multiple;
-        if (m <= 0 || hd <= 0) return hd;
+        if (m <= 0 || hd <= 0) {
+            return hd;
+        }
         return ((hd + m - 1) / m) * m;
     }
 
@@ -145,17 +151,17 @@ struct MoonshineHParams {
     int32_t enc_head_dim_rot() const {
         const int32_t hd = enc_head_dim();
         const int32_t r  = static_cast<int32_t>(static_cast<float>(hd) * partial_rotary_factor);
-        return r & ~int32_t{1};
+        return r & ~int32_t{ 1 };
     }
+
     int32_t dec_head_dim_rot() const {
         const int32_t hd = dec_head_dim();
         const int32_t r  = static_cast<int32_t>(static_cast<float>(hd) * partial_rotary_factor);
-        return r & ~int32_t{1};
+        return r & ~int32_t{ 1 };
     }
 };
 
-transcribe_status read_moonshine_hparams(const gguf_context * gguf,
-                                         MoonshineHParams &   hp);
+transcribe_status read_moonshine_hparams(const gguf_context * gguf, MoonshineHParams & hp);
 
 // ---------------------------------------------------------------------------
 // Weight slots
@@ -163,13 +169,13 @@ transcribe_status read_moonshine_hparams(const gguf_context * gguf,
 
 // Encoder conv stem: 3 Conv1d layers + GroupNorm right after conv0+tanh.
 struct MoonshineEncStem {
-    ggml_tensor * conv0_w     = nullptr;  // [127, 1,         d_model],   no bias
-    ggml_tensor * conv1_w     = nullptr;  // [7,   d_model,   2·d_model]
-    ggml_tensor * conv1_b     = nullptr;  // [2·d_model]
-    ggml_tensor * conv2_w     = nullptr;  // [3,   2·d_model, d_model]
-    ggml_tensor * conv2_b     = nullptr;  // [d_model]
-    ggml_tensor * gn_w        = nullptr;  // [d_model]   (num_groups=1, ε=1e-5)
-    ggml_tensor * gn_b        = nullptr;  // [d_model]
+    ggml_tensor * conv0_w = nullptr;  // [127, 1,         d_model],   no bias
+    ggml_tensor * conv1_w = nullptr;  // [7,   d_model,   2·d_model]
+    ggml_tensor * conv1_b = nullptr;  // [2·d_model]
+    ggml_tensor * conv2_w = nullptr;  // [3,   2·d_model, d_model]
+    ggml_tensor * conv2_b = nullptr;  // [d_model]
+    ggml_tensor * gn_w    = nullptr;  // [d_model]   (num_groups=1, ε=1e-5)
+    ggml_tensor * gn_b    = nullptr;  // [d_model]
 };
 
 struct MoonshineEncTop {
@@ -185,11 +191,11 @@ struct MoonshineEncBlock {
     ggml_tensor * attn_v_w    = nullptr;
     ggml_tensor * attn_out_w  = nullptr;
 
-    ggml_tensor * norm_ffn_w  = nullptr;
-    ggml_tensor * ffn_fc1_w   = nullptr;  // [d_model, ffn_dim]
-    ggml_tensor * ffn_fc1_b   = nullptr;  // [ffn_dim]
-    ggml_tensor * ffn_fc2_w   = nullptr;  // [ffn_dim, d_model]
-    ggml_tensor * ffn_fc2_b   = nullptr;  // [d_model]
+    ggml_tensor * norm_ffn_w = nullptr;
+    ggml_tensor * ffn_fc1_w  = nullptr;  // [d_model, ffn_dim]
+    ggml_tensor * ffn_fc1_b  = nullptr;  // [ffn_dim]
+    ggml_tensor * ffn_fc2_w  = nullptr;  // [ffn_dim, d_model]
+    ggml_tensor * ffn_fc2_b  = nullptr;  // [d_model]
 };
 
 // Decoder top: tied token embed + final LN.
@@ -202,11 +208,11 @@ struct MoonshineDecTop {
 // cross-attn. Decoder MLP is SwiGLU: fc1 emits 2·ffn_dim, fc2 takes ffn_dim.
 struct MoonshineDecBlock {
     // Self-attention (causal, partial RoPE on q/k).
-    ggml_tensor * norm_self_w  = nullptr;
-    ggml_tensor * self_q_w     = nullptr;
-    ggml_tensor * self_k_w     = nullptr;
-    ggml_tensor * self_v_w     = nullptr;
-    ggml_tensor * self_out_w   = nullptr;
+    ggml_tensor * norm_self_w = nullptr;
+    ggml_tensor * self_q_w    = nullptr;
+    ggml_tensor * self_k_w    = nullptr;
+    ggml_tensor * self_v_w    = nullptr;
+    ggml_tensor * self_out_w  = nullptr;
 
     // Cross-attention (queries decoder state against encoder; no RoPE).
     ggml_tensor * norm_cross_w = nullptr;
@@ -216,23 +222,23 @@ struct MoonshineDecBlock {
     ggml_tensor * cross_out_w  = nullptr;
 
     // SwiGLU MLP.
-    ggml_tensor * norm_ffn_w   = nullptr;
-    ggml_tensor * ffn_fc1_w    = nullptr;  // [d_model, 2·ffn_dim]
-    ggml_tensor * ffn_fc1_b    = nullptr;  // [2·ffn_dim]
-    ggml_tensor * ffn_fc2_w    = nullptr;  // [ffn_dim, d_model]
-    ggml_tensor * ffn_fc2_b    = nullptr;  // [d_model]
+    ggml_tensor * norm_ffn_w = nullptr;
+    ggml_tensor * ffn_fc1_w  = nullptr;  // [d_model, 2·ffn_dim]
+    ggml_tensor * ffn_fc1_b  = nullptr;  // [2·ffn_dim]
+    ggml_tensor * ffn_fc2_w  = nullptr;  // [ffn_dim, d_model]
+    ggml_tensor * ffn_fc2_b  = nullptr;  // [d_model]
 };
 
 struct MoonshineWeights {
-    MoonshineEncStem                 enc_stem;
-    MoonshineEncTop                  enc_top;
-    std::vector<MoonshineEncBlock>   enc_blocks;
-    MoonshineDecTop                  dec_top;
-    std::vector<MoonshineDecBlock>   dec_blocks;
+    MoonshineEncStem               enc_stem;
+    MoonshineEncTop                enc_top;
+    std::vector<MoonshineEncBlock> enc_blocks;
+    MoonshineDecTop                dec_top;
+    std::vector<MoonshineDecBlock> dec_blocks;
 };
 
 transcribe_status build_moonshine_weights(ggml_context *           ctx_meta,
                                           const MoonshineHParams & hp,
                                           MoonshineWeights &       weights);
 
-} // namespace transcribe::moonshine
+}  // namespace transcribe::moonshine
diff --git a/src/arch/moonshine_streaming/capabilities.cpp b/src/arch/moonshine_streaming/capabilities.cpp
index 6468df22..5812f181 100644
--- a/src/arch/moonshine_streaming/capabilities.cpp
+++ b/src/arch/moonshine_streaming/capabilities.cpp
@@ -26,7 +26,7 @@ void apply_family_invariants(transcribe_model & model) {
     // stream_finalize only tops up the trailing tail and runs a final AR
     // decode when frames advanced past the last partial (otherwise it just
     // commits the last partial transcript).
-    caps.supports_streaming            = true;
+    caps.supports_streaming = true;
 
     // Streaming latency characteristics (≈240 ms cumulative encoder
     // right-context, natural 20 ms emit unit, family-recommended 80 ms
@@ -40,4 +40,4 @@ void apply_family_invariants(transcribe_model & model) {
     transcribe::set_feature(&model, TRANSCRIBE_FEATURE_CANCELLATION, true);
 }
 
-} // namespace transcribe::moonshine_streaming
+}  // namespace transcribe::moonshine_streaming
diff --git a/src/arch/moonshine_streaming/decoder.cpp b/src/arch/moonshine_streaming/decoder.cpp
index 8a785ad5..36619195 100644
--- a/src/arch/moonshine_streaming/decoder.cpp
+++ b/src/arch/moonshine_streaming/decoder.cpp
@@ -15,15 +15,13 @@
 
 #include "decoder.h"
 
+#include "conformer/conformer.h"
 #include "encoder.h"
+#include "ggml.h"
 #include "moonshine_streaming.h"
-#include "weights.h"
-
-#include "conformer/conformer.h"
 #include "transcribe-debug.h"
 #include "transcribe-log.h"
-
-#include "ggml.h"
+#include "weights.h"
 
 #include <cmath>
 #include <cstdio>
@@ -33,21 +31,21 @@ namespace transcribe::moonshine_streaming {
 namespace {
 
 namespace conf = transcribe::conformer;
-using conf::named;
 using conf::layer_norm;
+using conf::named;
 
 ggml_tensor * pad_head_dim(ggml_context * ctx, ggml_tensor * t, int pad) {
-    if (pad <= 0) return t;
+    if (pad <= 0) {
+        return t;
+    }
     return ggml_pad(ctx, t, /*p0=*/pad, /*p1=*/0, /*p2=*/0, /*p3=*/0);
 }
 
-ggml_tensor * unpad_head_dim(ggml_context * ctx, ggml_tensor * t,
-                             int head_dim, int pad)
-{
-    if (pad <= 0) return t;
-    return ggml_view_3d(ctx, t,
-                        head_dim, t->ne[1], t->ne[2],
-                        t->nb[1], t->nb[2], 0);
+ggml_tensor * unpad_head_dim(ggml_context * ctx, ggml_tensor * t, int head_dim, int pad) {
+    if (pad <= 0) {
+        return t;
+    }
+    return ggml_view_3d(ctx, t, head_dim, t->ne[1], t->ne[2], t->nb[1], t->nb[2], 0);
 }
 
 // Decoder uses GPT-J / interleaved RoPE (`rotate_half` slices
@@ -56,44 +54,41 @@ ggml_tensor * apply_partial_rope(ggml_context *                    ctx,
                                  ggml_tensor *                     x,
                                  ggml_tensor *                     positions,
                                  const MoonshineStreamingHParams & hp,
-                                 int                               head_dim_rot)
-{
-    return ggml_rope_ext(
-        ctx, x, positions, /*c=*/nullptr,
-        head_dim_rot,
-        GGML_ROPE_TYPE_NORMAL,
-        /*n_ctx_orig=*/0,
-        hp.rope_theta,
-        /*freq_scale=*/1.0f,
-        /*ext_factor=*/0.0f,
-        /*attn_factor=*/1.0f,
-        /*beta_fast=*/32.0f,
-        /*beta_slow=*/1.0f);
+                                 int                               head_dim_rot) {
+    return ggml_rope_ext(ctx, x, positions, /*c=*/nullptr, head_dim_rot, GGML_ROPE_TYPE_NORMAL,
+                         /*n_ctx_orig=*/0, hp.rope_theta,
+                         /*freq_scale=*/1.0f,
+                         /*ext_factor=*/0.0f,
+                         /*attn_factor=*/1.0f,
+                         /*beta_fast=*/32.0f,
+                         /*beta_slow=*/1.0f);
 }
 
 // SwiGLU MLP: fc1 -> 2·ffn_dim, chunk(2, dim=-1) into [x_proj, gate]
 // (innermost dim = ggml ne[0]), out = silu(gate) * x_proj, fc2.
 ggml_tensor * ffn_decoder_swiglu(ggml_context * ctx,
                                  ggml_tensor *  x,
-                                 ggml_tensor *  fc1_w, ggml_tensor * fc1_b,
-                                 ggml_tensor *  fc2_w, ggml_tensor * fc2_b,
-                                 int            ffn_dim)
-{
+                                 ggml_tensor *  fc1_w,
+                                 ggml_tensor *  fc1_b,
+                                 ggml_tensor *  fc2_w,
+                                 ggml_tensor *  fc2_b,
+                                 int            ffn_dim) {
     ggml_tensor * h = ggml_mul_mat(ctx, fc1_w, x);
-    if (fc1_b != nullptr) h = ggml_add(ctx, h, fc1_b);
+    if (fc1_b != nullptr) {
+        h = ggml_add(ctx, h, fc1_b);
+    }
     const int64_t T          = h->ne[1];
     const size_t  el         = ggml_element_size(h);
     const size_t  half_bytes = static_cast<size_t>(ffn_dim) * el;
 
-    ggml_tensor * x_proj = ggml_view_2d(ctx, h, ffn_dim, T,
-                                        h->nb[1], 0);
-    ggml_tensor * gate   = ggml_view_2d(ctx, h, ffn_dim, T,
-                                        h->nb[1], half_bytes);
+    ggml_tensor * x_proj = ggml_view_2d(ctx, h, ffn_dim, T, h->nb[1], 0);
+    ggml_tensor * gate   = ggml_view_2d(ctx, h, ffn_dim, T, h->nb[1], half_bytes);
 
-    ggml_tensor * y = ggml_mul(ctx, ggml_silu(ctx, ggml_cont(ctx, gate)),
-                                    ggml_cont(ctx, x_proj));
+    ggml_tensor * y = ggml_mul(ctx, ggml_silu(ctx, ggml_cont(ctx, gate)), ggml_cont(ctx, x_proj));
     ggml_tensor * o = ggml_mul_mat(ctx, fc2_w, y);
-    if (fc2_b != nullptr) o = ggml_add(ctx, o, fc2_b);
+    if (fc2_b != nullptr) {
+        o = ggml_add(ctx, o, fc2_b);
+    }
     return o;
 }
 
@@ -114,8 +109,7 @@ ggml_tensor * mha_self_cached(ggml_context *                    ctx,
                               int                               n_past,
                               int                               n_tokens,
                               int                               n_kv,
-                              bool                              use_flash)
-{
+                              bool                              use_flash) {
     const int   head_dim     = d_model / n_heads;
     const int   head_dim_pad = hp.dec_head_dim_padded();
     const int   head_dim_rot = hp.dec_head_dim_rot();
@@ -143,42 +137,26 @@ ggml_tensor * mha_self_cached(ggml_context *                    ctx,
         const size_t k_elem = ggml_element_size(kv_cache.self_k);
         const size_t v_elem = ggml_element_size(kv_cache.self_v);
 
-        ggml_tensor * k_dst = ggml_view_1d(
-            ctx, kv_cache.self_k,
-            static_cast<int64_t>(n_tokens) * d_model,
-            k_elem * static_cast<size_t>(
-                static_cast<int64_t>(il) * n_ctx * d_model +
-                static_cast<int64_t>(n_past) * d_model));
-        ggml_tensor * v_dst = ggml_view_1d(
-            ctx, kv_cache.self_v,
-            static_cast<int64_t>(n_tokens) * d_model,
-            v_elem * static_cast<size_t>(
-                static_cast<int64_t>(il) * n_ctx * d_model +
-                static_cast<int64_t>(n_past) * d_model));
+        ggml_tensor * k_dst = ggml_view_1d(ctx, kv_cache.self_k, static_cast<int64_t>(n_tokens) * d_model,
+                                           k_elem * static_cast<size_t>(static_cast<int64_t>(il) * n_ctx * d_model +
+                                                                        static_cast<int64_t>(n_past) * d_model));
+        ggml_tensor * v_dst = ggml_view_1d(ctx, kv_cache.self_v, static_cast<int64_t>(n_tokens) * d_model,
+                                           v_elem * static_cast<size_t>(static_cast<int64_t>(il) * n_ctx * d_model +
+                                                                        static_cast<int64_t>(n_past) * d_model));
 
         ggml_build_forward_expand(gf, ggml_cpy(ctx, K_rope, k_dst));
-        ggml_build_forward_expand(gf, ggml_cpy(ctx, Vcur,   v_dst));
-    }
-
-    const size_t k_elem = ggml_element_size(kv_cache.self_k);
-    ggml_tensor * K = ggml_view_3d(
-        ctx, kv_cache.self_k,
-        head_dim, n_kv, n_heads,
-        k_elem * d_model,
-        k_elem * head_dim,
-        k_elem * static_cast<size_t>(
-            static_cast<int64_t>(il) * n_ctx * d_model));
-
-    const size_t v_elem = ggml_element_size(kv_cache.self_v);
-    ggml_tensor * V = ggml_view_3d(
-        ctx, kv_cache.self_v,
-        head_dim, n_kv, n_heads,
-        v_elem * d_model,
-        v_elem * head_dim,
-        v_elem * static_cast<size_t>(
-            static_cast<int64_t>(il) * n_ctx * d_model));
-
-    ggml_tensor * Q = pad_head_dim(ctx, Q_unpad, pad);
+        ggml_build_forward_expand(gf, ggml_cpy(ctx, Vcur, v_dst));
+    }
+
+    const size_t  k_elem = ggml_element_size(kv_cache.self_k);
+    ggml_tensor * K = ggml_view_3d(ctx, kv_cache.self_k, head_dim, n_kv, n_heads, k_elem * d_model, k_elem * head_dim,
+                                   k_elem * static_cast<size_t>(static_cast<int64_t>(il) * n_ctx * d_model));
+
+    const size_t  v_elem = ggml_element_size(kv_cache.self_v);
+    ggml_tensor * V = ggml_view_3d(ctx, kv_cache.self_v, head_dim, n_kv, n_heads, v_elem * d_model, v_elem * head_dim,
+                                   v_elem * static_cast<size_t>(static_cast<int64_t>(il) * n_ctx * d_model));
+
+    ggml_tensor * Q   = pad_head_dim(ctx, Q_unpad, pad);
     ggml_tensor * K_p = pad_head_dim(ctx, ggml_cont(ctx, K), pad);
     ggml_tensor * V_p = pad_head_dim(ctx, ggml_cont(ctx, V), pad);
 
@@ -190,8 +168,8 @@ ggml_tensor * mha_self_cached(ggml_context *                    ctx,
     } else {
         ggml_tensor * kq      = ggml_mul_mat(ctx, K_p, Q);
         ggml_tensor * kq_soft = ggml_soft_max_ext(ctx, kq, mask, scale, 0.0f);
-        ggml_tensor * v_t = ggml_cont(ctx, ggml_permute(ctx, V_p, 1, 0, 2, 3));
-        o = ggml_mul_mat(ctx, v_t, kq_soft);
+        ggml_tensor * v_t     = ggml_cont(ctx, ggml_permute(ctx, V_p, 1, 0, 2, 3));
+        o                     = ggml_mul_mat(ctx, v_t, kq_soft);
     }
 
     if (pad > 0) {
@@ -217,53 +195,40 @@ ggml_tensor * mha_cross_cached(ggml_context *                    ctx,
                                int                               d_model,
                                int                               il,
                                int                               T_enc,
-                               bool                              use_flash)
-{
-    const int   head_dim     = d_model / n_heads;
-    const int   head_dim_pad = hp.dec_head_dim_padded();
-    const int   pad          = head_dim_pad - head_dim;
-    const float scale        = 1.0f / std::sqrt(static_cast<float>(head_dim));
-    const int64_t n_tokens   = x->ne[1];
+                               bool                              use_flash) {
+    const int     head_dim     = d_model / n_heads;
+    const int     head_dim_pad = hp.dec_head_dim_padded();
+    const int     pad          = head_dim_pad - head_dim;
+    const float   scale        = 1.0f / std::sqrt(static_cast<float>(head_dim));
+    const int64_t n_tokens     = x->ne[1];
 
     ggml_tensor * Qcur = ggml_mul_mat(ctx, q_w, x);
-    ggml_tensor * Q = ggml_reshape_3d(ctx, Qcur, head_dim, n_heads, n_tokens);
-    Q = ggml_permute(ctx, Q, 0, 2, 1, 3);
-    Q = ggml_cont(ctx, Q);
-    Q = pad_head_dim(ctx, Q, pad);
+    ggml_tensor * Q    = ggml_reshape_3d(ctx, Qcur, head_dim, n_heads, n_tokens);
+    Q                  = ggml_permute(ctx, Q, 0, 2, 1, 3);
+    Q                  = ggml_cont(ctx, Q);
+    Q                  = pad_head_dim(ctx, Q, pad);
 
-    const size_t k_elem = ggml_element_size(kv_cache.cross_k);
-    ggml_tensor * K = ggml_view_3d(
-        ctx, kv_cache.cross_k,
-        head_dim, T_enc, n_heads,
-        k_elem * d_model,
-        k_elem * head_dim,
-        k_elem * static_cast<size_t>(
-            static_cast<int64_t>(il) * T_enc * d_model));
+    const size_t  k_elem = ggml_element_size(kv_cache.cross_k);
+    ggml_tensor * K = ggml_view_3d(ctx, kv_cache.cross_k, head_dim, T_enc, n_heads, k_elem * d_model, k_elem * head_dim,
+                                   k_elem * static_cast<size_t>(static_cast<int64_t>(il) * T_enc * d_model));
 
-    const size_t v_elem = ggml_element_size(kv_cache.cross_v);
-    ggml_tensor * V = ggml_view_3d(
-        ctx, kv_cache.cross_v,
-        head_dim, T_enc, n_heads,
-        v_elem * d_model,
-        v_elem * head_dim,
-        v_elem * static_cast<size_t>(
-            static_cast<int64_t>(il) * T_enc * d_model));
+    const size_t  v_elem = ggml_element_size(kv_cache.cross_v);
+    ggml_tensor * V = ggml_view_3d(ctx, kv_cache.cross_v, head_dim, T_enc, n_heads, v_elem * d_model, v_elem * head_dim,
+                                   v_elem * static_cast<size_t>(static_cast<int64_t>(il) * T_enc * d_model));
 
     ggml_tensor * K_p = pad_head_dim(ctx, ggml_cont(ctx, K), pad);
     ggml_tensor * V_p = pad_head_dim(ctx, ggml_cont(ctx, V), pad);
 
     ggml_tensor * o;
     if (use_flash) {
-        o = ggml_flash_attn_ext(ctx, Q, K_p, V_p, /*mask=*/nullptr,
-                                scale, 0.0f, 0.0f);
+        o = ggml_flash_attn_ext(ctx, Q, K_p, V_p, /*mask=*/nullptr, scale, 0.0f, 0.0f);
         o = ggml_permute(ctx, o, 0, 2, 1, 3);
         o = ggml_cont(ctx, o);
     } else {
         ggml_tensor * kq      = ggml_mul_mat(ctx, K_p, Q);
-        ggml_tensor * kq_soft = ggml_soft_max_ext(ctx, kq, /*mask=*/nullptr,
-                                                  scale, 0.0f);
-        ggml_tensor * v_t = ggml_cont(ctx, ggml_permute(ctx, V_p, 1, 0, 2, 3));
-        o = ggml_mul_mat(ctx, v_t, kq_soft);
+        ggml_tensor * kq_soft = ggml_soft_max_ext(ctx, kq, /*mask=*/nullptr, scale, 0.0f);
+        ggml_tensor * v_t     = ggml_cont(ctx, ggml_permute(ctx, V_p, 1, 0, 2, 3));
+        o                     = ggml_mul_mat(ctx, v_t, kq_soft);
     }
 
     if (pad > 0) {
@@ -277,20 +242,18 @@ ggml_tensor * mha_cross_cached(ggml_context *                    ctx,
     return o;
 }
 
-} // namespace
+}  // namespace
 
 // Adapter graph.
-AdapterBuild build_adapter_graph(ggml_context *                       ctx,
-                                 const MoonshineStreamingWeights &    w,
-                                 const MoonshineStreamingHParams &    hp,
-                                 int                                  T_enc)
-{
-    AdapterBuild ab {};
+AdapterBuild build_adapter_graph(ggml_context *                    ctx,
+                                 const MoonshineStreamingWeights & w,
+                                 const MoonshineStreamingHParams & hp,
+                                 int                               T_enc) {
+    AdapterBuild ab{};
 
     if (ctx == nullptr || T_enc <= 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine_streaming adapter: invalid arg (ctx=%p, T_enc=%d)",
-                     static_cast<void *>(ctx), T_enc);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine_streaming adapter: invalid arg (ctx=%p, T_enc=%d)",
+                static_cast<void *>(ctx), T_enc);
         return ab;
     }
 
@@ -317,8 +280,7 @@ AdapterBuild build_adapter_graph(ggml_context *                       ctx,
         y = ggml_mul_mat(ctx, w.adapter.proj_w, y);
     } else if (enc_h != dec_h) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine_streaming adapter: enc_h (%d) != dec_h (%d) but adapter_has_proj=false",
-                     enc_h, dec_h);
+                "moonshine_streaming adapter: enc_h (%d) != dec_h (%d) but adapter_has_proj=false", enc_h, dec_h);
         return ab;
     }
     named(y, "adapter.out");
@@ -328,8 +290,7 @@ AdapterBuild build_adapter_graph(ggml_context *                       ctx,
 
     ab.graph = ggml_new_graph_custom(ctx, 4096, false);
     if (ab.graph == nullptr) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine_streaming adapter: ggml_new_graph_custom failed");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine_streaming adapter: ggml_new_graph_custom failed");
         return ab;
     }
     // Build forward through both pos_emb (for the dump) and out.
@@ -340,18 +301,16 @@ AdapterBuild build_adapter_graph(ggml_context *                       ctx,
 }
 
 // Cross-KV precompute graph.
-DecoderBuild build_cross_kv_graph(ggml_context *                       ctx,
-                                  const MoonshineStreamingWeights &    w,
-                                  const MoonshineStreamingHParams &    hp,
-                                  MoonshineStreamingKvCache &          kv_cache,
-                                  int                                  T_enc)
-{
-    DecoderBuild db {};
+DecoderBuild build_cross_kv_graph(ggml_context *                    ctx,
+                                  const MoonshineStreamingWeights & w,
+                                  const MoonshineStreamingHParams & hp,
+                                  MoonshineStreamingKvCache &       kv_cache,
+                                  int                               T_enc) {
+    DecoderBuild db{};
 
     if (ctx == nullptr || T_enc <= 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine_streaming cross_kv: invalid arg (ctx=%p, T_enc=%d)",
-                     static_cast<void *>(ctx), T_enc);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine_streaming cross_kv: invalid arg (ctx=%p, T_enc=%d)",
+                static_cast<void *>(ctx), T_enc);
         return db;
     }
 
@@ -364,8 +323,7 @@ DecoderBuild build_cross_kv_graph(ggml_context *                       ctx,
 
     db.graph = ggml_new_graph_custom(ctx, 4096, false);
     if (db.graph == nullptr) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine_streaming cross_kv: ggml_new_graph_custom failed");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine_streaming cross_kv: ggml_new_graph_custom failed");
         return db;
     }
 
@@ -379,16 +337,10 @@ DecoderBuild build_cross_kv_graph(ggml_context *                       ctx,
         const size_t k_elem = ggml_element_size(kv_cache.cross_k);
         const size_t v_elem = ggml_element_size(kv_cache.cross_v);
 
-        ggml_tensor * k_dst = ggml_view_1d(
-            ctx, kv_cache.cross_k,
-            static_cast<int64_t>(T_enc) * d_model,
-            k_elem * static_cast<size_t>(
-                static_cast<int64_t>(il) * T_enc * d_model));
-        ggml_tensor * v_dst = ggml_view_1d(
-            ctx, kv_cache.cross_v,
-            static_cast<int64_t>(T_enc) * d_model,
-            v_elem * static_cast<size_t>(
-                static_cast<int64_t>(il) * T_enc * d_model));
+        ggml_tensor * k_dst = ggml_view_1d(ctx, kv_cache.cross_k, static_cast<int64_t>(T_enc) * d_model,
+                                           k_elem * static_cast<size_t>(static_cast<int64_t>(il) * T_enc * d_model));
+        ggml_tensor * v_dst = ggml_view_1d(ctx, kv_cache.cross_v, static_cast<int64_t>(T_enc) * d_model,
+                                           v_elem * static_cast<size_t>(static_cast<int64_t>(il) * T_enc * d_model));
 
         ggml_build_forward_expand(db.graph, ggml_cpy(ctx, Kcross, k_dst));
         ggml_build_forward_expand(db.graph, ggml_cpy(ctx, Vcross, v_dst));
@@ -398,19 +350,17 @@ DecoderBuild build_cross_kv_graph(ggml_context *                       ctx,
 }
 
 // Cross-KV projection (incremental streaming).
-CrossKVProjectionBuild build_cross_kv_projection_graph(
-    ggml_context *                       ctx,
-    const MoonshineStreamingWeights &    w,
-    const MoonshineStreamingHParams &    hp,
-    int                                  n_frames)
-{
-    CrossKVProjectionBuild pb {};
+CrossKVProjectionBuild build_cross_kv_projection_graph(ggml_context *                    ctx,
+                                                       const MoonshineStreamingWeights & w,
+                                                       const MoonshineStreamingHParams & hp,
+                                                       int                               n_frames) {
+    CrossKVProjectionBuild pb{};
 
     if (ctx == nullptr || n_frames <= 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine_streaming cross_kv_proj: invalid arg "
-                     "(ctx=%p, n_frames=%d)",
-                     static_cast<void *>(ctx), n_frames);
+                "moonshine_streaming cross_kv_proj: invalid arg "
+                "(ctx=%p, n_frames=%d)",
+                static_cast<void *>(ctx), n_frames);
         return pb;
     }
 
@@ -422,8 +372,7 @@ CrossKVProjectionBuild build_cross_kv_projection_graph(
 
     pb.graph = ggml_new_graph_custom(ctx, 4096, false);
     if (pb.graph == nullptr) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine_streaming cross_kv_proj: ggml_new_graph_custom failed");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine_streaming cross_kv_proj: ggml_new_graph_custom failed");
         return pb;
     }
 
@@ -455,31 +404,25 @@ CrossKVProjectionBuild build_cross_kv_projection_graph(
 }
 
 // Cross-KV commit (host buffers → persistent cache).
-CrossKVCommitBuild build_cross_kv_commit_graph(
-    ggml_context *                       ctx,
-    const MoonshineStreamingHParams &    hp,
-    MoonshineStreamingKvCache &          kv_cache,
-    int                                  T_enc)
-{
-    CrossKVCommitBuild cb {};
-
-    if (ctx == nullptr || T_enc <= 0 || kv_cache.cross_k == nullptr ||
-        kv_cache.cross_v == nullptr)
-    {
+CrossKVCommitBuild build_cross_kv_commit_graph(ggml_context *                    ctx,
+                                               const MoonshineStreamingHParams & hp,
+                                               MoonshineStreamingKvCache &       kv_cache,
+                                               int                               T_enc) {
+    CrossKVCommitBuild cb{};
+
+    if (ctx == nullptr || T_enc <= 0 || kv_cache.cross_k == nullptr || kv_cache.cross_v == nullptr) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine_streaming cross_kv_commit: invalid arg "
-                     "(ctx=%p, T_enc=%d, cache=%s)",
-                     static_cast<void *>(ctx), T_enc,
-                     (kv_cache.cross_k == nullptr ||
-                      kv_cache.cross_v == nullptr) ? "null" : "ok");
+                "moonshine_streaming cross_kv_commit: invalid arg "
+                "(ctx=%p, T_enc=%d, cache=%s)",
+                static_cast<void *>(ctx), T_enc,
+                (kv_cache.cross_k == nullptr || kv_cache.cross_v == nullptr) ? "null" : "ok");
         return cb;
     }
 
     const int d_model = hp.dec_d_model;
-    cb.graph = ggml_new_graph_custom(ctx, 4096, false);
+    cb.graph          = ggml_new_graph_custom(ctx, 4096, false);
     if (cb.graph == nullptr) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine_streaming cross_kv_commit: ggml_new_graph_custom failed");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine_streaming cross_kv_commit: ggml_new_graph_custom failed");
         return cb;
     }
 
@@ -493,7 +436,7 @@ CrossKVCommitBuild build_cross_kv_commit_graph(
     for (int il = 0; il < n_layers; ++il) {
         ggml_tensor * K_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, d_model, T_enc);
         ggml_tensor * V_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, d_model, T_enc);
-        char kname[64], vname[64];
+        char          kname[64], vname[64];
         std::snprintf(kname, sizeof(kname), "xkv.commit.k_in.%d", il);
         std::snprintf(vname, sizeof(vname), "xkv.commit.v_in.%d", il);
         named(K_in, kname);
@@ -503,16 +446,10 @@ CrossKVCommitBuild build_cross_kv_commit_graph(
         cb.per_layer_k_in.push_back(K_in);
         cb.per_layer_v_in.push_back(V_in);
 
-        ggml_tensor * k_dst = ggml_view_1d(
-            ctx, kv_cache.cross_k,
-            static_cast<int64_t>(T_enc) * d_model,
-            k_elem * static_cast<size_t>(
-                static_cast<int64_t>(il) * T_enc * d_model));
-        ggml_tensor * v_dst = ggml_view_1d(
-            ctx, kv_cache.cross_v,
-            static_cast<int64_t>(T_enc) * d_model,
-            v_elem * static_cast<size_t>(
-                static_cast<int64_t>(il) * T_enc * d_model));
+        ggml_tensor * k_dst = ggml_view_1d(ctx, kv_cache.cross_k, static_cast<int64_t>(T_enc) * d_model,
+                                           k_elem * static_cast<size_t>(static_cast<int64_t>(il) * T_enc * d_model));
+        ggml_tensor * v_dst = ggml_view_1d(ctx, kv_cache.cross_v, static_cast<int64_t>(T_enc) * d_model,
+                                           v_elem * static_cast<size_t>(static_cast<int64_t>(il) * T_enc * d_model));
 
         ggml_build_forward_expand(cb.graph, ggml_cpy(ctx, K_in, k_dst));
         ggml_build_forward_expand(cb.graph, ggml_cpy(ctx, V_in, v_dst));
@@ -522,30 +459,28 @@ CrossKVCommitBuild build_cross_kv_commit_graph(
 }
 
 // KV-cached decoder graph (prompt + step).
-DecoderBuild build_decoder_graph_kv(ggml_context *                       ctx,
-                                    const MoonshineStreamingWeights &    w,
-                                    const MoonshineStreamingHParams &    hp,
-                                    MoonshineStreamingKvCache &          kv_cache,
-                                    int                                  n_tokens,
-                                    int                                  n_past,
-                                    int                                  T_enc,
-                                    bool                                 skip_log_softmax,
-                                    bool                                 use_flash)
-{
-    DecoderBuild db {};
+DecoderBuild build_decoder_graph_kv(ggml_context *                    ctx,
+                                    const MoonshineStreamingWeights & w,
+                                    const MoonshineStreamingHParams & hp,
+                                    MoonshineStreamingKvCache &       kv_cache,
+                                    int                               n_tokens,
+                                    int                               n_past,
+                                    int                               T_enc,
+                                    bool                              skip_log_softmax,
+                                    bool                              use_flash) {
+    DecoderBuild db{};
 
     if (ctx == nullptr || n_tokens <= 0 || T_enc <= 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine_streaming decoder_kv: invalid arg "
-                     "(ctx=%p, n_tokens=%d, T_enc=%d)",
-                     static_cast<void *>(ctx), n_tokens, T_enc);
+                "moonshine_streaming decoder_kv: invalid arg "
+                "(ctx=%p, n_tokens=%d, T_enc=%d)",
+                static_cast<void *>(ctx), n_tokens, T_enc);
         return db;
     }
     const int n_kv = n_past + n_tokens;
     if (n_kv > kv_cache.n_ctx) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine_streaming decoder_kv: n_kv=%d exceeds n_ctx=%d",
-                     n_kv, kv_cache.n_ctx);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine_streaming decoder_kv: n_kv=%d exceeds n_ctx=%d", n_kv,
+                kv_cache.n_ctx);
         return db;
     }
 
@@ -561,7 +496,7 @@ DecoderBuild build_decoder_graph_kv(ggml_context *                       ctx,
     ggml_set_input(db.pos_ids_in);
 
     ggml_tensor * causal_mask = nullptr;
-    const bool need_mask = (n_tokens > 1);
+    const bool    need_mask   = (n_tokens > 1);
     if (need_mask) {
         db.causal_mask_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, n_kv, n_tokens);
         named(db.causal_mask_in, "dec.causal_mask");
@@ -569,8 +504,7 @@ DecoderBuild build_decoder_graph_kv(ggml_context *                       ctx,
         causal_mask = ggml_cast(ctx, db.causal_mask_in, GGML_TYPE_F16);
     }
 
-    ggml_tensor * tok_emb = ggml_get_rows(ctx, w.dec_top.token_embd_w,
-                                          db.token_ids_in);
+    ggml_tensor * tok_emb = ggml_get_rows(ctx, w.dec_top.token_embd_w, db.token_ids_in);
     named(tok_emb, "dec.token_emb");
     if (n_past == 0) {
         transcribe::debug::mark_tensor_for_dump(tok_emb);
@@ -590,8 +524,7 @@ DecoderBuild build_decoder_graph_kv(ggml_context *                       ctx,
 
     db.graph = ggml_new_graph_custom(ctx, 8192, false);
     if (db.graph == nullptr) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine_streaming decoder_kv: ggml_new_graph_custom failed");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine_streaming decoder_kv: ggml_new_graph_custom failed");
         return db;
     }
 
@@ -602,27 +535,19 @@ DecoderBuild build_decoder_graph_kv(ggml_context *                       ctx,
 
         {
             ggml_tensor * y = layer_norm(ctx, x, b.norm_self_w, /*beta=*/nullptr);
-            y = mha_self_cached(
-                ctx, db.graph, y, kv_cache, db.pos_ids_in, causal_mask,
-                b.self_q_w, b.self_k_w, b.self_v_w, b.self_out_w,
-                hp, n_heads, d_model,
-                i, n_past, n_tokens, n_kv, use_flash);
+            y = mha_self_cached(ctx, db.graph, y, kv_cache, db.pos_ids_in, causal_mask, b.self_q_w, b.self_k_w,
+                                b.self_v_w, b.self_out_w, hp, n_heads, d_model, i, n_past, n_tokens, n_kv, use_flash);
             x = ggml_add(ctx, x, y);
         }
         {
             ggml_tensor * y = layer_norm(ctx, x, b.norm_cross_w, /*beta=*/nullptr);
-            y = mha_cross_cached(
-                ctx, y, kv_cache,
-                b.cross_q_w, b.cross_out_w,
-                hp, n_heads, d_model, i, T_enc, use_flash);
+            y = mha_cross_cached(ctx, y, kv_cache, b.cross_q_w, b.cross_out_w, hp, n_heads, d_model, i, T_enc,
+                                 use_flash);
             x = ggml_add(ctx, x, y);
         }
         {
             ggml_tensor * y = layer_norm(ctx, x, b.norm_ffn_w, /*beta=*/nullptr);
-            y = ffn_decoder_swiglu(ctx, y,
-                                   b.ffn_fc1_w, b.ffn_fc1_b,
-                                   b.ffn_fc2_w, b.ffn_fc2_b,
-                                   hp.dec_ffn_dim);
+            y = ffn_decoder_swiglu(ctx, y, b.ffn_fc1_w, b.ffn_fc1_b, b.ffn_fc2_w, b.ffn_fc2_b, hp.dec_ffn_dim);
             x = ggml_add(ctx, x, y);
         }
 
@@ -673,12 +598,9 @@ DecoderBuild build_decoder_graph_kv(ggml_context *                       ctx,
         ggml_tensor * last_logits = logits;
         if (n_tokens > 1) {
             const int64_t vocab     = logits->ne[0];
-            const size_t  row_bytes = ggml_element_size(logits) *
-                                      static_cast<size_t>(vocab);
-            last_logits = ggml_view_2d(ctx, logits,
-                                       vocab, /*n=*/1,
-                                       row_bytes,
-                                       row_bytes * static_cast<size_t>(n_tokens - 1));
+            const size_t  row_bytes = ggml_element_size(logits) * static_cast<size_t>(vocab);
+            last_logits =
+                ggml_view_2d(ctx, logits, vocab, /*n=*/1, row_bytes, row_bytes * static_cast<size_t>(n_tokens - 1));
             last_logits = ggml_cont(ctx, last_logits);
         }
         db.argmax_out = ggml_argmax(ctx, last_logits);
@@ -695,121 +617,134 @@ DecoderBuild build_decoder_graph_kv(ggml_context *                       ctx,
 // Offline batched decode (B utterances).
 namespace {
 
-ggml_tensor * unpad_head_dim_4d(ggml_context * ctx, ggml_tensor * t,
-                                int head_dim, int pad) {
-    if (pad <= 0) return t;
-    return ggml_view_4d(ctx, t, head_dim, t->ne[1], t->ne[2], t->ne[3],
-                        t->nb[1], t->nb[2], t->nb[3], 0);
+ggml_tensor * unpad_head_dim_4d(ggml_context * ctx, ggml_tensor * t, int head_dim, int pad) {
+    if (pad <= 0) {
+        return t;
+    }
+    return ggml_view_4d(ctx, t, head_dim, t->ne[1], t->ne[2], t->ne[3], t->nb[1], t->nb[2], t->nb[3], 0);
 }
 
-ggml_tensor * mha_self_step_batched(
-    ggml_context * ctx, ggml_cgraph * gf, ggml_tensor * x,
-    MoonshineStreamingKvCache & kv_cache, ggml_tensor * pos_ids, ggml_tensor * kv_idx,
-    ggml_tensor * mask,
-    ggml_tensor * q_w, ggml_tensor * k_w, ggml_tensor * v_w, ggml_tensor * out_w,
-    const MoonshineStreamingHParams & hp, int n_heads, int d_model,
-    int il, int max_n_kv, int B)
-{
-    const int   head_dim     = d_model / n_heads;
-    const int   head_dim_pad = hp.dec_head_dim_padded();
-    const int   head_dim_rot = hp.dec_head_dim_rot();
-    const int   pad          = head_dim_pad - head_dim;
-    const int64_t n_ctx      = kv_cache.n_ctx;
-    const float scale        = 1.0f / std::sqrt(static_cast<float>(head_dim));
-    const size_t k_elem = ggml_element_size(kv_cache.self_k);
-    const size_t v_elem = ggml_element_size(kv_cache.self_v);
+ggml_tensor * mha_self_step_batched(ggml_context *                    ctx,
+                                    ggml_cgraph *                     gf,
+                                    ggml_tensor *                     x,
+                                    MoonshineStreamingKvCache &       kv_cache,
+                                    ggml_tensor *                     pos_ids,
+                                    ggml_tensor *                     kv_idx,
+                                    ggml_tensor *                     mask,
+                                    ggml_tensor *                     q_w,
+                                    ggml_tensor *                     k_w,
+                                    ggml_tensor *                     v_w,
+                                    ggml_tensor *                     out_w,
+                                    const MoonshineStreamingHParams & hp,
+                                    int                               n_heads,
+                                    int                               d_model,
+                                    int                               il,
+                                    int                               max_n_kv,
+                                    int                               B) {
+    const int     head_dim     = d_model / n_heads;
+    const int     head_dim_pad = hp.dec_head_dim_padded();
+    const int     head_dim_rot = hp.dec_head_dim_rot();
+    const int     pad          = head_dim_pad - head_dim;
+    const int64_t n_ctx        = kv_cache.n_ctx;
+    const float   scale        = 1.0f / std::sqrt(static_cast<float>(head_dim));
+    const size_t  k_elem       = ggml_element_size(kv_cache.self_k);
+    const size_t  v_elem       = ggml_element_size(kv_cache.self_v);
 
     ggml_tensor * Q = ggml_mul_mat(ctx, q_w, x);
     ggml_tensor * K = ggml_mul_mat(ctx, k_w, x);
     ggml_tensor * V = ggml_mul_mat(ctx, v_w, x);
-    Q = ggml_reshape_3d(ctx, Q, head_dim, n_heads, B);
-    K = ggml_reshape_3d(ctx, K, head_dim, n_heads, B);
-    V = ggml_reshape_3d(ctx, V, head_dim, n_heads, B);
-    Q = apply_partial_rope(ctx, Q, pos_ids, hp, head_dim_rot);
-    K = apply_partial_rope(ctx, K, pos_ids, hp, head_dim_rot);
+    Q               = ggml_reshape_3d(ctx, Q, head_dim, n_heads, B);
+    K               = ggml_reshape_3d(ctx, K, head_dim, n_heads, B);
+    V               = ggml_reshape_3d(ctx, V, head_dim, n_heads, B);
+    Q               = apply_partial_rope(ctx, Q, pos_ids, hp, head_dim_rot);
+    K               = apply_partial_rope(ctx, K, pos_ids, hp, head_dim_rot);
 
     {
-        const size_t off_k = k_elem * static_cast<size_t>(il) * n_ctx * d_model * B;
-        const size_t off_v = v_elem * static_cast<size_t>(il) * n_ctx * d_model * B;
-        ggml_tensor * k_layer = ggml_view_3d(ctx, kv_cache.self_k,
-            d_model, n_ctx, B, k_elem * d_model, k_elem * d_model * n_ctx, off_k);
-        ggml_tensor * v_layer = ggml_view_3d(ctx, kv_cache.self_v,
-            d_model, n_ctx, B, v_elem * d_model, v_elem * d_model * n_ctx, off_v);
+        const size_t  off_k = k_elem * static_cast<size_t>(il) * n_ctx * d_model * B;
+        const size_t  off_v = v_elem * static_cast<size_t>(il) * n_ctx * d_model * B;
+        ggml_tensor * k_layer =
+            ggml_view_3d(ctx, kv_cache.self_k, d_model, n_ctx, B, k_elem * d_model, k_elem * d_model * n_ctx, off_k);
+        ggml_tensor * v_layer =
+            ggml_view_3d(ctx, kv_cache.self_v, d_model, n_ctx, B, v_elem * d_model, v_elem * d_model * n_ctx, off_v);
         ggml_tensor * K_row = ggml_reshape_3d(ctx, ggml_cont(ctx, K), d_model, 1, B);
         ggml_tensor * V_row = ggml_reshape_3d(ctx, ggml_cont(ctx, V), d_model, 1, B);
         ggml_build_forward_expand(gf, ggml_set_rows(ctx, k_layer, K_row, kv_idx));
         ggml_build_forward_expand(gf, ggml_set_rows(ctx, v_layer, V_row, kv_idx));
     }
 
-    const size_t off_k = k_elem * static_cast<size_t>(il) * n_ctx * d_model * B;
-    const size_t off_v = v_elem * static_cast<size_t>(il) * n_ctx * d_model * B;
-    ggml_tensor * K_att = ggml_view_4d(ctx, kv_cache.self_k,
-        head_dim, max_n_kv, n_heads, B,
-        k_elem * d_model, k_elem * head_dim, k_elem * d_model * n_ctx, off_k);
-    ggml_tensor * V_att = ggml_view_4d(ctx, kv_cache.self_v,
-        head_dim, max_n_kv, n_heads, B,
-        v_elem * d_model, v_elem * head_dim, v_elem * d_model * n_ctx, off_v);
+    const size_t  off_k = k_elem * static_cast<size_t>(il) * n_ctx * d_model * B;
+    const size_t  off_v = v_elem * static_cast<size_t>(il) * n_ctx * d_model * B;
+    ggml_tensor * K_att = ggml_view_4d(ctx, kv_cache.self_k, head_dim, max_n_kv, n_heads, B, k_elem * d_model,
+                                       k_elem * head_dim, k_elem * d_model * n_ctx, off_k);
+    ggml_tensor * V_att = ggml_view_4d(ctx, kv_cache.self_v, head_dim, max_n_kv, n_heads, B, v_elem * d_model,
+                                       v_elem * head_dim, v_elem * d_model * n_ctx, off_v);
 
     ggml_tensor * Q_att = ggml_cont(ctx, ggml_permute(ctx, Q, 0, 2, 3, 1));
-    ggml_tensor * Qp = pad_head_dim(ctx, Q_att, pad);
-    ggml_tensor * Kp = pad_head_dim(ctx, ggml_cont(ctx, K_att), pad);
-    ggml_tensor * Vp = pad_head_dim(ctx, ggml_cont(ctx, V_att), pad);
+    ggml_tensor * Qp    = pad_head_dim(ctx, Q_att, pad);
+    ggml_tensor * Kp    = pad_head_dim(ctx, ggml_cont(ctx, K_att), pad);
+    ggml_tensor * Vp    = pad_head_dim(ctx, ggml_cont(ctx, V_att), pad);
 
     ggml_tensor * o = ggml_flash_attn_ext(ctx, Qp, Kp, Vp, mask, scale, 0.0f, 0.0f);
-    o = ggml_cont(ctx, unpad_head_dim_4d(ctx, o, head_dim, pad));
-    o = ggml_reshape_2d(ctx, o, d_model, B);
+    o               = ggml_cont(ctx, unpad_head_dim_4d(ctx, o, head_dim, pad));
+    o               = ggml_reshape_2d(ctx, o, d_model, B);
 
     o = ggml_mul_mat(ctx, out_w, o);
     return o;
 }
 
-ggml_tensor * mha_cross_step_batched(
-    ggml_context * ctx, ggml_tensor * x, MoonshineStreamingKvCache & kv_cache,
-    ggml_tensor * cross_mask, ggml_tensor * q_w, ggml_tensor * out_w,
-    const MoonshineStreamingHParams & hp, int n_heads, int d_model, int il, int T_enc_max, int B)
-{
-    const int   head_dim     = d_model / n_heads;
-    const int   head_dim_pad = hp.dec_head_dim_padded();
-    const int   pad          = head_dim_pad - head_dim;
-    const float scale        = 1.0f / std::sqrt(static_cast<float>(head_dim));
-    const size_t k_elem = ggml_element_size(kv_cache.cross_k);
-    const size_t v_elem = ggml_element_size(kv_cache.cross_v);
-
-    ggml_tensor * Q = ggml_mul_mat(ctx, q_w, x);
-    Q = ggml_reshape_3d(ctx, Q, head_dim, n_heads, B);
+ggml_tensor * mha_cross_step_batched(ggml_context *                    ctx,
+                                     ggml_tensor *                     x,
+                                     MoonshineStreamingKvCache &       kv_cache,
+                                     ggml_tensor *                     cross_mask,
+                                     ggml_tensor *                     q_w,
+                                     ggml_tensor *                     out_w,
+                                     const MoonshineStreamingHParams & hp,
+                                     int                               n_heads,
+                                     int                               d_model,
+                                     int                               il,
+                                     int                               T_enc_max,
+                                     int                               B) {
+    const int    head_dim     = d_model / n_heads;
+    const int    head_dim_pad = hp.dec_head_dim_padded();
+    const int    pad          = head_dim_pad - head_dim;
+    const float  scale        = 1.0f / std::sqrt(static_cast<float>(head_dim));
+    const size_t k_elem       = ggml_element_size(kv_cache.cross_k);
+    const size_t v_elem       = ggml_element_size(kv_cache.cross_v);
+
+    ggml_tensor * Q     = ggml_mul_mat(ctx, q_w, x);
+    Q                   = ggml_reshape_3d(ctx, Q, head_dim, n_heads, B);
     ggml_tensor * Q_att = ggml_cont(ctx, ggml_permute(ctx, Q, 0, 2, 3, 1));
-    ggml_tensor * Qp = pad_head_dim(ctx, Q_att, pad);
-
-    const size_t off_k = k_elem * static_cast<size_t>(il) * T_enc_max * d_model * B;
-    const size_t off_v = v_elem * static_cast<size_t>(il) * T_enc_max * d_model * B;
-    ggml_tensor * K = ggml_view_4d(ctx, kv_cache.cross_k,
-        head_dim, T_enc_max, n_heads, B,
-        k_elem * d_model, k_elem * head_dim, k_elem * d_model * T_enc_max, off_k);
-    ggml_tensor * V = ggml_view_4d(ctx, kv_cache.cross_v,
-        head_dim, T_enc_max, n_heads, B,
-        v_elem * d_model, v_elem * head_dim, v_elem * d_model * T_enc_max, off_v);
-    ggml_tensor * Kp = pad_head_dim(ctx, ggml_cont(ctx, K), pad);
-    ggml_tensor * Vp = pad_head_dim(ctx, ggml_cont(ctx, V), pad);
+    ggml_tensor * Qp    = pad_head_dim(ctx, Q_att, pad);
+
+    const size_t  off_k = k_elem * static_cast<size_t>(il) * T_enc_max * d_model * B;
+    const size_t  off_v = v_elem * static_cast<size_t>(il) * T_enc_max * d_model * B;
+    ggml_tensor * K     = ggml_view_4d(ctx, kv_cache.cross_k, head_dim, T_enc_max, n_heads, B, k_elem * d_model,
+                                       k_elem * head_dim, k_elem * d_model * T_enc_max, off_k);
+    ggml_tensor * V     = ggml_view_4d(ctx, kv_cache.cross_v, head_dim, T_enc_max, n_heads, B, v_elem * d_model,
+                                       v_elem * head_dim, v_elem * d_model * T_enc_max, off_v);
+    ggml_tensor * Kp    = pad_head_dim(ctx, ggml_cont(ctx, K), pad);
+    ggml_tensor * Vp    = pad_head_dim(ctx, ggml_cont(ctx, V), pad);
 
     ggml_tensor * o = ggml_flash_attn_ext(ctx, Qp, Kp, Vp, cross_mask, scale, 0.0f, 0.0f);
-    o = ggml_cont(ctx, unpad_head_dim_4d(ctx, o, head_dim, pad));
-    o = ggml_reshape_2d(ctx, o, d_model, B);
+    o               = ggml_cont(ctx, unpad_head_dim_4d(ctx, o, head_dim, pad));
+    o               = ggml_reshape_2d(ctx, o, d_model, B);
 
     o = ggml_mul_mat(ctx, out_w, o);
     return o;
 }
 
-} // namespace
+}  // namespace
 
 DecoderBuild build_cross_kv_graph_batched(ggml_context *                    ctx,
                                           const MoonshineStreamingWeights & w,
                                           const MoonshineStreamingHParams & hp,
                                           MoonshineStreamingKvCache &       kv_cache,
                                           int                               T_enc_max,
-                                          int                               n_batch)
-{
-    DecoderBuild db {};
-    if (ctx == nullptr || T_enc_max <= 0 || n_batch <= 0) return db;
+                                          int                               n_batch) {
+    DecoderBuild db{};
+    if (ctx == nullptr || T_enc_max <= 0 || n_batch <= 0) {
+        return db;
+    }
 
     const int d_model = hp.dec_d_model;
     const int B       = n_batch;
@@ -819,22 +754,24 @@ DecoderBuild build_cross_kv_graph_batched(ggml_context *                    ctx,
     ggml_set_input(db.encoder_out_in);
 
     db.graph = ggml_new_graph_custom(ctx, 8192, false);
-    if (db.graph == nullptr) return db;
+    if (db.graph == nullptr) {
+        return db;
+    }
 
     const size_t k_elem = ggml_element_size(kv_cache.cross_k);
     const size_t v_elem = ggml_element_size(kv_cache.cross_v);
 
     const int n_layers = static_cast<int>(w.dec_blocks.size());
     for (int il = 0; il < n_layers; ++il) {
-        const auto & blk = w.dec_blocks[il];
-        ggml_tensor * Kc = ggml_mul_mat(ctx, blk.cross_k_w, db.encoder_out_in);
-        ggml_tensor * Vc = ggml_mul_mat(ctx, blk.cross_v_w, db.encoder_out_in);
-        const size_t off_k = k_elem * static_cast<size_t>(il) * T_enc_max * d_model * B;
-        const size_t off_v = v_elem * static_cast<size_t>(il) * T_enc_max * d_model * B;
-        ggml_tensor * k_dst = ggml_view_3d(ctx, kv_cache.cross_k,
-            d_model, T_enc_max, B, k_elem * d_model, k_elem * d_model * T_enc_max, off_k);
-        ggml_tensor * v_dst = ggml_view_3d(ctx, kv_cache.cross_v,
-            d_model, T_enc_max, B, v_elem * d_model, v_elem * d_model * T_enc_max, off_v);
+        const auto &  blk   = w.dec_blocks[il];
+        ggml_tensor * Kc    = ggml_mul_mat(ctx, blk.cross_k_w, db.encoder_out_in);
+        ggml_tensor * Vc    = ggml_mul_mat(ctx, blk.cross_v_w, db.encoder_out_in);
+        const size_t  off_k = k_elem * static_cast<size_t>(il) * T_enc_max * d_model * B;
+        const size_t  off_v = v_elem * static_cast<size_t>(il) * T_enc_max * d_model * B;
+        ggml_tensor * k_dst = ggml_view_3d(ctx, kv_cache.cross_k, d_model, T_enc_max, B, k_elem * d_model,
+                                           k_elem * d_model * T_enc_max, off_k);
+        ggml_tensor * v_dst = ggml_view_3d(ctx, kv_cache.cross_v, d_model, T_enc_max, B, v_elem * d_model,
+                                           v_elem * d_model * T_enc_max, off_v);
         ggml_build_forward_expand(db.graph, ggml_cpy(ctx, Kc, k_dst));
         ggml_build_forward_expand(db.graph, ggml_cpy(ctx, Vc, v_dst));
     }
@@ -848,12 +785,13 @@ StepBuildBatched build_step_graph_batched(ggml_context *                    ctx,
                                           int                               max_n_kv,
                                           int                               T_enc_max,
                                           int                               n_batch,
-                                          bool                              use_flash)
-{
-    StepBuildBatched sb {};
+                                          bool                              use_flash) {
+    StepBuildBatched sb{};
     sb.max_n_kv = max_n_kv;
     sb.n_batch  = n_batch;
-    if (ctx == nullptr || max_n_kv <= 0 || T_enc_max <= 0 || n_batch <= 0) return sb;
+    if (ctx == nullptr || max_n_kv <= 0 || T_enc_max <= 0 || n_batch <= 0) {
+        return sb;
+    }
     if (!use_flash) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine_streaming step(batched): requires flash path");
         return sb;
@@ -864,18 +802,25 @@ StepBuildBatched build_step_graph_batched(ggml_context *                    ctx,
     const int B       = n_batch;
 
     sb.token_ids_in = ggml_new_tensor_1d(ctx, GGML_TYPE_I32, B);
-    ggml_set_name(sb.token_ids_in, "step.token_ids"); ggml_set_input(sb.token_ids_in);
+    ggml_set_name(sb.token_ids_in, "step.token_ids");
+    ggml_set_input(sb.token_ids_in);
     sb.pos_ids_in = ggml_new_tensor_1d(ctx, GGML_TYPE_I32, B);
-    ggml_set_name(sb.pos_ids_in, "step.pos_ids"); ggml_set_input(sb.pos_ids_in);
+    ggml_set_name(sb.pos_ids_in, "step.pos_ids");
+    ggml_set_input(sb.pos_ids_in);
     sb.kv_idx_in = ggml_new_tensor_2d(ctx, GGML_TYPE_I64, 1, B);
-    ggml_set_name(sb.kv_idx_in, "step.kv_idx"); ggml_set_input(sb.kv_idx_in);
+    ggml_set_name(sb.kv_idx_in, "step.kv_idx");
+    ggml_set_input(sb.kv_idx_in);
     sb.self_mask_in = ggml_new_tensor_4d(ctx, GGML_TYPE_F16, max_n_kv, 1, 1, B);
-    ggml_set_name(sb.self_mask_in, "step.self_mask"); ggml_set_input(sb.self_mask_in);
+    ggml_set_name(sb.self_mask_in, "step.self_mask");
+    ggml_set_input(sb.self_mask_in);
     sb.cross_mask_in = ggml_new_tensor_4d(ctx, GGML_TYPE_F16, T_enc_max, 1, 1, B);
-    ggml_set_name(sb.cross_mask_in, "step.cross_mask"); ggml_set_input(sb.cross_mask_in);
+    ggml_set_name(sb.cross_mask_in, "step.cross_mask");
+    ggml_set_input(sb.cross_mask_in);
 
     sb.graph = ggml_new_graph_custom(ctx, 16384, false);
-    if (sb.graph == nullptr) return sb;
+    if (sb.graph == nullptr) {
+        return sb;
+    }
 
     ggml_tensor * x = ggml_get_rows(ctx, w.dec_top.token_embd_w, sb.token_ids_in);
 
@@ -884,35 +829,32 @@ StepBuildBatched build_step_graph_batched(ggml_context *                    ctx,
         const auto & b = w.dec_blocks[i];
         {
             ggml_tensor * y = layer_norm(ctx, x, b.norm_self_w, /*beta=*/nullptr);
-            y = mha_self_step_batched(
-                ctx, sb.graph, y, kv_cache, sb.pos_ids_in, sb.kv_idx_in, sb.self_mask_in,
-                b.self_q_w, b.self_k_w, b.self_v_w, b.self_out_w,
-                hp, n_heads, d_model, i, max_n_kv, B);
+            y = mha_self_step_batched(ctx, sb.graph, y, kv_cache, sb.pos_ids_in, sb.kv_idx_in, sb.self_mask_in,
+                                      b.self_q_w, b.self_k_w, b.self_v_w, b.self_out_w, hp, n_heads, d_model, i,
+                                      max_n_kv, B);
             x = ggml_add(ctx, x, y);
         }
         {
             ggml_tensor * y = layer_norm(ctx, x, b.norm_cross_w, /*beta=*/nullptr);
-            y = mha_cross_step_batched(
-                ctx, y, kv_cache, sb.cross_mask_in, b.cross_q_w, b.cross_out_w,
-                hp, n_heads, d_model, i, T_enc_max, B);
+            y = mha_cross_step_batched(ctx, y, kv_cache, sb.cross_mask_in, b.cross_q_w, b.cross_out_w, hp, n_heads,
+                                       d_model, i, T_enc_max, B);
             x = ggml_add(ctx, x, y);
         }
         {
             ggml_tensor * y = layer_norm(ctx, x, b.norm_ffn_w, /*beta=*/nullptr);
-            y = ffn_decoder_swiglu(ctx, y, b.ffn_fc1_w, b.ffn_fc1_b,
-                                   b.ffn_fc2_w, b.ffn_fc2_b, hp.dec_ffn_dim);
+            y = ffn_decoder_swiglu(ctx, y, b.ffn_fc1_w, b.ffn_fc1_b, b.ffn_fc2_w, b.ffn_fc2_b, hp.dec_ffn_dim);
             x = ggml_add(ctx, x, y);
         }
     }
 
-    x = layer_norm(ctx, x, w.dec_top.final_norm_w, /*beta=*/nullptr);
+    x                    = layer_norm(ctx, x, w.dec_top.final_norm_w, /*beta=*/nullptr);
     ggml_tensor * logits = ggml_mul_mat(ctx, w.dec_top.lm_head_w, x);  // untied head
 
-    sb.argmax_out = ggml_argmax(ctx, logits);  // [B]
+    sb.argmax_out = ggml_argmax(ctx, logits);                          // [B]
     ggml_set_name(sb.argmax_out, "step.argmax");
     ggml_set_output(sb.argmax_out);
     ggml_build_forward_expand(sb.graph, sb.argmax_out);
     return sb;
 }
 
-} // namespace transcribe::moonshine_streaming
+}  // namespace transcribe::moonshine_streaming
diff --git a/src/arch/moonshine_streaming/decoder.h b/src/arch/moonshine_streaming/decoder.h
index 5766ac1a..74640477 100644
--- a/src/arch/moonshine_streaming/decoder.h
+++ b/src/arch/moonshine_streaming/decoder.h
@@ -25,14 +25,14 @@ struct MoonshineStreamingWeights;
 struct MoonshineStreamingKvCache;
 
 struct DecoderDumps {
-    ggml_tensor * adapter_pos_emb = nullptr;   // adapter.pos_emb (slice)
-    ggml_tensor * adapter_out     = nullptr;   // adapter.out (post pos_emb add + proj if present)
-    ggml_tensor * token_emb       = nullptr;   // dec.token_emb
-    ggml_tensor * embed_sum       = nullptr;   // dec.embed_sum (= token_emb)
-    std::vector<ggml_tensor *> block_outs;     // dec.block.{i}.out
-    ggml_tensor * out_before_head = nullptr;   // dec.out_before_head
-    ggml_tensor * logits_raw      = nullptr;   // dec.logits_raw
-    ggml_tensor * logits          = nullptr;   // dec.logits (log_softmax)
+    ggml_tensor *              adapter_pos_emb = nullptr;  // adapter.pos_emb (slice)
+    ggml_tensor *              adapter_out     = nullptr;  // adapter.out (post pos_emb add + proj if present)
+    ggml_tensor *              token_emb       = nullptr;  // dec.token_emb
+    ggml_tensor *              embed_sum       = nullptr;  // dec.embed_sum (= token_emb)
+    std::vector<ggml_tensor *> block_outs;                 // dec.block.{i}.out
+    ggml_tensor *              out_before_head = nullptr;  // dec.out_before_head
+    ggml_tensor *              logits_raw      = nullptr;  // dec.logits_raw
+    ggml_tensor *              logits          = nullptr;  // dec.logits (log_softmax)
 };
 
 struct AdapterBuild {
@@ -49,10 +49,10 @@ struct DecoderBuild {
     ggml_tensor * encoder_out_in = nullptr;  // [dec_hidden, T_enc] f32 (cross_kv graph only)
     ggml_tensor * causal_mask_in = nullptr;  // [n_kv, n_tokens] f32 (n_tokens>1 only)
 
-    ggml_tensor * out         = nullptr;     // logits or log-softmax depending on flag
-    ggml_tensor * argmax_out  = nullptr;     // [n_tokens] i32, set when skip_log_softmax
+    ggml_tensor * out        = nullptr;      // logits or log-softmax depending on flag
+    ggml_tensor * argmax_out = nullptr;      // [n_tokens] i32, set when skip_log_softmax
 
-    DecoderDumps  dumps {};
+    DecoderDumps  dumps{};
     ggml_cgraph * graph = nullptr;
 };
 
@@ -61,19 +61,19 @@ struct DecoderBuild {
 //   x = (proj when adapter_has_proj else identity) (x)
 // Output is host-read so the cross_kv graph can re-upload it into a
 // fresh compute_ctx.
-AdapterBuild build_adapter_graph(ggml_context *                       compute_ctx,
-                                 const MoonshineStreamingWeights &    weights,
-                                 const MoonshineStreamingHParams &    hp,
-                                 int                                  T_enc);
+AdapterBuild build_adapter_graph(ggml_context *                    compute_ctx,
+                                 const MoonshineStreamingWeights & weights,
+                                 const MoonshineStreamingHParams & hp,
+                                 int                               T_enc);
 
 // Build a graph that computes cross-attn K/V for every decoder layer
 // from an already-adapted encoder hidden state, writing into the cross
 // cache. Reads from `encoder_out_in` (= adapter.out).
-DecoderBuild build_cross_kv_graph(ggml_context *                       compute_ctx,
-                                  const MoonshineStreamingWeights &    weights,
-                                  const MoonshineStreamingHParams &    hp,
-                                  MoonshineStreamingKvCache &          kv_cache,
-                                  int                                  T_enc);
+DecoderBuild build_cross_kv_graph(ggml_context *                    compute_ctx,
+                                  const MoonshineStreamingWeights & weights,
+                                  const MoonshineStreamingHParams & hp,
+                                  MoonshineStreamingKvCache &       kv_cache,
+                                  int                               T_enc);
 
 // Build a graph that computes cross-attn K/V projections for every
 // decoder layer over an [dec_d_model, n_frames] adapter slice, leaving
@@ -84,17 +84,16 @@ DecoderBuild build_cross_kv_graph(ggml_context *                       compute_c
 // and decouples the cache allocation (which requires the final T_enc)
 // from per-feed computation.
 struct CrossKVProjectionBuild {
-    ggml_tensor *               encoder_out_in = nullptr; // [dec_d_model, n_frames] f32
-    std::vector<ggml_tensor *>  per_layer_k;              // [dec_d_model, n_frames] f32 each
-    std::vector<ggml_tensor *>  per_layer_v;
-    ggml_cgraph *               graph          = nullptr;
+    ggml_tensor *              encoder_out_in = nullptr;  // [dec_d_model, n_frames] f32
+    std::vector<ggml_tensor *> per_layer_k;               // [dec_d_model, n_frames] f32 each
+    std::vector<ggml_tensor *> per_layer_v;
+    ggml_cgraph *              graph = nullptr;
 };
 
-CrossKVProjectionBuild build_cross_kv_projection_graph(
-    ggml_context *                       compute_ctx,
-    const MoonshineStreamingWeights &    weights,
-    const MoonshineStreamingHParams &    hp,
-    int                                  n_frames);
+CrossKVProjectionBuild build_cross_kv_projection_graph(ggml_context *                    compute_ctx,
+                                                       const MoonshineStreamingWeights & weights,
+                                                       const MoonshineStreamingHParams & hp,
+                                                       int                               n_frames);
 
 // Build a graph that uploads per-layer K and V host buffers (one
 // pair per decoder layer, each [dec_d_model, T_enc] f32) into the
@@ -102,27 +101,26 @@ CrossKVProjectionBuild build_cross_kv_projection_graph(
 // through ggml_cpy lets the backend handle any F32→F16 conversion
 // that the cache's storage dtype requires.
 struct CrossKVCommitBuild {
-    std::vector<ggml_tensor *>  per_layer_k_in;  // [dec_d_model, T_enc] f32 input each
-    std::vector<ggml_tensor *>  per_layer_v_in;
-    ggml_cgraph *               graph = nullptr;
+    std::vector<ggml_tensor *> per_layer_k_in;  // [dec_d_model, T_enc] f32 input each
+    std::vector<ggml_tensor *> per_layer_v_in;
+    ggml_cgraph *              graph = nullptr;
 };
 
-CrossKVCommitBuild build_cross_kv_commit_graph(
-    ggml_context *                       compute_ctx,
-    const MoonshineStreamingHParams &    hp,
-    MoonshineStreamingKvCache &          kv_cache,
-    int                                  T_enc);
+CrossKVCommitBuild build_cross_kv_commit_graph(ggml_context *                    compute_ctx,
+                                               const MoonshineStreamingHParams & hp,
+                                               MoonshineStreamingKvCache &       kv_cache,
+                                               int                               T_enc);
 
 // Build a KV-cached decoder graph for the prompt or step pass.
-DecoderBuild build_decoder_graph_kv(ggml_context *                       compute_ctx,
-                                    const MoonshineStreamingWeights &    weights,
-                                    const MoonshineStreamingHParams &    hp,
-                                    MoonshineStreamingKvCache &          kv_cache,
-                                    int                                  n_tokens,
-                                    int                                  n_past,
-                                    int                                  T_enc,
-                                    bool                                 skip_log_softmax = false,
-                                    bool                                 use_flash        = true);
+DecoderBuild build_decoder_graph_kv(ggml_context *                    compute_ctx,
+                                    const MoonshineStreamingWeights & weights,
+                                    const MoonshineStreamingHParams & hp,
+                                    MoonshineStreamingKvCache &       kv_cache,
+                                    int                               n_tokens,
+                                    int                               n_past,
+                                    int                               T_enc,
+                                    bool                              skip_log_softmax = false,
+                                    bool                              use_flash        = true);
 
 // ---------------------------------------------------------------------------
 // Offline batched decode (B utterances). Mirrors src/arch/moonshine, with
@@ -159,4 +157,4 @@ StepBuildBatched build_step_graph_batched(ggml_context *                    ctx,
                                           int                               n_batch,
                                           bool                              use_flash = true);
 
-} // namespace transcribe::moonshine_streaming
+}  // namespace transcribe::moonshine_streaming
diff --git a/src/arch/moonshine_streaming/encoder.cpp b/src/arch/moonshine_streaming/encoder.cpp
index f873e65b..931ec49e 100644
--- a/src/arch/moonshine_streaming/encoder.cpp
+++ b/src/arch/moonshine_streaming/encoder.cpp
@@ -13,14 +13,12 @@
 
 #include "encoder.h"
 
-#include "moonshine_streaming.h"
-#include "weights.h"
-
 #include "conformer/conformer.h"
+#include "ggml.h"
+#include "moonshine_streaming.h"
 #include "transcribe-debug.h"
 #include "transcribe-log.h"
-
-#include "ggml.h"
+#include "weights.h"
 
 #include <cmath>
 #include <cstdio>
@@ -31,17 +29,17 @@ namespace transcribe::moonshine_streaming {
 namespace {
 
 namespace conf = transcribe::conformer;
-using conf::named;
 using conf::layer_norm;
+using conf::named;
 
 constexpr float kLayerNormEps = 1e-5f;
 
-ggml_tensor * add_conv1d_bias(ggml_context * ctx,
-                              ggml_tensor *  conv_out,
-                              ggml_tensor *  bias_1d) {
-    if (bias_1d == nullptr) return conv_out;
+ggml_tensor * add_conv1d_bias(ggml_context * ctx, ggml_tensor * conv_out, ggml_tensor * bias_1d) {
+    if (bias_1d == nullptr) {
+        return conv_out;
+    }
     const int64_t channels = bias_1d->ne[0];
-    ggml_tensor * bias_4d = ggml_reshape_4d(ctx, bias_1d, 1, channels, 1, 1);
+    ggml_tensor * bias_4d  = ggml_reshape_4d(ctx, bias_1d, 1, channels, 1, 1);
     return ggml_add(ctx, conv_out, bias_4d);
 }
 
@@ -75,8 +73,7 @@ ggml_tensor * mha_encoder_swa(ggml_context *                    ctx,
                               const MoonshineStreamingHParams & hp,
                               int                               n_heads,
                               int                               head_dim,
-                              bool                              use_flash)
-{
+                              bool                              use_flash) {
     const int     attn_dim     = n_heads * head_dim;
     const int     head_dim_pad = hp.enc_head_dim_padded();
     const int     pad          = head_dim_pad - head_dim;
@@ -118,17 +115,14 @@ ggml_tensor * mha_encoder_swa(ggml_context *                    ctx,
         o = ggml_cont(ctx, o);
     } else {
         ggml_tensor * kq      = ggml_mul_mat(ctx, K, Q);
-        ggml_tensor * kq_soft = ggml_soft_max_ext(ctx, kq, mask_f16,
-                                                  scale, 0.0f);
-        ggml_tensor * v_t = ggml_cont(ctx, ggml_permute(ctx, V, 1, 0, 2, 3));
-        o = ggml_mul_mat(ctx, v_t, kq_soft);
+        ggml_tensor * kq_soft = ggml_soft_max_ext(ctx, kq, mask_f16, scale, 0.0f);
+        ggml_tensor * v_t     = ggml_cont(ctx, ggml_permute(ctx, V, 1, 0, 2, 3));
+        o                     = ggml_mul_mat(ctx, v_t, kq_soft);
         // o ne: [head_dim_pad, T, n_heads, 1]
     }
 
     if (pad > 0) {
-        o = ggml_view_3d(ctx, o,
-                         head_dim, T, n_heads,
-                         o->nb[1], o->nb[2], 0);
+        o = ggml_view_3d(ctx, o, head_dim, T, n_heads, o->nb[1], o->nb[2], 0);
         o = ggml_cont(ctx, o);
     }
 
@@ -145,39 +139,40 @@ ggml_tensor * mha_encoder_swa(ggml_context *                    ctx,
 // Encoder MLP: fc1 (with bias) → GELU(erf) → fc2 (with bias).
 ggml_tensor * ffn_encoder(ggml_context * ctx,
                           ggml_tensor *  x,
-                          ggml_tensor *  fc1_w, ggml_tensor * fc1_b,
-                          ggml_tensor *  fc2_w, ggml_tensor * fc2_b)
-{
+                          ggml_tensor *  fc1_w,
+                          ggml_tensor *  fc1_b,
+                          ggml_tensor *  fc2_w,
+                          ggml_tensor *  fc2_b) {
     ggml_tensor * h = ggml_mul_mat(ctx, fc1_w, x);
-    if (fc1_b != nullptr) h = ggml_add(ctx, h, fc1_b);
-    h = ggml_gelu_erf(ctx, h);
+    if (fc1_b != nullptr) {
+        h = ggml_add(ctx, h, fc1_b);
+    }
+    h               = ggml_gelu_erf(ctx, h);
     ggml_tensor * o = ggml_mul_mat(ctx, fc2_w, h);
-    if (fc2_b != nullptr) o = ggml_add(ctx, o, fc2_b);
+    if (fc2_b != nullptr) {
+        o = ggml_add(ctx, o, fc2_b);
+    }
     return o;
 }
 
-ggml_tensor * build_encoder_block(ggml_context *                       ctx,
-                                  ggml_tensor *                        x,
-                                  ggml_tensor *                        mask_f32,
-                                  const MoonshineStreamingEncBlock &   b,
-                                  const MoonshineStreamingHParams &    hp,
-                                  int                                  n_heads,
-                                  int                                  head_dim,
-                                  bool                                 use_flash)
-{
+ggml_tensor * build_encoder_block(ggml_context *                     ctx,
+                                  ggml_tensor *                      x,
+                                  ggml_tensor *                      mask_f32,
+                                  const MoonshineStreamingEncBlock & b,
+                                  const MoonshineStreamingHParams &  hp,
+                                  int                                n_heads,
+                                  int                                head_dim,
+                                  bool                               use_flash) {
     {
         ggml_tensor * y = layer_norm(ctx, x, b.norm_attn_w, /*beta=*/nullptr);
-        y = mha_encoder_swa(ctx, y, mask_f32,
-                            b.attn_q_w, b.attn_k_w, b.attn_v_w, b.attn_out_w,
-                            hp, n_heads, head_dim, use_flash);
+        y = mha_encoder_swa(ctx, y, mask_f32, b.attn_q_w, b.attn_k_w, b.attn_v_w, b.attn_out_w, hp, n_heads, head_dim,
+                            use_flash);
         x = ggml_add(ctx, x, y);
     }
     {
         ggml_tensor * y = layer_norm(ctx, x, b.norm_ffn_w, /*beta=*/nullptr);
-        y = ffn_encoder(ctx, y,
-                        b.ffn_fc1_w, b.ffn_fc1_b,
-                        b.ffn_fc2_w, b.ffn_fc2_b);
-        x = ggml_add(ctx, x, y);
+        y               = ffn_encoder(ctx, y, b.ffn_fc1_w, b.ffn_fc1_b, b.ffn_fc2_w, b.ffn_fc2_b);
+        x               = ggml_add(ctx, x, y);
     }
     return x;
 }
@@ -186,69 +181,79 @@ ggml_tensor * build_encoder_block(ggml_context *                       ctx,
 //   T_out = floor((T_in + (k-1) - k) / s) + 1 = floor((T_in - 1) / s) + 1
 //         = ceil(T_in / s)
 int causal_conv1d_t_out(int T_in, int /*k*/, int s) {
-    if (T_in <= 0 || s <= 0) return 0;
+    if (T_in <= 0 || s <= 0) {
+        return 0;
+    }
     return (T_in + s - 1) / s;
 }
 
-
-} // namespace
+}  // namespace
 
 bool dump_block_index(int i, int n_layers) {
-    if (n_layers <= 8) return true;
-    const int last = n_layers - 1;
-    auto round_he = [](double x) -> int {
+    if (n_layers <= 8) {
+        return true;
+    }
+    const int last     = n_layers - 1;
+    auto      round_he = [](double x) -> int {
         return static_cast<int>(std::nearbyint(x));
     };
-    if (i == 0) return true;
-    if (i == last) return true;
-    if (i == round_he(last / 4.0)) return true;
-    if (i == round_he(last / 2.0)) return true;
-    if (i == round_he(3.0 * last / 4.0)) return true;
+    if (i == 0) {
+        return true;
+    }
+    if (i == last) {
+        return true;
+    }
+    if (i == round_he(last / 4.0)) {
+        return true;
+    }
+    if (i == round_he(last / 2.0)) {
+        return true;
+    }
+    if (i == round_he(3.0 * last / 4.0)) {
+        return true;
+    }
     return false;
 }
 
 int encoder_t_enc(const MoonshineStreamingHParams & hp, int n_samples) {
-    if (n_samples <= 0 || hp.enc_frame_len <= 0) return 0;
+    if (n_samples <= 0 || hp.enc_frame_len <= 0) {
+        return 0;
+    }
     const int T_frames = n_samples / hp.enc_frame_len;
-    if (T_frames <= 0) return 0;
+    if (T_frames <= 0) {
+        return 0;
+    }
     // Two strided causal conv layers with stride 2 each.
-    const int T1     = causal_conv1d_t_out(T_frames, /*k=*/5, /*s=*/2);
-    const int T_enc  = causal_conv1d_t_out(T1,       /*k=*/5, /*s=*/2);
+    const int T1    = causal_conv1d_t_out(T_frames, /*k=*/5, /*s=*/2);
+    const int T_enc = causal_conv1d_t_out(T1, /*k=*/5, /*s=*/2);
     return T_enc;
 }
 
-void build_sliding_window_mask(int     T_enc,
-                               int     left_window,
-                               int     right_window,
-                               float * out_mask)
-{
+void build_sliding_window_mask(int T_enc, int left_window, int right_window, float * out_mask) {
     constexpr float NEG_INF = -std::numeric_limits<float>::infinity();
     // mask[q, k]: q is row (n_q axis), k is col (n_kv axis = innermost).
     // ggml mask layout convention: ne0 = n_kv, ne1 = n_q. Row-major
     // memory has q as outer index, k as inner.
     for (int q = 0; q < T_enc; ++q) {
         for (int k = 0; k < T_enc; ++k) {
-            const int dist     = q - k;
-            const bool left_ok  = (dist >= 0) && (dist <  left_window);
-            const bool right_ok = (dist <  0) && (-dist <  right_window);
-            out_mask[static_cast<size_t>(q) * T_enc + k] =
-                (left_ok || right_ok) ? 0.0f : NEG_INF;
+            const int  dist                              = q - k;
+            const bool left_ok                           = (dist >= 0) && (dist < left_window);
+            const bool right_ok                          = (dist < 0) && (-dist < right_window);
+            out_mask[static_cast<size_t>(q) * T_enc + k] = (left_ok || right_ok) ? 0.0f : NEG_INF;
         }
     }
 }
 
-EncoderBuild build_encoder_graph(ggml_context *                       ctx,
-                                 const MoonshineStreamingWeights &    w,
-                                 const MoonshineStreamingHParams &    hp,
-                                 int                                  n_samples,
-                                 bool                                 use_flash)
-{
-    EncoderBuild eb {};
+EncoderBuild build_encoder_graph(ggml_context *                    ctx,
+                                 const MoonshineStreamingWeights & w,
+                                 const MoonshineStreamingHParams & hp,
+                                 int                               n_samples,
+                                 bool                              use_flash) {
+    EncoderBuild eb{};
 
     if (ctx == nullptr || n_samples <= 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine_streaming encoder: invalid arg (ctx=%p, n_samples=%d)",
-                     static_cast<void *>(ctx), n_samples);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine_streaming encoder: invalid arg (ctx=%p, n_samples=%d)",
+                static_cast<void *>(ctx), n_samples);
         return eb;
     }
 
@@ -259,9 +264,8 @@ EncoderBuild build_encoder_graph(ggml_context *                       ctx,
     const int T_enc     = encoder_t_enc(hp, n_samples);
 
     if (T_enc <= 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine_streaming encoder: input too short (n_samples=%d → T_enc=0)",
-                     n_samples);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine_streaming encoder: input too short (n_samples=%d → T_enc=0)",
+                n_samples);
         return eb;
     }
 
@@ -271,16 +275,18 @@ EncoderBuild build_encoder_graph(ggml_context *                       ctx,
     // multiple (callers right-pad before calling).
     if (n_samples % frame_len != 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine_streaming encoder: n_samples=%d not a multiple of "
-                     "frame_len=%d (caller must right-pad before calling)",
-                     n_samples, frame_len);
+                "moonshine_streaming encoder: n_samples=%d not a multiple of "
+                "frame_len=%d (caller must right-pad before calling)",
+                n_samples, frame_len);
         return eb;
     }
     const int T_frames = n_samples / frame_len;
 
     // ---- audio input ----
     eb.audio_in = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, n_samples);
-    if (eb.audio_in == nullptr) return eb;
+    if (eb.audio_in == nullptr) {
+        return eb;
+    }
     named(eb.audio_in, "enc.audio.in");
     ggml_set_input(eb.audio_in);
     eb.dumps.audio_in = eb.audio_in;
@@ -297,14 +303,14 @@ EncoderBuild build_encoder_graph(ggml_context *                       ctx,
 
     // ---- asinh compression ----
     ggml_tensor * exp_logk = ggml_exp(ctx, w.embedder.comp_log_k);  // [1]
-    ggml_tensor * z = ggml_mul(ctx, x, exp_logk);   // broadcast [1] over [80, T_frames]
-    x = asinh_op(ctx, z);
+    ggml_tensor * z        = ggml_mul(ctx, x, exp_logk);            // broadcast [1] over [80, T_frames]
+    x                      = asinh_op(ctx, z);
     named(x, "enc.embedder.comp.out");
     eb.dumps.comp_out = x;
     transcribe::debug::mark_tensor_for_dump(x);
 
     // ---- linear (no bias) + SiLU ----
-    x = ggml_mul_mat(ctx, w.embedder.linear_w, x);   // [hidden, T_frames]
+    x = ggml_mul_mat(ctx, w.embedder.linear_w, x);  // [hidden, T_frames]
     x = ggml_silu(ctx, x);
     named(x, "enc.embedder.linear.out");
     eb.dumps.linear_out = x;
@@ -313,24 +319,24 @@ EncoderBuild build_encoder_graph(ggml_context *                       ctx,
     // ---- conv1: causal, stride 2, hidden → 2·hidden ----
     // Transpose [hidden, T_frames] → [T_frames, hidden] for conv_1d_f32.
     {
-        x = ggml_cont(ctx, ggml_transpose(ctx, x));
+        x                = ggml_cont(ctx, ggml_transpose(ctx, x));
         // → ne=[T_frames, hidden]
-        x = ggml_reshape_3d(ctx, x, T_frames, hidden, 1);
+        x                = ggml_reshape_3d(ctx, x, T_frames, hidden, 1);
         // Left-pad ne[0] by k-1=4 (causal).
-        x = ggml_pad_ext(ctx, x,
-                         /*lp0=*/4, /*rp0=*/0,
-                         /*lp1=*/0, /*rp1=*/0,
-                         /*lp2=*/0, /*rp2=*/0,
-                         /*lp3=*/0, /*rp3=*/0);
-        x = conf::conv_1d_f32(ctx, w.embedder.conv1_w, x,
-                              /*stride=*/2, /*padding=*/0, /*dilation=*/1);
+        x                = ggml_pad_ext(ctx, x,
+                                        /*lp0=*/4, /*rp0=*/0,
+                                        /*lp1=*/0, /*rp1=*/0,
+                                        /*lp2=*/0, /*rp2=*/0,
+                                        /*lp3=*/0, /*rp3=*/0);
+        x                = conf::conv_1d_f32(ctx, w.embedder.conv1_w, x,
+                                             /*stride=*/2, /*padding=*/0, /*dilation=*/1);
         // x ne=[T1, hidden2, 1]
-        x = add_conv1d_bias(ctx, x, w.embedder.conv1_b);
-        x = ggml_silu(ctx, x);
+        x                = add_conv1d_bias(ctx, x, w.embedder.conv1_b);
+        x                = ggml_silu(ctx, x);
         // Reshape to 2-D [T1, hidden2] then transpose to [hidden2, T1] for dump.
         const int64_t T1 = x->ne[0];
-        x = ggml_reshape_2d(ctx, x, T1, hidden2);
-        x = ggml_cont(ctx, ggml_transpose(ctx, x));
+        x                = ggml_reshape_2d(ctx, x, T1, hidden2);
+        x                = ggml_cont(ctx, ggml_transpose(ctx, x));
     }
     named(x, "enc.embedder.conv1.out");
     eb.dumps.conv1_out = x;
@@ -339,22 +345,22 @@ EncoderBuild build_encoder_graph(ggml_context *                       ctx,
     // ---- conv2: causal, stride 2, 2·hidden → hidden (NO SiLU) ----
     {
         // x ne=[hidden2, T1]. Transpose to [T1, hidden2].
-        x = ggml_cont(ctx, ggml_transpose(ctx, x));
-        const int64_t T1 = x->ne[0];
-        x = ggml_reshape_3d(ctx, x, T1, hidden2, 1);
-        x = ggml_pad_ext(ctx, x,
-                         /*lp0=*/4, /*rp0=*/0,
-                         /*lp1=*/0, /*rp1=*/0,
-                         /*lp2=*/0, /*rp2=*/0,
-                         /*lp3=*/0, /*rp3=*/0);
-        x = conf::conv_1d_f32(ctx, w.embedder.conv2_w, x,
-                              /*stride=*/2, /*padding=*/0, /*dilation=*/1);
+        x                          = ggml_cont(ctx, ggml_transpose(ctx, x));
+        const int64_t T1           = x->ne[0];
+        x                          = ggml_reshape_3d(ctx, x, T1, hidden2, 1);
+        x                          = ggml_pad_ext(ctx, x,
+                                                  /*lp0=*/4, /*rp0=*/0,
+                                                  /*lp1=*/0, /*rp1=*/0,
+                                                  /*lp2=*/0, /*rp2=*/0,
+                                                  /*lp3=*/0, /*rp3=*/0);
+        x                          = conf::conv_1d_f32(ctx, w.embedder.conv2_w, x,
+                                                       /*stride=*/2, /*padding=*/0, /*dilation=*/1);
         // x ne=[T_enc, hidden, 1]
-        x = add_conv1d_bias(ctx, x, w.embedder.conv2_b);
+        x                          = add_conv1d_bias(ctx, x, w.embedder.conv2_b);
         // NO SiLU after conv2.
         const int64_t T_enc_actual = x->ne[0];
-        x = ggml_reshape_2d(ctx, x, T_enc_actual, hidden);
-        x = ggml_cont(ctx, ggml_transpose(ctx, x));
+        x                          = ggml_reshape_2d(ctx, x, T_enc_actual, hidden);
+        x                          = ggml_cont(ctx, ggml_transpose(ctx, x));
         // x ne=[hidden, T_enc]
     }
     named(x, "enc.embedder.conv2.out");
@@ -365,7 +371,7 @@ EncoderBuild build_encoder_graph(ggml_context *                       ctx,
     eb.per_layer_masks.assign(hp.enc_n_layers, nullptr);
     for (int i = 0; i < hp.enc_n_layers; ++i) {
         ggml_tensor * mask = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, T_enc, T_enc);
-        char mname[64];
+        char          mname[64];
         std::snprintf(mname, sizeof(mname), "enc.swa_mask.%d", i);
         named(mask, mname);
         ggml_set_input(mask);
@@ -375,9 +381,8 @@ EncoderBuild build_encoder_graph(ggml_context *                       ctx,
     // ---- transformer blocks ----
     eb.dumps.block_outs.reserve(static_cast<size_t>(hp.enc_n_layers));
     for (int i = 0; i < hp.enc_n_layers; ++i) {
-        x = build_encoder_block(ctx, x, eb.per_layer_masks[i],
-                                w.enc_blocks[i], hp,
-                                n_heads, hp.enc_head_dim, use_flash);
+        x = build_encoder_block(ctx, x, eb.per_layer_masks[i], w.enc_blocks[i], hp, n_heads, hp.enc_head_dim,
+                                use_flash);
 
         if (dump_block_index(i, hp.enc_n_layers)) {
             char bname[64];
@@ -400,14 +405,13 @@ EncoderBuild build_encoder_graph(ggml_context *                       ctx,
 
     eb.graph = ggml_new_graph_custom(ctx, 8192, false);
     if (eb.graph == nullptr) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine_streaming encoder: ggml_new_graph_custom failed");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine_streaming encoder: ggml_new_graph_custom failed");
         return eb;
     }
     ggml_build_forward_expand(eb.graph, eb.out);
 
-    (void)kLayerNormEps;
+    (void) kLayerNormEps;
     return eb;
 }
 
-} // namespace transcribe::moonshine_streaming
+}  // namespace transcribe::moonshine_streaming
diff --git a/src/arch/moonshine_streaming/encoder.h b/src/arch/moonshine_streaming/encoder.h
index 50339483..4fbf6566 100644
--- a/src/arch/moonshine_streaming/encoder.h
+++ b/src/arch/moonshine_streaming/encoder.h
@@ -30,14 +30,14 @@ struct MoonshineStreamingHParams;
 struct MoonshineStreamingWeights;
 
 struct EncoderDumps {
-    ggml_tensor * audio_in     = nullptr;
-    ggml_tensor * cmvn_out     = nullptr;
-    ggml_tensor * comp_out     = nullptr;
-    ggml_tensor * linear_out   = nullptr;
-    ggml_tensor * conv1_out    = nullptr;
-    ggml_tensor * conv2_out    = nullptr;
+    ggml_tensor *              audio_in   = nullptr;
+    ggml_tensor *              cmvn_out   = nullptr;
+    ggml_tensor *              comp_out   = nullptr;
+    ggml_tensor *              linear_out = nullptr;
+    ggml_tensor *              conv1_out  = nullptr;
+    ggml_tensor *              conv2_out  = nullptr;
     std::vector<ggml_tensor *> block_outs;
-    ggml_tensor * final_out    = nullptr;
+    ggml_tensor *              final_out = nullptr;
 };
 
 struct EncoderBuild {
@@ -53,7 +53,7 @@ struct EncoderBuild {
     // Output: final encoder hidden state [d_model, T_enc] f32.
     ggml_tensor * out = nullptr;
 
-    EncoderDumps  dumps {};
+    EncoderDumps  dumps{};
     ggml_cgraph * graph = nullptr;
 
     // Number of encoder frames produced for the supplied n_samples.
@@ -76,11 +76,11 @@ int encoder_t_enc(const MoonshineStreamingHParams & hp, int n_samples);
 bool dump_block_index(int i, int n_layers);
 
 // Build the encoder forward graph in compute_ctx.
-EncoderBuild build_encoder_graph(ggml_context *                       compute_ctx,
-                                 const MoonshineStreamingWeights &    weights,
-                                 const MoonshineStreamingHParams &    hp,
-                                 int                                  n_samples,
-                                 bool                                 use_flash = false);
+EncoderBuild build_encoder_graph(ggml_context *                    compute_ctx,
+                                 const MoonshineStreamingWeights & weights,
+                                 const MoonshineStreamingHParams & hp,
+                                 int                               n_samples,
+                                 bool                              use_flash = false);
 
 // Build a host-side sliding-window mask of shape [T_enc, T_enc] for the
 // (L, R) window. Allowed positions are 0.0; blocked are -INF.
@@ -90,9 +90,6 @@ EncoderBuild build_encoder_graph(ggml_context *                       compute_ct
 //   || (k-q >= 1 && k-q < R)  // up to R-1 positions ahead
 //
 // Caller-provided buffer must be at least T_enc*T_enc floats.
-void build_sliding_window_mask(int     T_enc,
-                               int     left_window,
-                               int     right_window,
-                               float * out_mask);
+void build_sliding_window_mask(int T_enc, int left_window, int right_window, float * out_mask);
 
-} // namespace transcribe::moonshine_streaming
+}  // namespace transcribe::moonshine_streaming
diff --git a/src/arch/moonshine_streaming/model.cpp b/src/arch/moonshine_streaming/model.cpp
index 3c6983e1..7f4ee4b9 100644
--- a/src/arch/moonshine_streaming/model.cpp
+++ b/src/arch/moonshine_streaming/model.cpp
@@ -20,14 +20,13 @@
 // (T_emitted - L_total - frontend_pad) encoder frames is unreachable and
 // dropped to bound memory.
 
-#include "moonshine_streaming.h"
-
 #include "decoder.h"
 #include "encoder.h"
-#include "weights.h"
-
-#include "transcribe/moonshine_streaming.h"
-
+#include "ggml-alloc.h"
+#include "ggml-backend.h"
+#include "ggml.h"
+#include "gguf.h"
+#include "moonshine_streaming.h"
 #include "transcribe-arch.h"
 #include "transcribe-batch-util.h"
 #include "transcribe-debug.h"
@@ -37,11 +36,8 @@
 #include "transcribe-loader.h"
 #include "transcribe-log.h"
 #include "transcribe-meta.h"
-
-#include "ggml.h"
-#include "ggml-alloc.h"
-#include "ggml-backend.h"
-#include "gguf.h"
+#include "transcribe/moonshine_streaming.h"
+#include "weights.h"
 
 #include <algorithm>
 #include <cmath>
@@ -59,7 +55,7 @@ namespace transcribe::moonshine_streaming {
 
 extern const Arch arch;
 
-static_assert(std::is_base_of_v<transcribe_model,   MoonshineStreamingModel>);
+static_assert(std::is_base_of_v<transcribe_model, MoonshineStreamingModel>);
 static_assert(std::is_base_of_v<transcribe_session, MoonshineStreamingSession>);
 
 MoonshineStreamingSession::~MoonshineStreamingSession() {
@@ -83,9 +79,7 @@ MoonshineStreamingModel::~MoonshineStreamingModel() {
         ggml_backend_buffer_free(backend_buffer);
         backend_buffer = nullptr;
     }
-    for (auto it = plan.scheduler_list.rbegin();
-         it != plan.scheduler_list.rend(); ++it)
-    {
+    for (auto it = plan.scheduler_list.rbegin(); it != plan.scheduler_list.rend(); ++it) {
         ggml_backend_free(*it);
     }
     plan.scheduler_list.clear();
@@ -103,12 +97,12 @@ MoonshineStreamingModel::~MoonshineStreamingModel() {
 // (dec_max_position_embeddings tokens) covers at ~4 output tokens/sec. 0 means
 // unknown/unbounded. Advisory only — does not reject.
 constexpr int k_tokens_per_sec = 4;  // rough speech-rate estimate; advisory only
+
 int64_t moonshine_streaming_max_audio_ms(const MoonshineStreamingHParams & hp) {
     if (hp.dec_max_position_embeddings <= 0) {
         return 0;
     }
-    return static_cast<int64_t>(hp.dec_max_position_embeddings) * 1000 /
-           k_tokens_per_sec;
+    return static_cast<int64_t>(hp.dec_max_position_embeddings) * 1000 / k_tokens_per_sec;
 }
 
 bool kv_cache_init(MoonshineStreamingKvCache & cache,
@@ -117,17 +111,17 @@ bool kv_cache_init(MoonshineStreamingKvCache & cache,
                    int                         T_enc,
                    int                         d_model,
                    int                         n_layer,
-                   ggml_type                   kv_type)
-{
+                   ggml_type                   kv_type) {
     if (kv_type != GGML_TYPE_F16 && kv_type != GGML_TYPE_F32) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine_streaming kv_cache: unsupported kv_type=%d "
-                     "(only F16/F32)", static_cast<int>(kv_type));
+                "moonshine_streaming kv_cache: unsupported kv_type=%d "
+                "(only F16/F32)",
+                static_cast<int>(kv_type));
         return false;
     }
 
-    const size_t ctx_size = 4 * ggml_tensor_overhead() + 256;
-    ggml_init_params params { ctx_size, nullptr, /*no_alloc=*/true };
+    const size_t     ctx_size = 4 * ggml_tensor_overhead() + 256;
+    ggml_init_params params{ ctx_size, nullptr, /*no_alloc=*/true };
     cache.ctx = ggml_init(params);
     if (cache.ctx == nullptr) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine_streaming kv_cache: ggml_init failed");
@@ -142,8 +136,8 @@ bool kv_cache_init(MoonshineStreamingKvCache & cache,
     cache.cross_k = ggml_new_tensor_1d(cache.ctx, kv_type, cross_elements);
     cache.cross_v = ggml_new_tensor_1d(cache.ctx, kv_type, cross_elements);
 
-    ggml_set_name(cache.self_k,  "kv_self_k");
-    ggml_set_name(cache.self_v,  "kv_self_v");
+    ggml_set_name(cache.self_k, "kv_self_k");
+    ggml_set_name(cache.self_v, "kv_self_v");
     ggml_set_name(cache.cross_k, "kv_cross_k");
     ggml_set_name(cache.cross_v, "kv_cross_v");
 
@@ -172,11 +166,11 @@ bool kv_cache_init_batched(MoonshineStreamingKvCache & cache,
                            int                         d_model,
                            int                         n_layer,
                            int                         n_batch,
-                           ggml_type                   kv_type)
-{
+                           ggml_type                   kv_type) {
     if (n_batch <= 1) {
-        if (!kv_cache_init(cache, backend, n_ctx, T_enc, d_model, n_layer, kv_type))
+        if (!kv_cache_init(cache, backend, n_ctx, T_enc, d_model, n_layer, kv_type)) {
             return false;
+        }
         cache.n_batch = 1;
         return true;
     }
@@ -184,31 +178,37 @@ bool kv_cache_init_batched(MoonshineStreamingKvCache & cache,
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine_streaming kv_cache(batched): unsupported kv_type");
         return false;
     }
-    const size_t ctx_size = 4 * ggml_tensor_overhead() + 256;
-    ggml_init_params params { ctx_size, nullptr, /*no_alloc=*/true };
+    const size_t     ctx_size = 4 * ggml_tensor_overhead() + 256;
+    ggml_init_params params{ ctx_size, nullptr, /*no_alloc=*/true };
     cache.ctx = ggml_init(params);
-    if (cache.ctx == nullptr) return false;
+    if (cache.ctx == nullptr) {
+        return false;
+    }
 
-    const int64_t self_elements =
-        static_cast<int64_t>(d_model) * n_layer * n_ctx * n_batch;
-    const int64_t cross_elements =
-        static_cast<int64_t>(d_model) * n_layer * T_enc * n_batch;
-    cache.self_k  = ggml_new_tensor_1d(cache.ctx, kv_type, self_elements);
-    cache.self_v  = ggml_new_tensor_1d(cache.ctx, kv_type, self_elements);
-    cache.cross_k = ggml_new_tensor_1d(cache.ctx, kv_type, cross_elements);
-    cache.cross_v = ggml_new_tensor_1d(cache.ctx, kv_type, cross_elements);
-    ggml_set_name(cache.self_k,  "kv_self_k");
-    ggml_set_name(cache.self_v,  "kv_self_v");
+    const int64_t self_elements  = static_cast<int64_t>(d_model) * n_layer * n_ctx * n_batch;
+    const int64_t cross_elements = static_cast<int64_t>(d_model) * n_layer * T_enc * n_batch;
+    cache.self_k                 = ggml_new_tensor_1d(cache.ctx, kv_type, self_elements);
+    cache.self_v                 = ggml_new_tensor_1d(cache.ctx, kv_type, self_elements);
+    cache.cross_k                = ggml_new_tensor_1d(cache.ctx, kv_type, cross_elements);
+    cache.cross_v                = ggml_new_tensor_1d(cache.ctx, kv_type, cross_elements);
+    ggml_set_name(cache.self_k, "kv_self_k");
+    ggml_set_name(cache.self_v, "kv_self_v");
     ggml_set_name(cache.cross_k, "kv_cross_k");
     ggml_set_name(cache.cross_v, "kv_cross_v");
 
     cache.buffer = ggml_backend_alloc_ctx_tensors(cache.ctx, backend);
     if (cache.buffer == nullptr) {
-        ggml_free(cache.ctx); cache.ctx = nullptr; return false;
+        ggml_free(cache.ctx);
+        cache.ctx = nullptr;
+        return false;
     }
     ggml_backend_buffer_clear(cache.buffer, 0);
-    cache.n_ctx = n_ctx; cache.T_enc = T_enc; cache.n = 0; cache.head = 0;
-    cache.n_batch = n_batch; cache.cross_populated = false;
+    cache.n_ctx           = n_ctx;
+    cache.T_enc           = T_enc;
+    cache.n               = 0;
+    cache.head            = 0;
+    cache.n_batch         = n_batch;
+    cache.cross_populated = false;
     return true;
 }
 
@@ -216,112 +216,104 @@ namespace {
 
 constexpr const char k_default_variant[] = "moonshine-streaming";
 
-extern transcribe_status load        (Loader &, const transcribe_model_load_params *,
-                                      transcribe_model **);
-extern transcribe_status init_context(transcribe_model *, const transcribe_session_params *,
-                                      transcribe_session **);
-extern transcribe_status run         (transcribe_session *, const float *, int,
-                                      const transcribe_run_params *);
-
-transcribe_status load(
-    Loader &                          loader,
-    const transcribe_model_load_params *   params,
-    transcribe_model **               out_model)
-{
+extern transcribe_status load(Loader &, const transcribe_model_load_params *, transcribe_model **);
+extern transcribe_status init_context(transcribe_model *, const transcribe_session_params *, transcribe_session **);
+extern transcribe_status run(transcribe_session *, const float *, int, const transcribe_run_params *);
+
+transcribe_status load(Loader & loader, const transcribe_model_load_params * params, transcribe_model ** out_model) {
     const int64_t t_load_start = ggml_time_us();
 
-    auto m = std::make_unique<MoonshineStreamingModel>();
+    auto m       = std::make_unique<MoonshineStreamingModel>();
     m->arch      = &arch;
     m->t_load_us = 0;
 
-    m->variant = loader.variant().empty() ? k_default_variant
-                                          : loader.variant();
+    m->variant = loader.variant().empty() ? k_default_variant : loader.variant();
     m->backend.clear();
 
     apply_family_invariants(*m);
     m->caps.n_languages = 0;
     m->caps.languages   = nullptr;
 
-    if (auto st = read_capability_kv(loader.gguf(), m->caps); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_languages_kv (loader.gguf(), *m);       st != TRANSCRIBE_OK) return st;
+    if (auto st = read_capability_kv(loader.gguf(), m->caps); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_languages_kv(loader.gguf(), *m); st != TRANSCRIBE_OK) {
+        return st;
+    }
 
-    if (auto st = m->tok.load(loader.gguf());                              st != TRANSCRIBE_OK) return st;
-    if (auto st = read_moonshine_streaming_hparams(loader.gguf(), m->hparams); st != TRANSCRIBE_OK) return st;
+    if (auto st = m->tok.load(loader.gguf()); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_moonshine_streaming_hparams(loader.gguf(), m->hparams); st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Publish the advisory window now that the decoder position cap is known
     // (first point it's available after hparams).
     m->caps.max_audio_ms = moonshine_streaming_max_audio_ms(m->hparams);
 
-    gguf_init_params init_params {};
-    init_params.no_alloc = true;
-    init_params.ctx      = &m->ctx_meta;
+    gguf_init_params init_params{};
+    init_params.no_alloc     = true;
+    init_params.ctx          = &m->ctx_meta;
     gguf_context * gguf_data = gguf_init_from_file(loader.path().c_str(), init_params);
-    if (gguf_data == nullptr) return TRANSCRIBE_ERR_GGUF;
+    if (gguf_data == nullptr) {
+        return TRANSCRIBE_ERR_GGUF;
+    }
 
-    if (auto st = build_moonshine_streaming_weights(m->ctx_meta, m->hparams, m->weights);
-        st != TRANSCRIBE_OK)
-    {
+    if (auto st = build_moonshine_streaming_weights(m->ctx_meta, m->hparams, m->weights); st != TRANSCRIBE_OK) {
         gguf_free(gguf_data);
         return st;
     }
 
-    const transcribe_backend_request backend_req =
-        (params != nullptr) ? params->backend : TRANSCRIBE_BACKEND_AUTO;
-    if (auto st = transcribe::load_common::init_backends(
-            backend_req, (params != nullptr) ? params->gpu_device : 0, "moonshine_streaming", m->plan); st != TRANSCRIBE_OK)
-    {
+    const transcribe_backend_request backend_req = (params != nullptr) ? params->backend : TRANSCRIBE_BACKEND_AUTO;
+    if (auto st = transcribe::load_common::init_backends(backend_req, (params != nullptr) ? params->gpu_device : 0,
+                                                         "moonshine_streaming", m->plan);
+        st != TRANSCRIBE_OK) {
         gguf_free(gguf_data);
         return st;
     }
-    m->backend = ggml_backend_name(m->plan.primary);
+    m->backend         = ggml_backend_name(m->plan.primary);
     m->primary_backend = m->plan.primary;
 
-    ggml_backend_buffer_t weights_buffer =
-        ggml_backend_alloc_ctx_tensors(m->ctx_meta, m->plan.primary);
+    ggml_backend_buffer_t weights_buffer = ggml_backend_alloc_ctx_tensors(m->ctx_meta, m->plan.primary);
     if (weights_buffer == nullptr) {
         gguf_free(gguf_data);
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine_streaming: ggml_backend_alloc_ctx_tensors failed");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine_streaming: ggml_backend_alloc_ctx_tensors failed");
         return TRANSCRIBE_ERR_GGUF;
     }
     m->backend_buffer = weights_buffer;
-    ggml_backend_buffer_set_usage(weights_buffer,
-                                  GGML_BACKEND_BUFFER_USAGE_WEIGHTS);
+    ggml_backend_buffer_set_usage(weights_buffer, GGML_BACKEND_BUFFER_USAGE_WEIGHTS);
 
-    if (auto st = transcribe::load_common::stream_tensor_data(
-            loader.path(), gguf_data, m->ctx_meta, "moonshine_streaming");
-        st != TRANSCRIBE_OK)
-    {
+    if (auto st =
+            transcribe::load_common::stream_tensor_data(loader.path(), gguf_data, m->ctx_meta, "moonshine_streaming");
+        st != TRANSCRIBE_OK) {
         gguf_free(gguf_data);
         return st;
     }
     gguf_free(gguf_data);
 
     m->t_load_us = ggml_time_us() - t_load_start;
-    *out_model = m.release();
+    *out_model   = m.release();
     return TRANSCRIBE_OK;
 }
 
-transcribe_status init_context(
-    transcribe_model *                model,
-    const transcribe_session_params * params,
-    transcribe_session **             out_ctx)
-{
+transcribe_status init_context(transcribe_model *                model,
+                               const transcribe_session_params * params,
+                               transcribe_session **             out_ctx) {
     if (model->arch != &arch) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
-    auto cc = std::make_unique<MoonshineStreamingSession>();
+    auto cc       = std::make_unique<MoonshineStreamingSession>();
     cc->model     = model;
     cc->n_threads = params->n_threads;
     cc->kv_type   = params->kv_type;
 
-    cc->encoder_use_flash = true;    // sliding-window mask is uploaded as
-                                     // F32 and cast to F16 inside the graph,
-                                     // which is the format flash_attn_ext
-                                     // expects. Validated under tolerances.
+    cc->encoder_use_flash = true;  // sliding-window mask is uploaded as
+                                   // F32 and cast to F16 inside the graph,
+                                   // which is the format flash_attn_ext
+                                   // expects. Validated under tolerances.
     cc->decoder_use_flash = true;
-    transcribe::flash::apply_env_overrides(
-        cc->encoder_use_flash, cc->decoder_use_flash);
+    transcribe::flash::apply_env_overrides(cc->encoder_use_flash, cc->decoder_use_flash);
 
     *out_ctx = cc.release();
     return TRANSCRIBE_OK;
@@ -336,19 +328,19 @@ bool ensure_compute_ctx(MoonshineStreamingSession * cc, size_t mem_size) {
         ggml_free(cc->compute_ctx);
         cc->compute_ctx = nullptr;
     }
-    ggml_init_params init_params {};
+    ggml_init_params init_params{};
     init_params.mem_size   = mem_size;
     init_params.mem_buffer = nullptr;
     init_params.no_alloc   = true;
-    cc->compute_ctx = ggml_init(init_params);
+    cc->compute_ctx        = ggml_init(init_params);
     return cc->compute_ctx != nullptr;
 }
 
 ggml_tensor * find_tensor_by_name(ggml_context * gctx, const char * name) {
-    for (ggml_tensor * t = ggml_get_first_tensor(gctx); t != nullptr;
-         t = ggml_get_next_tensor(gctx, t))
-    {
-        if (std::strcmp(t->name, name) == 0) return t;
+    for (ggml_tensor * t = ggml_get_first_tensor(gctx); t != nullptr; t = ggml_get_next_tensor(gctx, t)) {
+        if (std::strcmp(t->name, name) == 0) {
+            return t;
+        }
     }
     return nullptr;
 }
@@ -363,8 +355,8 @@ std::vector<float> right_pad_pcm(const float * pcm, int n_samples, int frame_len
     if (frame_len <= 0) {
         return std::vector<float>(pcm, pcm + n_samples);
     }
-    const int rem = n_samples % frame_len;
-    const int pad = (rem == 0) ? 0 : (frame_len - rem);
+    const int          rem = n_samples % frame_len;
+    const int          pad = (rem == 0) ? 0 : (frame_len - rem);
     std::vector<float> out;
     out.resize(static_cast<size_t>(n_samples) + pad, 0.0f);
     std::memcpy(out.data(), pcm, static_cast<size_t>(n_samples) * sizeof(float));
@@ -372,17 +364,14 @@ std::vector<float> right_pad_pcm(const float * pcm, int n_samples, int frame_len
 }
 
 // Ensure the per-context backend scheduler is allocated. Idempotent.
-transcribe_status ensure_sched(MoonshineStreamingSession * cc,
-                               MoonshineStreamingModel *   cm)
-{
-    if (cc->sched != nullptr) return TRANSCRIBE_OK;
-    cc->sched = ggml_backend_sched_new(
-        cm->plan.scheduler_list.data(), nullptr,
-        static_cast<int>(cm->plan.scheduler_list.size()),
-        16384, false, true);
+transcribe_status ensure_sched(MoonshineStreamingSession * cc, MoonshineStreamingModel * cm) {
+    if (cc->sched != nullptr) {
+        return TRANSCRIBE_OK;
+    }
+    cc->sched = ggml_backend_sched_new(cm->plan.scheduler_list.data(), nullptr,
+                                       static_cast<int>(cm->plan.scheduler_list.size()), 16384, false, true);
     if (cc->sched == nullptr) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine_streaming: ggml_backend_sched_new failed");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine_streaming: ggml_backend_sched_new failed");
         return TRANSCRIBE_ERR_GGUF;
     }
     return TRANSCRIBE_OK;
@@ -399,7 +388,9 @@ int cumulative_right_context(const MoonshineStreamingHParams & hp) {
     int total = 0;
     for (int i = 0; i < hp.enc_n_layers; ++i) {
         const int R = hp.enc_sliding_windows[2 * i + 1];
-        if (R > 0) total += (R - 1);
+        if (R > 0) {
+            total += (R - 1);
+        }
     }
     return total;
 }
@@ -411,7 +402,9 @@ int cumulative_left_context(const MoonshineStreamingHParams & hp) {
     int total = 0;
     for (int i = 0; i < hp.enc_n_layers; ++i) {
         const int L = hp.enc_sliding_windows[2 * i + 0];
-        if (L > 1) total += (L - 1);
+        if (L > 1) {
+            total += (L - 1);
+        }
     }
     return total;
 }
@@ -447,15 +440,12 @@ int decode_generation_budget(const MoonshineStreamingHParams & hp, int T_enc) {
     if (hp.enc_frame_len <= 0 || T_enc <= 0) {
         return 0;
     }
-    constexpr int64_t k_native_sr_hz   = 16000;
-    constexpr int64_t k_budget_num     = 13;  // 6.5 tokens/sec, numerator
-    constexpr int64_t k_budget_den     = 2;   //                 denominator
-    constexpr int64_t k_budget_floor   = 24;  // headroom for very short clips
-    const int64_t audio_samples =
-        static_cast<int64_t>(T_enc) * samples_per_encoder_frame(hp);
-    return static_cast<int>(
-        audio_samples * k_budget_num / (k_budget_den * k_native_sr_hz)
-        + k_budget_floor);
+    constexpr int64_t k_native_sr_hz = 16000;
+    constexpr int64_t k_budget_num   = 13;  // 6.5 tokens/sec, numerator
+    constexpr int64_t k_budget_den   = 2;   //                 denominator
+    constexpr int64_t k_budget_floor = 24;  // headroom for very short clips
+    const int64_t     audio_samples  = static_cast<int64_t>(T_enc) * samples_per_encoder_frame(hp);
+    return static_cast<int>(audio_samples * k_budget_num / (k_budget_den * k_native_sr_hz) + k_budget_floor);
 }
 
 // Encoder helper: build the graph for `n_samples` PCM, upload PCM + masks,
@@ -464,22 +454,19 @@ int decode_generation_budget(const MoonshineStreamingHParams & hp, int T_enc) {
 // passes false so per-feed runs do not clobber reference dump artifacts.
 //
 // n_samples must be > 0 and a multiple of hp.enc_frame_len.
-transcribe_status encode_window_to_host(
-    MoonshineStreamingSession * cc,
-    MoonshineStreamingModel *   cm,
-    const float *               pcm,
-    int                         n_samples,
-    bool                        emit_dumps,
-    std::vector<float> &        out_enc_host,
-    int &                       out_T_enc)
-{
+transcribe_status encode_window_to_host(MoonshineStreamingSession * cc,
+                                        MoonshineStreamingModel *   cm,
+                                        const float *               pcm,
+                                        int                         n_samples,
+                                        bool                        emit_dumps,
+                                        std::vector<float> &        out_enc_host,
+                                        int &                       out_T_enc) {
     const auto & hp = cm->hparams;
-    if (n_samples <= 0 || hp.enc_frame_len <= 0 ||
-        n_samples % hp.enc_frame_len != 0)
-    {
+    if (n_samples <= 0 || hp.enc_frame_len <= 0 || n_samples % hp.enc_frame_len != 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine_streaming encode_window: invalid n_samples=%d "
-                     "(frame_len=%d)", n_samples, hp.enc_frame_len);
+                "moonshine_streaming encode_window: invalid n_samples=%d "
+                "(frame_len=%d)",
+                n_samples, hp.enc_frame_len);
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
 
@@ -487,61 +474,62 @@ transcribe_status encode_window_to_host(
 
     if (!ensure_compute_ctx(cc, 16 * 1024 * 1024)) {
         transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "moonshine_streaming encode_window: compute context allocation "
-            "failed — out of memory.");
+                            "moonshine_streaming encode_window: compute context allocation "
+                            "failed — out of memory.");
         return TRANSCRIBE_ERR_OOM;
     }
 
-    EncoderBuild eb = build_encoder_graph(
-        cc->compute_ctx, cm->weights, hp,
-        n_samples, cc->encoder_use_flash);
+    EncoderBuild eb = build_encoder_graph(cc->compute_ctx, cm->weights, hp, n_samples, cc->encoder_use_flash);
     if (eb.audio_in == nullptr || eb.out == nullptr || eb.graph == nullptr) {
         return TRANSCRIBE_ERR_GGUF;
     }
     const int T_enc = eb.T_enc;
 
-    if (auto st = ensure_sched(cc, cm); st != TRANSCRIBE_OK) return st;
+    if (auto st = ensure_sched(cc, cm); st != TRANSCRIBE_OK) {
+        return st;
+    }
     ggml_backend_sched_reset(cc->sched);
     if (!ggml_backend_sched_alloc_graph(cc->sched, eb.graph)) {
         transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "moonshine_streaming encode_window: encoder graph allocation "
-            "failed — out of memory.");
+                            "moonshine_streaming encode_window: encoder graph allocation "
+                            "failed — out of memory.");
         return TRANSCRIBE_ERR_OOM;
     }
 
-    ggml_backend_tensor_set(eb.audio_in, pcm,
-                            0, static_cast<size_t>(n_samples) * sizeof(float));
+    ggml_backend_tensor_set(eb.audio_in, pcm, 0, static_cast<size_t>(n_samples) * sizeof(float));
     {
         std::vector<float> mask_buf(static_cast<size_t>(T_enc) * T_enc);
         for (int i = 0; i < hp.enc_n_layers; ++i) {
             const int L = hp.enc_sliding_windows[2 * i + 0];
             const int R = hp.enc_sliding_windows[2 * i + 1];
             build_sliding_window_mask(T_enc, L, R, mask_buf.data());
-            ggml_backend_tensor_set(eb.per_layer_masks[i], mask_buf.data(),
-                                    0, mask_buf.size() * sizeof(float));
+            ggml_backend_tensor_set(eb.per_layer_masks[i], mask_buf.data(), 0, mask_buf.size() * sizeof(float));
         }
     }
 
     apply_thread_policy(cc);
 
     if (ggml_backend_sched_graph_compute(cc->sched, eb.graph) != GGML_STATUS_SUCCESS) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine_streaming encode_window: encoder compute failed");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine_streaming encode_window: encoder compute failed");
         return TRANSCRIBE_ERR_GGUF;
     }
 
     if (emit_dumps) {
         auto try_dump = [](const char * name, ggml_tensor * t, const char * stage) {
-            if (t != nullptr) transcribe::debug::dump_tensor(name, t, stage);
+            if (t != nullptr) {
+                transcribe::debug::dump_tensor(name, t, stage);
+            }
         };
-        try_dump("enc.audio.in",            eb.dumps.audio_in,   "encoder.audio.in");
-        try_dump("enc.embedder.cmvn.out",   eb.dumps.cmvn_out,   "encoder.embedder.cmvn");
-        try_dump("enc.embedder.comp.out",   eb.dumps.comp_out,   "encoder.embedder.comp");
+        try_dump("enc.audio.in", eb.dumps.audio_in, "encoder.audio.in");
+        try_dump("enc.embedder.cmvn.out", eb.dumps.cmvn_out, "encoder.embedder.cmvn");
+        try_dump("enc.embedder.comp.out", eb.dumps.comp_out, "encoder.embedder.comp");
         try_dump("enc.embedder.linear.out", eb.dumps.linear_out, "encoder.embedder.linear");
-        try_dump("enc.embedder.conv1.out",  eb.dumps.conv1_out,  "encoder.embedder.conv1");
-        try_dump("enc.embedder.conv2.out",  eb.dumps.conv2_out,  "encoder.embedder.conv2");
+        try_dump("enc.embedder.conv1.out", eb.dumps.conv1_out, "encoder.embedder.conv1");
+        try_dump("enc.embedder.conv2.out", eb.dumps.conv2_out, "encoder.embedder.conv2");
         for (size_t i = 0; i < eb.dumps.block_outs.size(); ++i) {
-            if (!dump_block_index(static_cast<int>(i), hp.enc_n_layers)) continue;
+            if (!dump_block_index(static_cast<int>(i), hp.enc_n_layers)) {
+                continue;
+            }
             char bname[64], stage[64];
             std::snprintf(bname, sizeof(bname), "enc.block.%zu.out", i);
             std::snprintf(stage, sizeof(stage), "encoder.block%zu.out", i);
@@ -551,10 +539,8 @@ transcribe_status encode_window_to_host(
     }
 
     const int enc_h = hp.enc_d_model;
-    out_enc_host.assign(static_cast<size_t>(enc_h) *
-                        static_cast<size_t>(T_enc), 0.0f);
-    ggml_backend_tensor_get(eb.out, out_enc_host.data(), 0,
-                            out_enc_host.size() * sizeof(float));
+    out_enc_host.assign(static_cast<size_t>(enc_h) * static_cast<size_t>(T_enc), 0.0f);
+    ggml_backend_tensor_get(eb.out, out_enc_host.data(), 0, out_enc_host.size() * sizeof(float));
     out_T_enc = T_enc;
 
     cc->t_encode_us += ggml_time_us() - t_start;
@@ -569,31 +555,33 @@ transcribe_status encode_window_to_host(
 // pipeline). emit_dumps gates the `adapter.*` dump points.
 //
 // out_adapter is resized to [dec_d_model, n_frames] f32 row-major.
-transcribe_status apply_adapter_window(
-    MoonshineStreamingSession * cc,
-    MoonshineStreamingModel *   cm,
-    const float *               enc_data,
-    int                         n_frames,
-    int                         abs_frame_offset,
-    bool                        emit_dumps,
-    std::vector<float> &        out_adapter)
-{
-    if (cc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
+transcribe_status apply_adapter_window(MoonshineStreamingSession * cc,
+                                       MoonshineStreamingModel *   cm,
+                                       const float *               enc_data,
+                                       int                         n_frames,
+                                       int                         abs_frame_offset,
+                                       bool                        emit_dumps,
+                                       std::vector<float> &        out_adapter) {
+    if (cc->poll_abort()) {
+        return TRANSCRIBE_ERR_ABORTED;
+    }
     if (n_frames <= 0 || abs_frame_offset < 0) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
 
-    const auto & hp = cm->hparams;
-    const int enc_h = hp.enc_d_model;
-    const int dec_h = hp.dec_d_model;
+    const auto & hp    = cm->hparams;
+    const int    enc_h = hp.enc_d_model;
+    const int    dec_h = hp.dec_d_model;
 
     const int64_t t_start = ggml_time_us();
 
-    if (auto st = ensure_sched(cc, cm); st != TRANSCRIBE_OK) return st;
+    if (auto st = ensure_sched(cc, cm); st != TRANSCRIBE_OK) {
+        return st;
+    }
     if (!ensure_compute_ctx(cc, 4 * 1024 * 1024)) {
         transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "moonshine_streaming adapter: compute context allocation failed — "
-            "out of memory.");
+                            "moonshine_streaming adapter: compute context allocation failed — "
+                            "out of memory.");
         return TRANSCRIBE_ERR_OOM;
     }
 
@@ -604,36 +592,35 @@ transcribe_status apply_adapter_window(
     ggml_backend_sched_reset(cc->sched);
     if (!ggml_backend_sched_alloc_graph(cc->sched, ab.graph)) {
         transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "moonshine_streaming adapter: graph allocation failed — "
-            "out of memory.");
+                            "moonshine_streaming adapter: graph allocation failed — "
+                            "out of memory.");
         return TRANSCRIBE_ERR_OOM;
     }
     ggml_backend_tensor_set(ab.encoder_out_in, enc_data, 0,
-                            static_cast<size_t>(enc_h) *
-                                static_cast<size_t>(n_frames) * sizeof(float));
+                            static_cast<size_t>(enc_h) * static_cast<size_t>(n_frames) * sizeof(float));
     std::vector<int32_t> pos_ids(static_cast<size_t>(n_frames));
-    for (int i = 0; i < n_frames; ++i) pos_ids[i] = abs_frame_offset + i;
-    ggml_backend_tensor_set(ab.pos_ids_in, pos_ids.data(), 0,
-                            pos_ids.size() * sizeof(int32_t));
+    for (int i = 0; i < n_frames; ++i) {
+        pos_ids[i] = abs_frame_offset + i;
+    }
+    ggml_backend_tensor_set(ab.pos_ids_in, pos_ids.data(), 0, pos_ids.size() * sizeof(int32_t));
 
     if (ggml_backend_sched_graph_compute(cc->sched, ab.graph) != GGML_STATUS_SUCCESS) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine_streaming adapter: compute failed");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine_streaming adapter: compute failed");
         return TRANSCRIBE_ERR_GGUF;
     }
 
     if (emit_dumps) {
         auto try_dump = [](const char * name, ggml_tensor * t, const char * stage) {
-            if (t != nullptr) transcribe::debug::dump_tensor(name, t, stage);
+            if (t != nullptr) {
+                transcribe::debug::dump_tensor(name, t, stage);
+            }
         };
         try_dump("adapter.pos_emb", ab.pos_emb_out, "adapter.pos_emb");
-        try_dump("adapter.out",     ab.out,         "adapter.out");
+        try_dump("adapter.out", ab.out, "adapter.out");
     }
 
-    out_adapter.assign(static_cast<size_t>(dec_h) *
-                       static_cast<size_t>(n_frames), 0.0f);
-    ggml_backend_tensor_get(ab.out, out_adapter.data(), 0,
-                            out_adapter.size() * sizeof(float));
+    out_adapter.assign(static_cast<size_t>(dec_h) * static_cast<size_t>(n_frames), 0.0f);
+    ggml_backend_tensor_get(ab.out, out_adapter.data(), 0, out_adapter.size() * sizeof(float));
 
     cc->t_decode_us += ggml_time_us() - t_start;
     return TRANSCRIBE_OK;
@@ -648,77 +635,71 @@ transcribe_status apply_adapter_window(
 //
 // Wall-clock accumulates into cc->t_decode_us (cross-KV projection is
 // part of the decoder pipeline).
-transcribe_status project_cross_kv_window(
-    MoonshineStreamingSession *           cc,
-    MoonshineStreamingModel *             cm,
-    const float *                         adapter_data,
-    int                                   n_frames,
-    std::vector<std::vector<float>> &     out_per_layer_k,
-    std::vector<std::vector<float>> &     out_per_layer_v)
-{
-    if (cc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
-    if (n_frames <= 0) return TRANSCRIBE_ERR_INVALID_ARG;
+transcribe_status project_cross_kv_window(MoonshineStreamingSession *       cc,
+                                          MoonshineStreamingModel *         cm,
+                                          const float *                     adapter_data,
+                                          int                               n_frames,
+                                          std::vector<std::vector<float>> & out_per_layer_k,
+                                          std::vector<std::vector<float>> & out_per_layer_v) {
+    if (cc->poll_abort()) {
+        return TRANSCRIBE_ERR_ABORTED;
+    }
+    if (n_frames <= 0) {
+        return TRANSCRIBE_ERR_INVALID_ARG;
+    }
 
-    const auto & hp = cm->hparams;
-    const int dec_h    = hp.dec_d_model;
-    const int n_layers = hp.dec_n_layers;
-    if (static_cast<int>(out_per_layer_k.size()) != n_layers ||
-        static_cast<int>(out_per_layer_v.size()) != n_layers)
-    {
+    const auto & hp       = cm->hparams;
+    const int    dec_h    = hp.dec_d_model;
+    const int    n_layers = hp.dec_n_layers;
+    if (static_cast<int>(out_per_layer_k.size()) != n_layers || static_cast<int>(out_per_layer_v.size()) != n_layers) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine_streaming cross_kv_proj: per-layer buffer "
-                     "size mismatch (got K=%zu V=%zu, expected %d)",
-                     out_per_layer_k.size(), out_per_layer_v.size(), n_layers);
+                "moonshine_streaming cross_kv_proj: per-layer buffer "
+                "size mismatch (got K=%zu V=%zu, expected %d)",
+                out_per_layer_k.size(), out_per_layer_v.size(), n_layers);
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
 
     const int64_t t_start = ggml_time_us();
 
-    if (auto st = ensure_sched(cc, cm); st != TRANSCRIBE_OK) return st;
+    if (auto st = ensure_sched(cc, cm); st != TRANSCRIBE_OK) {
+        return st;
+    }
     if (!ensure_compute_ctx(cc, 8 * 1024 * 1024)) {
         transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "moonshine_streaming cross_kv_proj: compute context allocation "
-            "failed — out of memory.");
+                            "moonshine_streaming cross_kv_proj: compute context allocation "
+                            "failed — out of memory.");
         return TRANSCRIBE_ERR_OOM;
     }
 
-    CrossKVProjectionBuild pb = build_cross_kv_projection_graph(
-        cc->compute_ctx, cm->weights, hp, n_frames);
-    if (pb.graph == nullptr) return TRANSCRIBE_ERR_GGUF;
+    CrossKVProjectionBuild pb = build_cross_kv_projection_graph(cc->compute_ctx, cm->weights, hp, n_frames);
+    if (pb.graph == nullptr) {
+        return TRANSCRIBE_ERR_GGUF;
+    }
 
     ggml_backend_sched_reset(cc->sched);
     if (!ggml_backend_sched_alloc_graph(cc->sched, pb.graph)) {
         transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "moonshine_streaming cross_kv_proj: graph allocation failed — "
-            "out of memory.");
+                            "moonshine_streaming cross_kv_proj: graph allocation failed — "
+                            "out of memory.");
         return TRANSCRIBE_ERR_OOM;
     }
 
     ggml_backend_tensor_set(pb.encoder_out_in, adapter_data, 0,
-                            static_cast<size_t>(dec_h) *
-                                static_cast<size_t>(n_frames) * sizeof(float));
+                            static_cast<size_t>(dec_h) * static_cast<size_t>(n_frames) * sizeof(float));
 
-    if (ggml_backend_sched_graph_compute(cc->sched, pb.graph)
-        != GGML_STATUS_SUCCESS)
-    {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine_streaming cross_kv_proj: compute failed");
+    if (ggml_backend_sched_graph_compute(cc->sched, pb.graph) != GGML_STATUS_SUCCESS) {
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine_streaming cross_kv_proj: compute failed");
         return TRANSCRIBE_ERR_GGUF;
     }
 
-    const size_t per_slice_floats =
-        static_cast<size_t>(dec_h) * static_cast<size_t>(n_frames);
+    const size_t       per_slice_floats = static_cast<size_t>(dec_h) * static_cast<size_t>(n_frames);
     std::vector<float> scratch_k(per_slice_floats);
     std::vector<float> scratch_v(per_slice_floats);
     for (int il = 0; il < n_layers; ++il) {
-        ggml_backend_tensor_get(pb.per_layer_k[il], scratch_k.data(), 0,
-                                per_slice_floats * sizeof(float));
-        ggml_backend_tensor_get(pb.per_layer_v[il], scratch_v.data(), 0,
-                                per_slice_floats * sizeof(float));
-        out_per_layer_k[il].insert(out_per_layer_k[il].end(),
-                                   scratch_k.begin(), scratch_k.end());
-        out_per_layer_v[il].insert(out_per_layer_v[il].end(),
-                                   scratch_v.begin(), scratch_v.end());
+        ggml_backend_tensor_get(pb.per_layer_k[il], scratch_k.data(), 0, per_slice_floats * sizeof(float));
+        ggml_backend_tensor_get(pb.per_layer_v[il], scratch_v.data(), 0, per_slice_floats * sizeof(float));
+        out_per_layer_k[il].insert(out_per_layer_k[il].end(), scratch_k.begin(), scratch_k.end());
+        out_per_layer_v[il].insert(out_per_layer_v[il].end(), scratch_v.begin(), scratch_v.end());
     }
 
     cc->t_decode_us += ggml_time_us() - t_start;
@@ -730,34 +711,34 @@ transcribe_status project_cross_kv_window(
 // dec_max_position_embeddings as its capacity; the cross-attention
 // cache is sized exactly at T_enc. Marks cross_populated = false so a
 // downstream commit / direct-write graph fills it.
-transcribe_status ensure_kv_cache_for_T(
-    MoonshineStreamingSession * cc,
-    MoonshineStreamingModel *   cm,
-    int                         T_enc)
-{
-    if (T_enc <= 0) return TRANSCRIBE_ERR_INVALID_ARG;
+transcribe_status ensure_kv_cache_for_T(MoonshineStreamingSession * cc, MoonshineStreamingModel * cm, int T_enc) {
+    if (T_enc <= 0) {
+        return TRANSCRIBE_ERR_INVALID_ARG;
+    }
 
     const auto & hp = cm->hparams;
 
     ggml_type resolved_kv = GGML_TYPE_COUNT;
-    if (cc->kv_type == TRANSCRIBE_KV_TYPE_F32) resolved_kv = GGML_TYPE_F32;
-    if (cc->kv_type == TRANSCRIBE_KV_TYPE_F16) resolved_kv = GGML_TYPE_F16;
+    if (cc->kv_type == TRANSCRIBE_KV_TYPE_F32) {
+        resolved_kv = GGML_TYPE_F32;
+    }
+    if (cc->kv_type == TRANSCRIBE_KV_TYPE_F16) {
+        resolved_kv = GGML_TYPE_F16;
+    }
 
     if (cc->kv_cache.buffer != nullptr && cc->kv_cache.T_enc != T_enc) {
         cc->kv_cache.free();
     }
     if (cc->kv_cache.buffer == nullptr) {
-        const int n_ctx = hp.dec_max_position_embeddings > 0
-                        ? hp.dec_max_position_embeddings : 512;
+        const int n_ctx      = hp.dec_max_position_embeddings > 0 ? hp.dec_max_position_embeddings : 512;
         ggml_type cache_type = resolved_kv;
-        if (cache_type == GGML_TYPE_COUNT) cache_type = GGML_TYPE_F32;
-        if (!kv_cache_init(cc->kv_cache, cm->plan.primary,
-                           n_ctx, T_enc, hp.dec_d_model, hp.dec_n_layers,
-                           cache_type))
-        {
+        if (cache_type == GGML_TYPE_COUNT) {
+            cache_type = GGML_TYPE_F32;
+        }
+        if (!kv_cache_init(cc->kv_cache, cm->plan.primary, n_ctx, T_enc, hp.dec_d_model, hp.dec_n_layers, cache_type)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "moonshine_streaming: KV cache allocation failed — "
-                "out of memory.");
+                                "moonshine_streaming: KV cache allocation failed — "
+                                "out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
     } else {
@@ -772,74 +753,68 @@ transcribe_status ensure_kv_cache_for_T(
 // small commit graph. ggml_cpy inside the graph handles any F32→F16
 // conversion the cache's storage dtype requires. Accumulates into
 // cc->t_decode_us.
-transcribe_status commit_cross_kv_from_host(
-    MoonshineStreamingSession *               cc,
-    MoonshineStreamingModel *                 cm,
-    int                                       T_enc,
-    const std::vector<std::vector<float>> &   per_layer_k,
-    const std::vector<std::vector<float>> &   per_layer_v)
-{
-    if (cc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
-    if (T_enc <= 0) return TRANSCRIBE_ERR_INVALID_ARG;
+transcribe_status commit_cross_kv_from_host(MoonshineStreamingSession *             cc,
+                                            MoonshineStreamingModel *               cm,
+                                            int                                     T_enc,
+                                            const std::vector<std::vector<float>> & per_layer_k,
+                                            const std::vector<std::vector<float>> & per_layer_v) {
+    if (cc->poll_abort()) {
+        return TRANSCRIBE_ERR_ABORTED;
+    }
+    if (T_enc <= 0) {
+        return TRANSCRIBE_ERR_INVALID_ARG;
+    }
 
-    const auto & hp = cm->hparams;
-    const int dec_h    = hp.dec_d_model;
-    const int n_layers = hp.dec_n_layers;
-    const size_t expected_floats =
-        static_cast<size_t>(dec_h) * static_cast<size_t>(T_enc);
+    const auto & hp              = cm->hparams;
+    const int    dec_h           = hp.dec_d_model;
+    const int    n_layers        = hp.dec_n_layers;
+    const size_t expected_floats = static_cast<size_t>(dec_h) * static_cast<size_t>(T_enc);
 
-    if (static_cast<int>(per_layer_k.size()) != n_layers ||
-        static_cast<int>(per_layer_v.size()) != n_layers)
-    {
+    if (static_cast<int>(per_layer_k.size()) != n_layers || static_cast<int>(per_layer_v.size()) != n_layers) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
     for (int il = 0; il < n_layers; ++il) {
-        if (per_layer_k[il].size() != expected_floats ||
-            per_layer_v[il].size() != expected_floats)
-        {
+        if (per_layer_k[il].size() != expected_floats || per_layer_v[il].size() != expected_floats) {
             log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "moonshine_streaming cross_kv_commit: layer %d size "
-                         "mismatch (K=%zu V=%zu, expected %zu)",
-                         il, per_layer_k[il].size(), per_layer_v[il].size(),
-                         expected_floats);
+                    "moonshine_streaming cross_kv_commit: layer %d size "
+                    "mismatch (K=%zu V=%zu, expected %zu)",
+                    il, per_layer_k[il].size(), per_layer_v[il].size(), expected_floats);
             return TRANSCRIBE_ERR_INVALID_ARG;
         }
     }
 
     const int64_t t_start = ggml_time_us();
 
-    if (auto st = ensure_sched(cc, cm); st != TRANSCRIBE_OK) return st;
+    if (auto st = ensure_sched(cc, cm); st != TRANSCRIBE_OK) {
+        return st;
+    }
     if (!ensure_compute_ctx(cc, 8 * 1024 * 1024)) {
         transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "moonshine_streaming cross_kv_commit: compute context allocation "
-            "failed — out of memory.");
+                            "moonshine_streaming cross_kv_commit: compute context allocation "
+                            "failed — out of memory.");
         return TRANSCRIBE_ERR_OOM;
     }
 
-    CrossKVCommitBuild cb = build_cross_kv_commit_graph(
-        cc->compute_ctx, hp, cc->kv_cache, T_enc);
-    if (cb.graph == nullptr) return TRANSCRIBE_ERR_GGUF;
+    CrossKVCommitBuild cb = build_cross_kv_commit_graph(cc->compute_ctx, hp, cc->kv_cache, T_enc);
+    if (cb.graph == nullptr) {
+        return TRANSCRIBE_ERR_GGUF;
+    }
 
     ggml_backend_sched_reset(cc->sched);
     if (!ggml_backend_sched_alloc_graph(cc->sched, cb.graph)) {
         transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "moonshine_streaming cross_kv_commit: graph allocation failed — "
-            "out of memory.");
+                            "moonshine_streaming cross_kv_commit: graph allocation failed — "
+                            "out of memory.");
         return TRANSCRIBE_ERR_OOM;
     }
 
     for (int il = 0; il < n_layers; ++il) {
-        ggml_backend_tensor_set(cb.per_layer_k_in[il], per_layer_k[il].data(),
-                                0, expected_floats * sizeof(float));
-        ggml_backend_tensor_set(cb.per_layer_v_in[il], per_layer_v[il].data(),
-                                0, expected_floats * sizeof(float));
+        ggml_backend_tensor_set(cb.per_layer_k_in[il], per_layer_k[il].data(), 0, expected_floats * sizeof(float));
+        ggml_backend_tensor_set(cb.per_layer_v_in[il], per_layer_v[il].data(), 0, expected_floats * sizeof(float));
     }
 
-    if (ggml_backend_sched_graph_compute(cc->sched, cb.graph)
-        != GGML_STATUS_SUCCESS)
-    {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine_streaming cross_kv_commit: compute failed");
+    if (ggml_backend_sched_graph_compute(cc->sched, cb.graph) != GGML_STATUS_SUCCESS) {
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine_streaming cross_kv_commit: compute failed");
         return TRANSCRIBE_ERR_GGUF;
     }
     cc->kv_cache.cross_populated = true;
@@ -852,32 +827,39 @@ transcribe_status commit_cross_kv_from_host(
 // kv_cache are already populated (cross_populated == true). Mutates
 // the context result vectors and accumulates wall-clock time into
 // cc->t_decode_us.
-transcribe_status decode_from_kv_cache(
-    MoonshineStreamingSession * cc,
-    MoonshineStreamingModel *   cm,
-    int                         T_enc,
-    const transcribe_run_params *   params,
-    bool                        emit_dumps)
-{
-    (void)params;
+transcribe_status decode_from_kv_cache(MoonshineStreamingSession *   cc,
+                                       MoonshineStreamingModel *     cm,
+                                       int                           T_enc,
+                                       const transcribe_run_params * params,
+                                       bool                          emit_dumps) {
+    (void) params;
 
-    if (cc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
-    if (T_enc <= 0) return TRANSCRIBE_ERR_INVALID_ARG;
-    if (!cc->kv_cache.cross_populated) return TRANSCRIBE_ERR_INVALID_ARG;
+    if (cc->poll_abort()) {
+        return TRANSCRIBE_ERR_ABORTED;
+    }
+    if (T_enc <= 0) {
+        return TRANSCRIBE_ERR_INVALID_ARG;
+    }
+    if (!cc->kv_cache.cross_populated) {
+        return TRANSCRIBE_ERR_INVALID_ARG;
+    }
 
-    if (auto st = ensure_sched(cc, cm); st != TRANSCRIBE_OK) return st;
+    if (auto st = ensure_sched(cc, cm); st != TRANSCRIBE_OK) {
+        return st;
+    }
 
-    const auto & hp = cm->hparams;
+    const auto &  hp             = cm->hparams;
     const int64_t t_decode_start = ggml_time_us();
 
-    auto try_dump = [emit_dumps](const char * name, ggml_tensor * t,
-                                 const char * stage) {
-        if (!emit_dumps || t == nullptr) return;
+    auto try_dump = [emit_dumps](const char * name, ggml_tensor * t, const char * stage) {
+        if (!emit_dumps || t == nullptr) {
+            return;
+        }
         transcribe::debug::dump_tensor(name, t, stage);
     };
 
-    const int decoder_start = hp.decoder_start_token_id;   // 1
-    const int eos           = hp.eos_token_id;             // 2
+    const int decoder_start = hp.decoder_start_token_id;  // 1
+    const int eos           = hp.eos_token_id;            // 2
     const int max_pos       = hp.dec_max_position_embeddings;
 
     // Effective stop bound for the greedy loop: the duration-based generation
@@ -886,54 +868,46 @@ transcribe_status decode_from_kv_cache(
     // few dozen tokens; the position cap remains the absolute backstop. A
     // budget of 0 (unknown frame geometry) falls back to the position cap.
     const int dur_budget = decode_generation_budget(hp, T_enc);
-    const int gen_cap    = (dur_budget > 0 && (max_pos <= 0 || dur_budget < max_pos))
-                         ? dur_budget : max_pos;
+    const int gen_cap    = (dur_budget > 0 && (max_pos <= 0 || dur_budget < max_pos)) ? dur_budget : max_pos;
 
     std::vector<int32_t> generated_ids;
-    int next_token = -1;
-    int n_past     = 0;
+    int                  next_token = -1;
+    int                  n_past     = 0;
 
-    auto run_step = [&](int n_tokens, int n_past_in,
-                        int token_id_first, bool dump_prompt,
-                        const char * mid_gen_dump_name)
-                       -> transcribe_status {
+    auto run_step = [&](int n_tokens, int n_past_in, int token_id_first, bool dump_prompt,
+                        const char * mid_gen_dump_name) -> transcribe_status {
         if (!ensure_compute_ctx(cc, 4 * 1024 * 1024)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "moonshine_streaming decode: compute context allocation failed "
-                "(step) — out of memory.");
+                                "moonshine_streaming decode: compute context allocation failed "
+                                "(step) — out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
-        const bool skip_log_softmax = !dump_prompt;
-        DecoderBuild db = build_decoder_graph_kv(
-            cc->compute_ctx, cm->weights, hp, cc->kv_cache,
-            n_tokens, n_past_in, T_enc,
-            skip_log_softmax, cc->decoder_use_flash);
+        const bool   skip_log_softmax = !dump_prompt;
+        DecoderBuild db = build_decoder_graph_kv(cc->compute_ctx, cm->weights, hp, cc->kv_cache, n_tokens, n_past_in,
+                                                 T_enc, skip_log_softmax, cc->decoder_use_flash);
         if (db.out == nullptr || db.graph == nullptr) {
             return TRANSCRIBE_ERR_GGUF;
         }
         ggml_backend_sched_reset(cc->sched);
         if (!ggml_backend_sched_alloc_graph(cc->sched, db.graph)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "moonshine_streaming decode: step graph allocation failed — "
-                "out of memory.");
+                                "moonshine_streaming decode: step graph allocation failed — "
+                                "out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
         std::vector<int32_t> token_ids(static_cast<size_t>(n_tokens));
-        std::vector<int32_t> pos_ids  (static_cast<size_t>(n_tokens));
+        std::vector<int32_t> pos_ids(static_cast<size_t>(n_tokens));
         for (int i = 0; i < n_tokens; ++i) {
             token_ids[i] = (i == 0) ? token_id_first : 0;
-            pos_ids  [i] = n_past_in + i;
+            pos_ids[i]   = n_past_in + i;
         }
-        ggml_backend_tensor_set(db.token_ids_in, token_ids.data(),
-                                0, token_ids.size() * sizeof(int32_t));
-        ggml_backend_tensor_set(db.pos_ids_in, pos_ids.data(),
-                                0, pos_ids.size() * sizeof(int32_t));
+        ggml_backend_tensor_set(db.token_ids_in, token_ids.data(), 0, token_ids.size() * sizeof(int32_t));
+        ggml_backend_tensor_set(db.pos_ids_in, pos_ids.data(), 0, pos_ids.size() * sizeof(int32_t));
         if (n_tokens > 1) {
             ggml_tensor * m = find_tensor_by_name(cc->compute_ctx, "dec.causal_mask");
             if (m != nullptr) {
-                const int n_kv = n_past_in + n_tokens;
-                std::vector<float> mask(static_cast<size_t>(n_kv) * n_tokens,
-                                        -1e9f);
+                const int          n_kv = n_past_in + n_tokens;
+                std::vector<float> mask(static_cast<size_t>(n_kv) * n_tokens, -1e9f);
                 for (int q = 0; q < n_tokens; ++q) {
                     for (int k = 0; k < n_kv; ++k) {
                         if (k <= q + n_past_in) {
@@ -941,55 +915,52 @@ transcribe_status decode_from_kv_cache(
                         }
                     }
                 }
-                ggml_backend_tensor_set(m, mask.data(), 0,
-                                        mask.size() * sizeof(float));
+                ggml_backend_tensor_set(m, mask.data(), 0, mask.size() * sizeof(float));
             }
         }
 
-        if (ggml_backend_sched_graph_compute(cc->sched, db.graph)
-            != GGML_STATUS_SUCCESS)
-        {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "moonshine_streaming decode: decoder compute failed (n_past=%d)",
-                         n_past_in);
+        if (ggml_backend_sched_graph_compute(cc->sched, db.graph) != GGML_STATUS_SUCCESS) {
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine_streaming decode: decoder compute failed (n_past=%d)",
+                    n_past_in);
             return TRANSCRIBE_ERR_GGUF;
         }
 
         if (dump_prompt) {
-            try_dump("dec.token_emb",       db.dumps.token_emb,       "decoder.embedding");
-            try_dump("dec.embed_sum",       db.dumps.embed_sum,       "decoder.embed_sum");
+            try_dump("dec.token_emb", db.dumps.token_emb, "decoder.embedding");
+            try_dump("dec.embed_sum", db.dumps.embed_sum, "decoder.embed_sum");
             for (size_t i = 0; i < db.dumps.block_outs.size(); ++i) {
-                if (!dump_block_index(static_cast<int>(i), hp.dec_n_layers)) continue;
+                if (!dump_block_index(static_cast<int>(i), hp.dec_n_layers)) {
+                    continue;
+                }
                 char bname[64], stage[64];
                 std::snprintf(bname, sizeof(bname), "dec.block.%zu.out", i);
                 std::snprintf(stage, sizeof(stage), "decoder.block%zu.out", i);
                 try_dump(bname, db.dumps.block_outs[i], stage);
             }
             try_dump("dec.out_before_head", db.dumps.out_before_head, "decoder.output_before_head");
-            try_dump("dec.logits_raw",      db.dumps.logits_raw,      "decoder.logits_raw");
-            try_dump("dec.logits",          db.dumps.logits,          "decoder.logits");
+            try_dump("dec.logits_raw", db.dumps.logits_raw, "decoder.logits_raw");
+            try_dump("dec.logits", db.dumps.logits, "decoder.logits");
         } else if (mid_gen_dump_name != nullptr) {
             try_dump(mid_gen_dump_name, db.out, "decoder.logits_raw.gen");
         }
 
         if (db.argmax_out != nullptr) {
             int32_t argmax_id = 0;
-            ggml_backend_tensor_get(db.argmax_out, &argmax_id,
-                                    0, sizeof(int32_t));
+            ggml_backend_tensor_get(db.argmax_out, &argmax_id, 0, sizeof(int32_t));
             next_token = argmax_id;
         } else {
-            const int64_t vocab_size = db.out->ne[0];
-            const int64_t last_T     = (ggml_n_dims(db.out) == 1) ? 1 : db.out->ne[1];
-            std::vector<float> logits_host(static_cast<size_t>(vocab_size) *
-                                           static_cast<size_t>(last_T));
-            ggml_backend_tensor_get(db.out, logits_host.data(), 0,
-                                    logits_host.size() * sizeof(float));
-            const float * last_logits = logits_host.data() +
-                                        static_cast<size_t>(last_T - 1) * vocab_size;
-            int best_idx = 0;
-            float best_v = last_logits[0];
+            const int64_t      vocab_size = db.out->ne[0];
+            const int64_t      last_T     = (ggml_n_dims(db.out) == 1) ? 1 : db.out->ne[1];
+            std::vector<float> logits_host(static_cast<size_t>(vocab_size) * static_cast<size_t>(last_T));
+            ggml_backend_tensor_get(db.out, logits_host.data(), 0, logits_host.size() * sizeof(float));
+            const float * last_logits = logits_host.data() + static_cast<size_t>(last_T - 1) * vocab_size;
+            int           best_idx    = 0;
+            float         best_v      = last_logits[0];
             for (int j = 1; j < static_cast<int>(vocab_size); ++j) {
-                if (last_logits[j] > best_v) { best_v = last_logits[j]; best_idx = j; }
+                if (last_logits[j] > best_v) {
+                    best_v   = last_logits[j];
+                    best_idx = j;
+                }
             }
             next_token = best_idx;
         }
@@ -1004,8 +975,7 @@ transcribe_status decode_from_kv_cache(
                            /*token_id_first=*/decoder_start,
                            /*dump_prompt=*/emit_dumps,
                            /*mid_gen_dump_name=*/nullptr);
-        st != TRANSCRIBE_OK)
-    {
+        st != TRANSCRIBE_OK) {
         return st;
     }
     if (next_token != eos) {
@@ -1016,17 +986,18 @@ transcribe_status decode_from_kv_cache(
     // emitted token (n_past == 20 at that step). Matches moonshine.
     constexpr int k_mid_gen_step = 20;
     while (next_token != eos && n_past < gen_cap) {
-        if (cc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
+        if (cc->poll_abort()) {
+            return TRANSCRIBE_ERR_ABORTED;
+        }
 
-        const bool is_mid_gen = (n_past == k_mid_gen_step);
-        const char * dump_name = is_mid_gen ? "dec.logits_raw.gen20" : nullptr;
+        const bool   is_mid_gen = (n_past == k_mid_gen_step);
+        const char * dump_name  = is_mid_gen ? "dec.logits_raw.gen20" : nullptr;
 
         if (auto st = run_step(/*n_tokens=*/1, /*n_past=*/n_past,
                                /*token_id_first=*/next_token,
                                /*dump_prompt=*/false,
                                /*mid_gen_dump_name=*/dump_name);
-            st != TRANSCRIBE_OK)
-        {
+            st != TRANSCRIBE_OK) {
             return st;
         }
         if (next_token != eos) {
@@ -1037,23 +1008,20 @@ transcribe_status decode_from_kv_cache(
     // Non-EOS after the loop means gen_cap stopped decode before EOS. gen_cap
     // is either the position cap or the tighter duration budget.
     if (next_token != eos) {
-        cc->was_truncated = true;
+        cc->was_truncated              = true;
         const bool hit_duration_budget = (gen_cap < max_pos) || (max_pos <= 0);
-        transcribe::log_msg(
-            TRANSCRIBE_LOG_LEVEL_WARN,
-            "moonshine run: output truncated at %d tokens — decode reached the "
-            "%s (%d) before end-of-stream; the transcript may be incomplete. "
-            "See transcribe_capabilities.max_audio_ms.",
-            static_cast<int>(generated_ids.size()),
-            hit_duration_budget ? "generation budget" : "position cap",
-            gen_cap);
+        transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_WARN,
+                            "moonshine run: output truncated at %d tokens — decode reached the "
+                            "%s (%d) before end-of-stream; the transcript may be incomplete. "
+                            "See transcribe_capabilities.max_audio_ms.",
+                            static_cast<int>(generated_ids.size()),
+                            hit_duration_budget ? "generation budget" : "position cap", gen_cap);
     }
 
     cc->t_decode_us += ggml_time_us() - t_decode_start;
 
     if (!generated_ids.empty()) {
-        std::string full = cm->tok.decode(generated_ids.data(),
-                                          static_cast<int>(generated_ids.size()));
+        std::string full = cm->tok.decode(generated_ids.data(), static_cast<int>(generated_ids.size()));
         if (!full.empty() && full.front() == ' ') {
             full.erase(full.begin());
         }
@@ -1068,10 +1036,9 @@ transcribe_status decode_from_kv_cache(
         // text (see include/transcribe.h on keep_special_tags); the
         // committed-prefix accessors would otherwise hand bindings
         // empty strings.
-        cc->tokens.reserve(cc->tokens.size() +
-                           static_cast<size_t>(n_generated));
+        cc->tokens.reserve(cc->tokens.size() + static_cast<size_t>(n_generated));
         for (int i = 0; i < n_generated; ++i) {
-            const int32_t id = generated_ids[static_cast<size_t>(i)];
+            const int32_t                  id = generated_ids[static_cast<size_t>(i)];
             transcribe_session::TokenEntry tok;
             tok.id         = id;
             tok.p          = 0.0f;
@@ -1106,25 +1073,22 @@ transcribe_status decode_from_kv_cache(
 // the one-shot path; streaming finalize uses its own incremental
 // adapter + commit path so the cross-KV K/V projections never need
 // to round-trip through host adapter at finalize.
-transcribe_status decode_from_committed_enc(
-    MoonshineStreamingSession * cc,
-    MoonshineStreamingModel *   cm,
-    const float *               enc_host_data,
-    int                         T_enc,
-    const transcribe_run_params *   params,
-    bool                        emit_dumps)
-{
-    if (T_enc <= 0) return TRANSCRIBE_ERR_INVALID_ARG;
+transcribe_status decode_from_committed_enc(MoonshineStreamingSession *   cc,
+                                            MoonshineStreamingModel *     cm,
+                                            const float *                 enc_host_data,
+                                            int                           T_enc,
+                                            const transcribe_run_params * params,
+                                            bool                          emit_dumps) {
+    if (T_enc <= 0) {
+        return TRANSCRIBE_ERR_INVALID_ARG;
+    }
 
     const auto & hp = cm->hparams;
 
     // 1. Adapter on the full encoder buffer (single window).
     std::vector<float> adapter_host;
-    if (auto st = apply_adapter_window(
-            cc, cm, enc_host_data, T_enc, /*abs_frame_offset=*/0,
-            emit_dumps, adapter_host);
-        st != TRANSCRIBE_OK)
-    {
+    if (auto st = apply_adapter_window(cc, cm, enc_host_data, T_enc, /*abs_frame_offset=*/0, emit_dumps, adapter_host);
+        st != TRANSCRIBE_OK) {
         return st;
     }
     cc->enc_T = T_enc;
@@ -1138,32 +1102,30 @@ transcribe_status decode_from_committed_enc(
     //    existing builder (project + write into cache in one graph)
     //    to avoid a host round-trip that streaming has to pay.
     {
-        if (cc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
+        if (cc->poll_abort()) {
+            return TRANSCRIBE_ERR_ABORTED;
+        }
         const int64_t t_xkv_start = ggml_time_us();
         if (!ensure_compute_ctx(cc, 4 * 1024 * 1024)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "moonshine_streaming decode: compute context allocation failed "
-                "(cross_kv) — out of memory.");
+                                "moonshine_streaming decode: compute context allocation failed "
+                                "(cross_kv) — out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
-        DecoderBuild cross_db = build_cross_kv_graph(
-            cc->compute_ctx, cm->weights, hp, cc->kv_cache, T_enc);
-        if (cross_db.graph == nullptr) return TRANSCRIBE_ERR_GGUF;
+        DecoderBuild cross_db = build_cross_kv_graph(cc->compute_ctx, cm->weights, hp, cc->kv_cache, T_enc);
+        if (cross_db.graph == nullptr) {
+            return TRANSCRIBE_ERR_GGUF;
+        }
         ggml_backend_sched_reset(cc->sched);
         if (!ggml_backend_sched_alloc_graph(cc->sched, cross_db.graph)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "moonshine_streaming decode: cross_kv graph allocation failed — "
-                "out of memory.");
+                                "moonshine_streaming decode: cross_kv graph allocation failed — "
+                                "out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
-        ggml_backend_tensor_set(cross_db.encoder_out_in,
-                                adapter_host.data(), 0,
-                                adapter_host.size() * sizeof(float));
-        if (ggml_backend_sched_graph_compute(cc->sched, cross_db.graph)
-            != GGML_STATUS_SUCCESS)
-        {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "moonshine_streaming decode: cross_kv compute failed");
+        ggml_backend_tensor_set(cross_db.encoder_out_in, adapter_host.data(), 0, adapter_host.size() * sizeof(float));
+        if (ggml_backend_sched_graph_compute(cc->sched, cross_db.graph) != GGML_STATUS_SUCCESS) {
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine_streaming decode: cross_kv compute failed");
             return TRANSCRIBE_ERR_GGUF;
         }
         cc->kv_cache.cross_populated = true;
@@ -1184,14 +1146,14 @@ transcribe_status decode_from_committed_enc(
 // whereas one-shot's decode_from_committed_enc fuses the cross-KV
 // projection and cache write into a single graph for minimum
 // host↔backend traffic.
-transcribe_status run_one_shot_inner(
-    MoonshineStreamingSession * cc,
-    MoonshineStreamingModel *   cm,
-    const float *               pcm,
-    int                         n_samples,
-    const transcribe_run_params *   params)
-{
-    if (cc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
+transcribe_status run_one_shot_inner(MoonshineStreamingSession *   cc,
+                                     MoonshineStreamingModel *     cm,
+                                     const float *                 pcm,
+                                     int                           n_samples,
+                                     const transcribe_run_params * params) {
+    if (cc->poll_abort()) {
+        return TRANSCRIBE_ERR_ABORTED;
+    }
 
     transcribe::debug::init();
 
@@ -1201,31 +1163,26 @@ transcribe_status run_one_shot_inner(
     cc->t_encode_us = 0;
     cc->t_decode_us = 0;
 
-    std::vector<float> pcm_padded = right_pad_pcm(pcm, n_samples, hp.enc_frame_len);
-    const int n_samples_padded = static_cast<int>(pcm_padded.size());
+    std::vector<float> pcm_padded       = right_pad_pcm(pcm, n_samples, hp.enc_frame_len);
+    const int          n_samples_padded = static_cast<int>(pcm_padded.size());
 
     std::vector<float> enc_host;
-    int T_enc = 0;
-    if (auto st = encode_window_to_host(
-            cc, cm, pcm_padded.data(), n_samples_padded,
-            /*emit_dumps=*/true, enc_host, T_enc);
-        st != TRANSCRIBE_OK)
-    {
+    int                T_enc = 0;
+    if (auto st = encode_window_to_host(cc, cm, pcm_padded.data(), n_samples_padded,
+                                        /*emit_dumps=*/true, enc_host, T_enc);
+        st != TRANSCRIBE_OK) {
         return st;
     }
-    return decode_from_committed_enc(
-        cc, cm, enc_host.data(), T_enc, params,
-        /*emit_dumps=*/true);
+    return decode_from_committed_enc(cc, cm, enc_host.data(), T_enc, params,
+                                     /*emit_dumps=*/true);
 }
 
 // One-shot entry point. Validates session/cm, clears the previous result
 // snapshot, then forwards to the shared inference helper.
-transcribe_status run(
-    transcribe_session *      session,
-    const float *             pcm,
-    int                       n_samples,
-    const transcribe_run_params * params)
-{
+transcribe_status run(transcribe_session *          session,
+                      const float *                 pcm,
+                      int                           n_samples,
+                      const transcribe_run_params * params) {
     if (session == nullptr || pcm == nullptr || n_samples <= 0) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
@@ -1236,16 +1193,14 @@ transcribe_status run(
     }
 
     cc->clear_result();
-    const transcribe_status st =
-        run_one_shot_inner(cc, cm, pcm, n_samples, params);
+    const transcribe_status st = run_one_shot_inner(cc, cm, pcm, n_samples, params);
     if (st != TRANSCRIBE_OK) {
         return st;
     }
     // Remap truncation to a hard status only at this offline entry:
     // decode_from_kv_cache returns OK (it's shared with the streaming finalize
     // path, which must NOT surface OUTPUT_TRUNCATED). Partial text stays readable.
-    return cc->was_truncated ? TRANSCRIBE_ERR_OUTPUT_TRUNCATED
-                             : TRANSCRIBE_OK;
+    return cc->was_truncated ? TRANSCRIBE_ERR_OUTPUT_TRUNCATED : TRANSCRIBE_OK;
 }
 
 // Streaming hooks.
@@ -1300,32 +1255,25 @@ void reset_result_text_only(MoonshineStreamingSession * cc) {
 // the commit graph, and run the AR decoder from BOS. Mutates the
 // result text fields on cc; bumps `stream_last_decoded_T` on success
 // so subsequent calls can skip when no new frames have committed.
-transcribe_status decode_partial(
-    MoonshineStreamingSession * cc,
-    MoonshineStreamingModel *   cm,
-    const transcribe_run_params *   params,
-    bool                        emit_dumps)
-{
+transcribe_status decode_partial(MoonshineStreamingSession *   cc,
+                                 MoonshineStreamingModel *     cm,
+                                 const transcribe_run_params * params,
+                                 bool                          emit_dumps) {
     const int T_enc = cc->stream_T_emitted;
-    if (T_enc <= 0) return TRANSCRIBE_ERR_INVALID_ARG;
+    if (T_enc <= 0) {
+        return TRANSCRIBE_ERR_INVALID_ARG;
+    }
 
     reset_result_text_only(cc);
 
     if (auto st = ensure_kv_cache_for_T(cc, cm, T_enc); st != TRANSCRIBE_OK) {
         return st;
     }
-    if (auto st = commit_cross_kv_from_host(
-            cc, cm, T_enc,
-            cc->stream_cross_k_committed,
-            cc->stream_cross_v_committed);
-        st != TRANSCRIBE_OK)
-    {
+    if (auto st = commit_cross_kv_from_host(cc, cm, T_enc, cc->stream_cross_k_committed, cc->stream_cross_v_committed);
+        st != TRANSCRIBE_OK) {
         return st;
     }
-    if (auto st = decode_from_kv_cache(
-            cc, cm, T_enc, params, emit_dumps);
-        st != TRANSCRIBE_OK)
-    {
+    if (auto st = decode_from_kv_cache(cc, cm, T_enc, params, emit_dumps); st != TRANSCRIBE_OK) {
         return st;
     }
     cc->stream_last_decoded_T = T_enc;
@@ -1333,9 +1281,7 @@ transcribe_status decode_partial(
     return TRANSCRIBE_OK;
 }
 
-std::vector<int32_t> token_ids_from_rows(
-    const std::vector<transcribe_session::TokenEntry> & tokens)
-{
+std::vector<int32_t> token_ids_from_rows(const std::vector<transcribe_session::TokenEntry> & tokens) {
     std::vector<int32_t> ids;
     ids.reserve(tokens.size());
     for (const auto & tok : tokens) {
@@ -1344,41 +1290,28 @@ std::vector<int32_t> token_ids_from_rows(
     return ids;
 }
 
-int longest_common_prefix_in_token_ids(
-    const std::vector<int32_t> & a,
-    const std::vector<int32_t> & b)
-{
-    const int bound =
-        std::min(static_cast<int>(a.size()), static_cast<int>(b.size()));
-    int prefix = 0;
-    while (prefix < bound && a[static_cast<size_t>(prefix)] ==
-                                  b[static_cast<size_t>(prefix)]) {
+int longest_common_prefix_in_token_ids(const std::vector<int32_t> & a, const std::vector<int32_t> & b) {
+    const int bound  = std::min(static_cast<int>(a.size()), static_cast<int>(b.size()));
+    int       prefix = 0;
+    while (prefix < bound && a[static_cast<size_t>(prefix)] == b[static_cast<size_t>(prefix)]) {
         ++prefix;
     }
     return prefix;
 }
 
-uint32_t token_stable_prefix_agreement_n(
-    const MoonshineStreamingSession * cc)
-{
+uint32_t token_stable_prefix_agreement_n(const MoonshineStreamingSession * cc) {
     // Library default when the caller leaves stable_prefix_agreement_n at
     // 0; documented as "currently 3" on transcribe_stream_params.
     static constexpr uint32_t k_default_stable_prefix_agreement_n = 3;
-    uint32_t agreement_n = cc != nullptr
-        ? cc->stream_stable_prefix_agreement_n
-        : 0;
-    return agreement_n == 0 ? k_default_stable_prefix_agreement_n
-                            : agreement_n;
+    uint32_t                  agreement_n = cc != nullptr ? cc->stream_stable_prefix_agreement_n : 0;
+    return agreement_n == 0 ? k_default_stable_prefix_agreement_n : agreement_n;
 }
 
 // Compute how many leading token ids agree across the last N partial
 // decodes. The matching prefix is considered "committed" — it
 // reproduced under multiple cross-KV sizes, so it's unlikely to change
 // again. Returns the prefix length in tokens.
-int stable_token_prefix_from_history(
-    MoonshineStreamingSession *        cc,
-    const std::vector<int32_t> &       current_ids)
-{
+int stable_token_prefix_from_history(MoonshineStreamingSession * cc, const std::vector<int32_t> & current_ids) {
     const uint32_t agreement_n = token_stable_prefix_agreement_n(cc);
     if (agreement_n <= 1) {
         return static_cast<int>(current_ids.size());
@@ -1392,11 +1325,10 @@ int stable_token_prefix_from_history(
         return 0;
     }
 
-    const auto & base = cc->stream_token_id_history.front();
-    int prefix = static_cast<int>(base.size());
+    const auto & base   = cc->stream_token_id_history.front();
+    int          prefix = static_cast<int>(base.size());
     for (const auto & ids : cc->stream_token_id_history) {
-        prefix = std::min(
-            prefix, longest_common_prefix_in_token_ids(base, ids));
+        prefix = std::min(prefix, longest_common_prefix_in_token_ids(base, ids));
     }
     return prefix;
 }
@@ -1411,24 +1343,17 @@ constexpr int k_default_min_decode_interval_ms = 240;
 //   ext NULL / -1   -> family default (k_default_min_decode_interval_ms)
 //   < -1            -> TRANSCRIBE_ERR_INVALID_ARG
 //   >= 0            -> the requested value (0 = decode every advance)
-transcribe_status resolve_min_decode_interval_ms(
-    const transcribe_stream_params * stream_params,
-    int32_t *                        out_min_decode_ms)
-{
-    int32_t min_decode_ms = k_default_min_decode_interval_ms;
-    const transcribe_ext * family =
-        stream_params != nullptr ? stream_params->family : nullptr;
-    if (const transcribe_status st = transcribe_ext_check(
-            family,
-            TRANSCRIBE_EXT_KIND_MOONSHINE_STREAMING_STREAM,
-            sizeof(struct transcribe_moonshine_streaming_stream_ext));
-        st != TRANSCRIBE_OK)
-    {
+transcribe_status resolve_min_decode_interval_ms(const transcribe_stream_params * stream_params,
+                                                 int32_t *                        out_min_decode_ms) {
+    int32_t                min_decode_ms = k_default_min_decode_interval_ms;
+    const transcribe_ext * family        = stream_params != nullptr ? stream_params->family : nullptr;
+    if (const transcribe_status st = transcribe_ext_check(family, TRANSCRIBE_EXT_KIND_MOONSHINE_STREAMING_STREAM,
+                                                          sizeof(struct transcribe_moonshine_streaming_stream_ext));
+        st != TRANSCRIBE_OK) {
         return st;
     }
     if (family != nullptr) {
-        const auto * mx =
-            reinterpret_cast<const transcribe_moonshine_streaming_stream_ext *>(family);
+        const auto * mx = reinterpret_cast<const transcribe_moonshine_streaming_stream_ext *>(family);
         if (mx->min_decode_interval_ms < -1) {
             return TRANSCRIBE_ERR_INVALID_ARG;
         }
@@ -1443,11 +1368,9 @@ transcribe_status resolve_min_decode_interval_ms(
 // Pure pre-flight: reject malformed family stream config BEFORE the
 // dispatcher clears the previous result snapshot, so a caller typo does
 // not destroy the prior utterance's transcript. Mutates nothing.
-transcribe_status stream_validate(
-    const transcribe_session *        session,
-    const transcribe_run_params *     /*run_params*/,
-    const transcribe_stream_params *  stream_params)
-{
+transcribe_status stream_validate(const transcribe_session * session,
+                                  const transcribe_run_params * /*run_params*/,
+                                  const transcribe_stream_params * stream_params) {
     const auto * cc = static_cast<const MoonshineStreamingSession *>(session);
     const auto * cm = static_cast<const MoonshineStreamingModel *>(cc->model);
     if (cm == nullptr || cm->plan.scheduler_list.empty()) {
@@ -1457,11 +1380,9 @@ transcribe_status stream_validate(
     return resolve_min_decode_interval_ms(stream_params, &min_decode_ms);
 }
 
-transcribe_status stream_begin(
-    transcribe_session *              session,
-    const transcribe_run_params *         run_params,
-    const transcribe_stream_params *  stream_params)
-{
+transcribe_status stream_begin(transcribe_session *             session,
+                               const transcribe_run_params *    run_params,
+                               const transcribe_stream_params * stream_params) {
     auto * cc = static_cast<MoonshineStreamingSession *>(session);
     auto * cm = static_cast<MoonshineStreamingModel *>(cc->model);
     if (cm == nullptr || cm->plan.scheduler_list.empty()) {
@@ -1475,10 +1396,8 @@ transcribe_status stream_begin(
     // it before any mutation keeps stream_begin's own failure path from
     // half-clearing buffers on an input the preflight somehow missed.
     int32_t min_decode_ms = k_default_min_decode_interval_ms;
-    if (const transcribe_status st = resolve_min_decode_interval_ms(
-            stream_params, &min_decode_ms);
-        st != TRANSCRIBE_OK)
-    {
+    if (const transcribe_status st = resolve_min_decode_interval_ms(stream_params, &min_decode_ms);
+        st != TRANSCRIBE_OK) {
         return st;
     }
 
@@ -1487,29 +1406,24 @@ transcribe_status stream_begin(
     const auto & hp = cm->hparams;
 
     cc->stream_pcm_buffer.clear();
-    cc->stream_pcm_start_sample       = 0;
+    cc->stream_pcm_start_sample = 0;
     cc->stream_adapter_committed.clear();
-    cc->stream_cross_k_committed.assign(static_cast<size_t>(hp.dec_n_layers),
-                                        std::vector<float>{});
-    cc->stream_cross_v_committed.assign(static_cast<size_t>(hp.dec_n_layers),
-                                        std::vector<float>{});
-    cc->stream_T_emitted              = 0;
-    cc->stream_last_decoded_T         = 0;
+    cc->stream_cross_k_committed.assign(static_cast<size_t>(hp.dec_n_layers), std::vector<float>{});
+    cc->stream_cross_v_committed.assign(static_cast<size_t>(hp.dec_n_layers), std::vector<float>{});
+    cc->stream_T_emitted      = 0;
+    cc->stream_last_decoded_T = 0;
     cc->stream_token_id_history.clear();
-    cc->stream_L_total_frames         = cumulative_left_context(hp);
-    cc->stream_R_total_frames         = cumulative_right_context(hp);
-    cc->stream_frontend_pad_frames    = k_frontend_pad_enc_frames;
-    cc->stream_samples_per_enc_frame  = samples_per_encoder_frame(hp);
-    cc->stream_run_params             = *run_params;
+    cc->stream_L_total_frames        = cumulative_left_context(hp);
+    cc->stream_R_total_frames        = cumulative_right_context(hp);
+    cc->stream_frontend_pad_frames   = k_frontend_pad_enc_frames;
+    cc->stream_samples_per_enc_frame = samples_per_encoder_frame(hp);
+    cc->stream_run_params            = *run_params;
 
     // Convert the resolved throttle interval to encoder frames using the
     // model's actual frame rate (samples_per_enc_frame / sample_rate).
-    const int64_t spf = cc->stream_samples_per_enc_frame > 0
-                          ? cc->stream_samples_per_enc_frame : 1;
-    const int64_t min_decode_samples =
-        static_cast<int64_t>(min_decode_ms) * k_sample_rate_hz;
-    cc->stream_min_decode_frames = static_cast<int32_t>(
-        (min_decode_samples + 1000LL * spf - 1) / (1000LL * spf));
+    const int64_t spf                = cc->stream_samples_per_enc_frame > 0 ? cc->stream_samples_per_enc_frame : 1;
+    const int64_t min_decode_samples = static_cast<int64_t>(min_decode_ms) * k_sample_rate_hz;
+    cc->stream_min_decode_frames     = static_cast<int32_t>((min_decode_samples + 1000LL * spf - 1) / (1000LL * spf));
     if (min_decode_ms >= 0 && cc->stream_min_decode_frames < 1) {
         cc->stream_min_decode_frames = 1;
     }
@@ -1535,44 +1449,39 @@ transcribe_status stream_begin(
 // PCM buffer is sliding — `pcm_start_sample` tracks the absolute
 // sample index of buffer[0] so absolute frame indices translate to
 // buffer-relative offsets via the subtraction.
-transcribe_status flush_stable_frames(
-    MoonshineStreamingSession * cc,
-    MoonshineStreamingModel *   cm,
-    int                         win_start,
-    int                         win_end,
-    int                         emit_start,
-    int                         emit_end)
-{
-    if (win_start < 0 || emit_start < win_start ||
-        emit_end > win_end || emit_start >= emit_end)
-    {
+transcribe_status flush_stable_frames(MoonshineStreamingSession * cc,
+                                      MoonshineStreamingModel *   cm,
+                                      int                         win_start,
+                                      int                         win_end,
+                                      int                         emit_start,
+                                      int                         emit_end) {
+    if (win_start < 0 || emit_start < win_start || emit_end > win_end || emit_start >= emit_end) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
 
-    const auto & hp = cm->hparams;
-    const int spf   = cc->stream_samples_per_enc_frame;
-    const int enc_h = hp.enc_d_model;
-    const int dec_h = hp.dec_d_model;
+    const auto & hp    = cm->hparams;
+    const int    spf   = cc->stream_samples_per_enc_frame;
+    const int    enc_h = hp.enc_d_model;
+    const int    dec_h = hp.dec_d_model;
 
     // Extend the slice leftward by frontend_pad encoder frames so the
     // conv stack's left-pad is filled with real PCM (or with implicit
     // zero-pad at stream origin, which matches one-shot).
-    const int pad_left_frames = std::min(cc->stream_frontend_pad_frames, win_start);
+    const int pad_left_frames   = std::min(cc->stream_frontend_pad_frames, win_start);
     const int slice_start_frame = win_start - pad_left_frames;
     const int slice_end_frame   = win_end;
 
     const int64_t abs_pcm_start = static_cast<int64_t>(slice_start_frame) * spf;
-    const int64_t abs_pcm_end   = static_cast<int64_t>(slice_end_frame)   * spf;
+    const int64_t abs_pcm_end   = static_cast<int64_t>(slice_end_frame) * spf;
     if (abs_pcm_start < cc->stream_pcm_start_sample) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine_streaming flush: slice underruns trimmed "
-                     "PCM (slice_start_abs=%lld, pcm_start=%lld)",
-                     static_cast<long long>(abs_pcm_start),
-                     static_cast<long long>(cc->stream_pcm_start_sample));
+                "moonshine_streaming flush: slice underruns trimmed "
+                "PCM (slice_start_abs=%lld, pcm_start=%lld)",
+                static_cast<long long>(abs_pcm_start), static_cast<long long>(cc->stream_pcm_start_sample));
         return TRANSCRIBE_ERR_GGUF;
     }
     const int64_t buf_pcm_start = abs_pcm_start - cc->stream_pcm_start_sample;
-    const int64_t buf_pcm_end   = abs_pcm_end   - cc->stream_pcm_start_sample;
+    const int64_t buf_pcm_end   = abs_pcm_end - cc->stream_pcm_start_sample;
     if (buf_pcm_end > static_cast<int64_t>(cc->stream_pcm_buffer.size())) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
@@ -1582,61 +1491,47 @@ transcribe_status flush_stable_frames(
     }
 
     std::vector<float> enc_host;
-    int slice_T_enc = 0;
-    if (auto st = encode_window_to_host(
-            cc, cm,
-            cc->stream_pcm_buffer.data() + buf_pcm_start,
-            n_samples,
-            /*emit_dumps=*/false,
-            enc_host, slice_T_enc);
-        st != TRANSCRIBE_OK)
-    {
+    int                slice_T_enc = 0;
+    if (auto st = encode_window_to_host(cc, cm, cc->stream_pcm_buffer.data() + buf_pcm_start, n_samples,
+                                        /*emit_dumps=*/false, enc_host, slice_T_enc);
+        st != TRANSCRIBE_OK) {
         return st;
     }
     const int expected_T = slice_end_frame - slice_start_frame;
     if (slice_T_enc != expected_T) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine_streaming flush: slice T_enc mismatch "
-                     "(got %d, expected %d)", slice_T_enc, expected_T);
+                "moonshine_streaming flush: slice T_enc mismatch "
+                "(got %d, expected %d)",
+                slice_T_enc, expected_T);
         return TRANSCRIBE_ERR_GGUF;
     }
 
     // Extract emit-slice rows from the encoder output, then run the
     // adapter on the slice and project K/V.
     const int rel_emit_start = emit_start - slice_start_frame;
-    const int rel_emit_end   = emit_end   - slice_start_frame;
+    const int rel_emit_end   = emit_end - slice_start_frame;
     const int n_emit         = rel_emit_end - rel_emit_start;
 
-    const size_t emit_floats =
-        static_cast<size_t>(enc_h) * static_cast<size_t>(n_emit);
-    const size_t emit_off =
-        static_cast<size_t>(enc_h) * static_cast<size_t>(rel_emit_start);
+    const size_t       emit_floats = static_cast<size_t>(enc_h) * static_cast<size_t>(n_emit);
+    const size_t       emit_off    = static_cast<size_t>(enc_h) * static_cast<size_t>(rel_emit_start);
     std::vector<float> enc_emit_slice(emit_floats);
-    std::memcpy(enc_emit_slice.data(), enc_host.data() + emit_off,
-                emit_floats * sizeof(float));
+    std::memcpy(enc_emit_slice.data(), enc_host.data() + emit_off, emit_floats * sizeof(float));
 
     std::vector<float> adapter_slice;
-    if (auto st = apply_adapter_window(
-            cc, cm, enc_emit_slice.data(), n_emit,
-            /*abs_frame_offset=*/emit_start,
-            /*emit_dumps=*/false, adapter_slice);
-        st != TRANSCRIBE_OK)
-    {
+    if (auto st = apply_adapter_window(cc, cm, enc_emit_slice.data(), n_emit,
+                                       /*abs_frame_offset=*/emit_start,
+                                       /*emit_dumps=*/false, adapter_slice);
+        st != TRANSCRIBE_OK) {
         return st;
     }
     if (static_cast<int>(adapter_slice.size()) != dec_h * n_emit) {
         return TRANSCRIBE_ERR_GGUF;
     }
-    cc->stream_adapter_committed.insert(
-        cc->stream_adapter_committed.end(),
-        adapter_slice.begin(), adapter_slice.end());
+    cc->stream_adapter_committed.insert(cc->stream_adapter_committed.end(), adapter_slice.begin(), adapter_slice.end());
 
-    if (auto st = project_cross_kv_window(
-            cc, cm, adapter_slice.data(), n_emit,
-            cc->stream_cross_k_committed,
-            cc->stream_cross_v_committed);
-        st != TRANSCRIBE_OK)
-    {
+    if (auto st = project_cross_kv_window(cc, cm, adapter_slice.data(), n_emit, cc->stream_cross_k_committed,
+                                          cc->stream_cross_v_committed);
+        st != TRANSCRIBE_OK) {
         return st;
     }
 
@@ -1651,71 +1546,59 @@ transcribe_status flush_stable_frames(
 // pcm_start_sample stays frame-aligned and absolute↔buffer-relative
 // translation is integer.
 void trim_pcm_buffer(MoonshineStreamingSession * cc) {
-    const int spf = cc->stream_samples_per_enc_frame;
-    const int64_t keep_from_frame = std::max<int64_t>(
-        0,
-        static_cast<int64_t>(cc->stream_T_emitted) -
-            static_cast<int64_t>(cc->stream_L_total_frames) -
-            static_cast<int64_t>(cc->stream_frontend_pad_frames));
+    const int     spf              = cc->stream_samples_per_enc_frame;
+    const int64_t keep_from_frame  = std::max<int64_t>(0, static_cast<int64_t>(cc->stream_T_emitted) -
+                                                              static_cast<int64_t>(cc->stream_L_total_frames) -
+                                                              static_cast<int64_t>(cc->stream_frontend_pad_frames));
     const int64_t keep_from_sample = keep_from_frame * spf;
-    if (keep_from_sample <= cc->stream_pcm_start_sample) return;
+    if (keep_from_sample <= cc->stream_pcm_start_sample) {
+        return;
+    }
 
     const int64_t drop = keep_from_sample - cc->stream_pcm_start_sample;
-    if (drop <= 0 ||
-        drop >= static_cast<int64_t>(cc->stream_pcm_buffer.size()))
-    {
+    if (drop <= 0 || drop >= static_cast<int64_t>(cc->stream_pcm_buffer.size())) {
         return;
     }
-    cc->stream_pcm_buffer.erase(
-        cc->stream_pcm_buffer.begin(),
-        cc->stream_pcm_buffer.begin() + drop);
+    cc->stream_pcm_buffer.erase(cc->stream_pcm_buffer.begin(), cc->stream_pcm_buffer.begin() + drop);
     cc->stream_pcm_start_sample = keep_from_sample;
 }
 
-transcribe_status stream_feed(
-    transcribe_session *        session,
-    const float *               pcm,
-    int                         n_samples,
-    transcribe_stream_update *  update)
-{
+transcribe_status stream_feed(transcribe_session *       session,
+                              const float *              pcm,
+                              int                        n_samples,
+                              transcribe_stream_update * update) {
     auto * cc = static_cast<MoonshineStreamingSession *>(session);
     auto * cm = static_cast<MoonshineStreamingModel *>(cc->model);
     if (cm == nullptr || cm->plan.scheduler_list.empty()) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
-    if (cc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
+    if (cc->poll_abort()) {
+        return TRANSCRIBE_ERR_ABORTED;
+    }
 
-    cc->stream_pcm_buffer.insert(
-        cc->stream_pcm_buffer.end(), pcm, pcm + n_samples);
+    cc->stream_pcm_buffer.insert(cc->stream_pcm_buffer.end(), pcm, pcm + n_samples);
     cc->stream_audio_input_us += samples_to_us(n_samples);
 
-    const int spf  = cc->stream_samples_per_enc_frame;
+    const int     spf              = cc->stream_samples_per_enc_frame;
     // total_pcm and available_frames are computed in ABSOLUTE frames
     // (the buffer holds samples [pcm_start_sample, ...)).
-    const int64_t total_pcm_abs =
-        cc->stream_pcm_start_sample +
-        static_cast<int64_t>(cc->stream_pcm_buffer.size());
-    const int available_frames = static_cast<int>(total_pcm_abs / spf);
-    const int R = cc->stream_R_total_frames;
-    const int L = cc->stream_L_total_frames;
-
-    const int stable_frames = available_frames - R;
-    bool result_changed = false;
+    const int64_t total_pcm_abs    = cc->stream_pcm_start_sample + static_cast<int64_t>(cc->stream_pcm_buffer.size());
+    const int     available_frames = static_cast<int>(total_pcm_abs / spf);
+    const int     R                = cc->stream_R_total_frames;
+    const int     L                = cc->stream_L_total_frames;
+
+    const int stable_frames  = available_frames - R;
+    bool      result_changed = false;
     if (stable_frames > cc->stream_T_emitted) {
         const int emit_start = cc->stream_T_emitted;
         const int emit_end   = stable_frames;
         const int win_start  = std::max(0, emit_start - L);
         const int win_end    = emit_end + R;
-        if (auto st = flush_stable_frames(cc, cm, win_start, win_end,
-                                          emit_start, emit_end);
-            st != TRANSCRIBE_OK)
-        {
+        if (auto st = flush_stable_frames(cc, cm, win_start, win_end, emit_start, emit_end); st != TRANSCRIBE_OK) {
             return st;
         }
         cc->stream_audio_committed_us =
-            static_cast<int64_t>(cc->stream_T_emitted) *
-            static_cast<int64_t>(spf) * 1000000LL /
-            k_sample_rate_hz;
+            static_cast<int64_t>(cc->stream_T_emitted) * static_cast<int64_t>(spf) * 1000000LL / k_sample_rate_hz;
 
         trim_pcm_buffer(cc);
 
@@ -1730,23 +1613,17 @@ transcribe_status stream_feed(
         // the host adapter + cross-KV buffers; they get picked up by
         // the next feed that crosses the throttle, or by the
         // stream_finalize decode regardless.
-        const int frames_since_last_decode =
-            cc->stream_T_emitted - cc->stream_last_decoded_T;
-        const bool throttle_allows_decode =
-            frames_since_last_decode >= cc->stream_min_decode_frames;
-        if (cc->stream_T_emitted > cc->stream_last_decoded_T &&
-            throttle_allows_decode)
-        {
+        const int  frames_since_last_decode = cc->stream_T_emitted - cc->stream_last_decoded_T;
+        const bool throttle_allows_decode   = frames_since_last_decode >= cc->stream_min_decode_frames;
+        if (cc->stream_T_emitted > cc->stream_last_decoded_T && throttle_allows_decode) {
             // Snapshot prior text so we can detect "decode produced
             // the same transcript again" and avoid bumping revision
             // unnecessarily. Cheap — full_text is short.
             const std::string prev_full_text = cc->full_text;
 
-            if (auto st = decode_partial(
-                    cc, cm, &cc->stream_run_params,
-                    /*emit_dumps=*/false);
-                st != TRANSCRIBE_OK)
-            {
+            if (auto st = decode_partial(cc, cm, &cc->stream_run_params,
+                                         /*emit_dumps=*/false);
+                st != TRANSCRIBE_OK) {
                 return st;
             }
 
@@ -1754,10 +1631,8 @@ transcribe_status stream_feed(
             // the configured agreement window are stable enough to mark
             // as committed. Tokens past the divergence point remain
             // tentative.
-            const std::vector<int32_t> current_ids =
-                token_ids_from_rows(cc->tokens);
-            const int commit_prefix =
-                stable_token_prefix_from_history(cc, current_ids);
+            const std::vector<int32_t> current_ids   = token_ids_from_rows(cc->tokens);
+            const int                  commit_prefix = stable_token_prefix_from_history(cc, current_ids);
             if (commit_prefix > cc->n_committed_tokens) {
                 cc->n_committed_tokens = commit_prefix;
             }
@@ -1774,16 +1649,12 @@ transcribe_status stream_feed(
         update->revision           = cc->stream_revision;
         update->input_received_ms  = us_to_ms(cc->stream_audio_input_us);
         update->audio_committed_ms = us_to_ms(cc->stream_audio_committed_us);
-        update->buffered_ms        =
-            us_to_ms(cc->stream_audio_input_us - cc->stream_audio_committed_us);
+        update->buffered_ms        = us_to_ms(cc->stream_audio_input_us - cc->stream_audio_committed_us);
     }
     return TRANSCRIBE_OK;
 }
 
-transcribe_status stream_finalize(
-    transcribe_session *        session,
-    transcribe_stream_update *  update)
-{
+transcribe_status stream_finalize(transcribe_session * session, transcribe_stream_update * update) {
     auto * cc = static_cast<MoonshineStreamingSession *>(session);
     auto * cm = static_cast<MoonshineStreamingModel *>(cc->model);
     if (cm == nullptr || cm->plan.scheduler_list.empty()) {
@@ -1820,22 +1691,20 @@ transcribe_status stream_finalize(
         }
     }
 
-    const int spf = cc->stream_samples_per_enc_frame;
-    const int64_t total_pcm_abs =
-        cc->stream_pcm_start_sample +
-        static_cast<int64_t>(cc->stream_pcm_buffer.size());
-    const int T_total = static_cast<int>(total_pcm_abs / spf);
+    const int     spf           = cc->stream_samples_per_enc_frame;
+    const int64_t total_pcm_abs = cc->stream_pcm_start_sample + static_cast<int64_t>(cc->stream_pcm_buffer.size());
+    const int     T_total       = static_cast<int>(total_pcm_abs / spf);
 
     auto write_update = [&](transcribe_status st) {
-        if (update == nullptr) return;
+        if (update == nullptr) {
+            return;
+        }
         update->result_changed     = cc->has_result;
         update->revision           = cc->stream_revision;
         update->input_received_ms  = us_to_ms(cc->stream_audio_input_us);
         update->audio_committed_ms = us_to_ms(cc->stream_audio_committed_us);
-        update->buffered_ms        = (st == TRANSCRIBE_OK)
-            ? 0
-            : us_to_ms(cc->stream_audio_input_us -
-                       cc->stream_audio_committed_us);
+        update->buffered_ms =
+            (st == TRANSCRIBE_OK) ? 0 : us_to_ms(cc->stream_audio_input_us - cc->stream_audio_committed_us);
     };
 
     if (T_total > cc->stream_T_emitted) {
@@ -1843,10 +1712,7 @@ transcribe_status stream_finalize(
         const int emit_end   = T_total;
         const int win_start  = std::max(0, emit_start - cc->stream_L_total_frames);
         const int win_end    = emit_end;
-        if (auto st = flush_stable_frames(cc, cm, win_start, win_end,
-                                          emit_start, emit_end);
-            st != TRANSCRIBE_OK)
-        {
+        if (auto st = flush_stable_frames(cc, cm, win_start, win_end, emit_start, emit_end); st != TRANSCRIBE_OK) {
             write_update(st);
             return st;
         }
@@ -1873,11 +1739,9 @@ transcribe_status stream_finalize(
     // and we just commit it as-is.
     const std::string prev_full_text = cc->full_text;
     if (T_enc > cc->stream_last_decoded_T || !cc->has_result) {
-        if (auto st = decode_partial(
-                cc, cm, &cc->stream_run_params,
-                /*emit_dumps=*/true);
-            st != TRANSCRIBE_OK)
-        {
+        if (auto st = decode_partial(cc, cm, &cc->stream_run_params,
+                                     /*emit_dumps=*/true);
+            st != TRANSCRIBE_OK) {
             write_update(st);
             return st;
         }
@@ -1916,101 +1780,115 @@ void stream_reset(transcribe_session * session) {
     cc->stream_pcm_buffer.clear();
     cc->stream_pcm_start_sample = 0;
     cc->stream_adapter_committed.clear();
-    for (auto & v : cc->stream_cross_k_committed) v.clear();
-    for (auto & v : cc->stream_cross_v_committed) v.clear();
+    for (auto & v : cc->stream_cross_k_committed) {
+        v.clear();
+    }
+    for (auto & v : cc->stream_cross_v_committed) {
+        v.clear();
+    }
     cc->stream_T_emitted      = 0;
     cc->stream_last_decoded_T = 0;
     cc->stream_token_id_history.clear();
 }
 
-bool accepts_ext_kind(const transcribe_model * model,
-                      transcribe_ext_slot      slot,
-                      uint32_t                 kind) {
+bool accepts_ext_kind(const transcribe_model * model, transcribe_ext_slot slot, uint32_t kind) {
     (void) model;
-    if (slot != TRANSCRIBE_EXT_SLOT_STREAM) return false;
+    if (slot != TRANSCRIBE_EXT_SLOT_STREAM) {
+        return false;
+    }
     return kind == TRANSCRIBE_EXT_KIND_MOONSHINE_STREAMING_STREAM;
 }
 
 // Offline batched decode (transcribe_run_batch). Encoder + adapter serial per
 // utterance (no mel to parallelize); decode (self+cross attn, partial RoPE)
 // batched. Always uses flash (the moonshine flash-for-batch decision).
-transcribe_status run_batch_serial(MoonshineStreamingSession * cc,
-                                   const float * const * pcm,
-                                   const int * n_samples, int n,
+transcribe_status run_batch_serial(MoonshineStreamingSession *   cc,
+                                   const float * const *         pcm,
+                                   const int *                   n_samples,
+                                   int                           n,
                                    const transcribe_run_params * params) {
     for (int i = 0; i < n; ++i) {
-        if (cc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
-        const transcribe_status st =
-            (pcm[i] == nullptr || n_samples[i] <= 0)
-                ? TRANSCRIBE_ERR_INVALID_ARG
-                : run(cc, pcm[i], n_samples[i], params);
+        if (cc->poll_abort()) {
+            return TRANSCRIBE_ERR_ABORTED;
+        }
+        const transcribe_status st = (pcm[i] == nullptr || n_samples[i] <= 0) ? TRANSCRIBE_ERR_INVALID_ARG :
+                                                                                run(cc, pcm[i], n_samples[i], params);
         if (st == TRANSCRIBE_OK) {
             cc->batch_results.push_back(cc->capture_result(st));
         } else {
-            transcribe_session::ResultSet rs; rs.status = st;
+            transcribe_session::ResultSet rs;
+            rs.status = st;
             cc->batch_results.push_back(std::move(rs));
         }
     }
     return TRANSCRIBE_OK;
 }
 
-transcribe_status run_batch(
-    transcribe_session *          session,
-    const float * const *         pcm,
-    const int *                   n_samples,
-    int                           n,
-    const transcribe_run_params * params)
-{
-    if (session == nullptr || pcm == nullptr || n_samples == nullptr || n <= 0)
+transcribe_status run_batch(transcribe_session *          session,
+                            const float * const *         pcm,
+                            const int *                   n_samples,
+                            int                           n,
+                            const transcribe_run_params * params) {
+    if (session == nullptr || pcm == nullptr || n_samples == nullptr || n <= 0) {
         return TRANSCRIBE_ERR_INVALID_ARG;
+    }
     auto * cc = static_cast<MoonshineStreamingSession *>(session);
     auto * cm = static_cast<MoonshineStreamingModel *>(cc->model);
-    if (cm == nullptr || cm->plan.scheduler_list.empty())
+    if (cm == nullptr || cm->plan.scheduler_list.empty()) {
         return TRANSCRIBE_ERR_INVALID_ARG;
+    }
 
-    const bool primary_is_gpu =
-        cm->plan.primary_kind != transcribe::BackendKind::Cpu &&
-        cm->plan.primary_kind != transcribe::BackendKind::Accel &&
-        cm->plan.primary_kind != transcribe::BackendKind::Unknown;
-    if (n == 1 || !primary_is_gpu || transcribe::debug::enabled())
+    const bool primary_is_gpu = cm->plan.primary_kind != transcribe::BackendKind::Cpu &&
+                                cm->plan.primary_kind != transcribe::BackendKind::Accel &&
+                                cm->plan.primary_kind != transcribe::BackendKind::Unknown;
+    if (n == 1 || !primary_is_gpu || transcribe::debug::enabled()) {
         return run_batch_serial(cc, pcm, n_samples, n, params);
+    }
 
     transcribe::debug::init();
-    const auto & hp = cm->hparams;
-    const int d_model = hp.dec_d_model;
-    const int n_layer = hp.dec_n_layers;
-    const int decoder_start = hp.decoder_start_token_id;
-    const int32_t eos = hp.eos_token_id;
-    const int max_pos = hp.dec_max_position_embeddings;
+    const auto &  hp            = cm->hparams;
+    const int     d_model       = hp.dec_d_model;
+    const int     n_layer       = hp.dec_n_layers;
+    const int     decoder_start = hp.decoder_start_token_id;
+    const int32_t eos           = hp.eos_token_id;
+    const int     max_pos       = hp.dec_max_position_embeddings;
 
     // ----- Pass 1: serial per-utterance encoder + adapter -----
-    std::vector<char> valid(n, 0);
+    std::vector<char>               valid(n, 0);
     std::vector<std::vector<float>> adapter_hosts(n);
-    std::vector<int> T_enc(n, 0);
-    int T_enc_max = 0;
-    const int64_t t_enc0 = ggml_time_us();
+    std::vector<int>                T_enc(n, 0);
+    int                             T_enc_max = 0;
+    const int64_t                   t_enc0    = ggml_time_us();
     for (int b = 0; b < n; ++b) {
-        if (cc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
-        if (pcm[b] == nullptr || n_samples[b] <= 0) continue;
-        std::vector<float> pcm_padded =
-            right_pad_pcm(pcm[b], n_samples[b], hp.enc_frame_len);
-        std::vector<float> enc_host; int t_enc_b = 0;
-        if (encode_window_to_host(cc, cm, pcm_padded.data(),
-                                  static_cast<int>(pcm_padded.size()),
-                                  /*emit_dumps=*/false, enc_host, t_enc_b) != TRANSCRIBE_OK
-            || t_enc_b <= 0) continue;
+        if (cc->poll_abort()) {
+            return TRANSCRIBE_ERR_ABORTED;
+        }
+        if (pcm[b] == nullptr || n_samples[b] <= 0) {
+            continue;
+        }
+        std::vector<float> pcm_padded = right_pad_pcm(pcm[b], n_samples[b], hp.enc_frame_len);
+        std::vector<float> enc_host;
+        int                t_enc_b = 0;
+        if (encode_window_to_host(cc, cm, pcm_padded.data(), static_cast<int>(pcm_padded.size()),
+                                  /*emit_dumps=*/false, enc_host, t_enc_b) != TRANSCRIBE_OK ||
+            t_enc_b <= 0) {
+            continue;
+        }
         std::vector<float> adapter_host;
         if (apply_adapter_window(cc, cm, enc_host.data(), t_enc_b,
-                                 /*abs_frame_offset=*/0, /*emit_dumps=*/false,
-                                 adapter_host) != TRANSCRIBE_OK) continue;
-        valid[b] = 1; T_enc[b] = t_enc_b;
+                                 /*abs_frame_offset=*/0, /*emit_dumps=*/false, adapter_host) != TRANSCRIBE_OK) {
+            continue;
+        }
+        valid[b]         = 1;
+        T_enc[b]         = t_enc_b;
         adapter_hosts[b] = std::move(adapter_host);
-        T_enc_max = std::max(T_enc_max, t_enc_b);
+        T_enc_max        = std::max(T_enc_max, t_enc_b);
     }
     const int64_t enc_us = ggml_time_us() - t_enc0;
     if (T_enc_max <= 0) {
         for (int b = 0; b < n; ++b) {
-            transcribe_session::ResultSet rs; rs.status = TRANSCRIBE_ERR_INVALID_ARG;
+            transcribe_session::ResultSet rs;
+            rs.status = TRANSCRIBE_ERR_INVALID_ARG;
             cc->batch_results.push_back(std::move(rs));
         }
         return TRANSCRIBE_OK;
@@ -2024,23 +1902,27 @@ transcribe_status run_batch(
     // that grows with n_past (see below) — reading the full capacity every
     // step would dominate the decode and make batching a net loss.
     const int n_ctx_cap = std::min(max_pos, 2048);
-    ggml_type kv_type = GGML_TYPE_F32;
-    if (cc->kv_type == TRANSCRIBE_KV_TYPE_F16) kv_type = GGML_TYPE_F16;
+    ggml_type kv_type   = GGML_TYPE_F32;
+    if (cc->kv_type == TRANSCRIBE_KV_TYPE_F16) {
+        kv_type = GGML_TYPE_F16;
+    }
     if (cc->kv_cache.buffer != nullptr &&
-        (cc->kv_cache.n_batch != n || cc->kv_cache.T_enc != T_enc_max ||
-         cc->kv_cache.n_ctx != n_ctx_cap))
+        (cc->kv_cache.n_batch != n || cc->kv_cache.T_enc != T_enc_max || cc->kv_cache.n_ctx != n_ctx_cap)) {
         cc->kv_cache.free();
+    }
     if (cc->kv_cache.buffer == nullptr) {
-        if (!kv_cache_init_batched(cc->kv_cache, cm->plan.primary,
-                                   n_ctx_cap, T_enc_max, d_model, n_layer, n, kv_type)) {
+        if (!kv_cache_init_batched(cc->kv_cache, cm->plan.primary, n_ctx_cap, T_enc_max, d_model, n_layer, n,
+                                   kv_type)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "moonshine_streaming run_batch: batched KV cache allocation "
-                "failed — out of memory.");
+                                "moonshine_streaming run_batch: batched KV cache allocation "
+                                "failed — out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
     } else {
         ggml_backend_buffer_clear(cc->kv_cache.buffer, 0);
-        cc->kv_cache.n = 0; cc->kv_cache.head = 0; cc->kv_cache.cross_populated = false;
+        cc->kv_cache.n               = 0;
+        cc->kv_cache.head            = 0;
+        cc->kv_cache.cross_populated = false;
     }
 
     const int64_t t_dec0 = ggml_time_us();
@@ -2049,31 +1931,33 @@ transcribe_status run_batch(
     {
         if (!ensure_compute_ctx(cc, 8 * 1024 * 1024)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "moonshine_streaming run_batch: compute context allocation "
-                "failed (cross_kv) — out of memory.");
+                                "moonshine_streaming run_batch: compute context allocation "
+                                "failed (cross_kv) — out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
-        DecoderBuild cross = build_cross_kv_graph_batched(
-            cc->compute_ctx, cm->weights, hp, cc->kv_cache, T_enc_max, n);
-        if (cross.graph == nullptr) return TRANSCRIBE_ERR_GGUF;
+        DecoderBuild cross = build_cross_kv_graph_batched(cc->compute_ctx, cm->weights, hp, cc->kv_cache, T_enc_max, n);
+        if (cross.graph == nullptr) {
+            return TRANSCRIBE_ERR_GGUF;
+        }
         ggml_backend_sched_reset(cc->sched);
         if (!ggml_backend_sched_alloc_graph(cc->sched, cross.graph)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "moonshine_streaming run_batch: cross_kv graph allocation "
-                "failed — out of memory.");
+                                "moonshine_streaming run_batch: cross_kv graph allocation "
+                                "failed — out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
         std::vector<float> packed(static_cast<size_t>(d_model) * T_enc_max * n, 0.0f);
         for (int b = 0; b < n; ++b) {
-            if (!valid[b]) continue;
-            std::memcpy(packed.data() + static_cast<size_t>(b) * T_enc_max * d_model,
-                        adapter_hosts[b].data(),
+            if (!valid[b]) {
+                continue;
+            }
+            std::memcpy(packed.data() + static_cast<size_t>(b) * T_enc_max * d_model, adapter_hosts[b].data(),
                         static_cast<size_t>(d_model) * T_enc[b] * sizeof(float));
         }
-        ggml_backend_tensor_set(cross.encoder_out_in, packed.data(), 0,
-                                packed.size() * sizeof(float));
-        if (ggml_backend_sched_graph_compute(cc->sched, cross.graph) != GGML_STATUS_SUCCESS)
+        ggml_backend_tensor_set(cross.encoder_out_in, packed.data(), 0, packed.size() * sizeof(float));
+        if (ggml_backend_sched_graph_compute(cc->sched, cross.graph) != GGML_STATUS_SUCCESS) {
             return TRANSCRIBE_ERR_GGUF;
+        }
         cc->kv_cache.cross_populated = true;
     }
 
@@ -2089,102 +1973,152 @@ transcribe_status run_batch(
 
     std::vector<ggml_fp16_t> cmask(static_cast<size_t>(T_enc_max) * n, f16_ninf);
     for (int b = 0; b < n; ++b) {
-        const int real = valid[b] ? T_enc[b] : 1;
+        const int     real = valid[b] ? T_enc[b] : 1;
         ggml_fp16_t * base = cmask.data() + static_cast<size_t>(b) * T_enc_max;
         std::fill(base, base + std::min(real, T_enc_max), f16_zero);
     }
 
     int kv_window = 64;
-    while (kv_window > n_ctx_cap) kv_window /= 2;
-    if (kv_window < 1) kv_window = n_ctx_cap;
+    while (kv_window > n_ctx_cap) {
+        kv_window /= 2;
+    }
+    if (kv_window < 1) {
+        kv_window = n_ctx_cap;
+    }
 
-    StepBuildBatched sb {};
-    auto rebuild_step = [&](int win) -> bool {
+    StepBuildBatched sb{};
+    auto             rebuild_step = [&](int win) -> bool {
         if (!ensure_compute_ctx(cc, 16 * 1024 * 1024)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "moonshine_streaming run_batch: compute context allocation "
-                "failed (step) — out of memory.");
+                                "moonshine_streaming run_batch: compute context allocation "
+                                "failed (step) — out of memory.");
+            return false;
+        }
+        sb = build_step_graph_batched(cc->compute_ctx, cm->weights, hp, cc->kv_cache, win, T_enc_max, n,
+                                      /*use_flash=*/true);
+        if (sb.graph == nullptr || sb.argmax_out == nullptr) {
             return false;
         }
-        sb = build_step_graph_batched(cc->compute_ctx, cm->weights, hp,
-                                      cc->kv_cache, win, T_enc_max, n, /*use_flash=*/true);
-        if (sb.graph == nullptr || sb.argmax_out == nullptr) return false;
         ggml_backend_sched_reset(cc->sched);
         if (!ggml_backend_sched_alloc_graph(cc->sched, sb.graph)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "moonshine_streaming run_batch: step graph allocation failed — "
-                "out of memory.");
+                                "moonshine_streaming run_batch: step graph allocation failed — "
+                                "out of memory.");
             return false;
         }
-        ggml_backend_tensor_set(sb.cross_mask_in, cmask.data(), 0,
-                                cmask.size() * sizeof(ggml_fp16_t));
+        ggml_backend_tensor_set(sb.cross_mask_in, cmask.data(), 0, cmask.size() * sizeof(ggml_fp16_t));
         return true;
     };
-    if (!rebuild_step(kv_window)) return TRANSCRIBE_ERR_GGUF;
+    if (!rebuild_step(kv_window)) {
+        return TRANSCRIBE_ERR_GGUF;
+    }
 
-    std::vector<ggml_fp16_t> smask(static_cast<size_t>(kv_window) * n, f16_ninf);
-    std::vector<int32_t> tok_buf(n, 0), pos_buf(n, 0), argmax_buf(n, 0);
-    std::vector<int64_t> kvidx_buf(n, 0);
-    std::vector<char> finished(n, 0);
+    std::vector<ggml_fp16_t>          smask(static_cast<size_t>(kv_window) * n, f16_ninf);
+    std::vector<int32_t>              tok_buf(n, 0), pos_buf(n, 0), argmax_buf(n, 0);
+    std::vector<int64_t>              kvidx_buf(n, 0);
+    std::vector<char>                 finished(n, 0);
     std::vector<std::vector<int32_t>> generated(n);
-    std::vector<int32_t> next_tok(n, 0);
-    for (int b = 0; b < n; ++b) if (!valid[b]) finished[b] = 1;
+    std::vector<int32_t>              next_tok(n, 0);
+    for (int b = 0; b < n; ++b) {
+        if (!valid[b]) {
+            finished[b] = 1;
+        }
+    }
 
     auto run_step = [&](int posv) -> transcribe_status {
         for (int b = 0; b < n; ++b) {
-            pos_buf[b] = posv; kvidx_buf[b] = posv;
+            pos_buf[b]                                       = posv;
+            kvidx_buf[b]                                     = posv;
             smask[static_cast<size_t>(b) * kv_window + posv] = f16_zero;
         }
         ggml_backend_tensor_set(sb.token_ids_in, tok_buf.data(), 0, n * sizeof(int32_t));
-        ggml_backend_tensor_set(sb.pos_ids_in,  pos_buf.data(), 0, n * sizeof(int32_t));
-        ggml_backend_tensor_set(sb.kv_idx_in,   kvidx_buf.data(), 0, n * sizeof(int64_t));
-        ggml_backend_tensor_set(sb.self_mask_in, smask.data(), 0,
-                                smask.size() * sizeof(ggml_fp16_t));
-        if (ggml_backend_sched_graph_compute(cc->sched, sb.graph) != GGML_STATUS_SUCCESS)
+        ggml_backend_tensor_set(sb.pos_ids_in, pos_buf.data(), 0, n * sizeof(int32_t));
+        ggml_backend_tensor_set(sb.kv_idx_in, kvidx_buf.data(), 0, n * sizeof(int64_t));
+        ggml_backend_tensor_set(sb.self_mask_in, smask.data(), 0, smask.size() * sizeof(ggml_fp16_t));
+        if (ggml_backend_sched_graph_compute(cc->sched, sb.graph) != GGML_STATUS_SUCCESS) {
             return TRANSCRIBE_ERR_GGUF;
+        }
         ggml_backend_tensor_get(sb.argmax_out, argmax_buf.data(), 0, n * sizeof(int32_t));
         return TRANSCRIBE_OK;
     };
 
     // Grow the window (and rebuild the graph + mask) so position `pos` fits.
     auto ensure_window = [&](int pos) -> bool {
-        if (pos + 1 <= kv_window) return true;
+        if (pos + 1 <= kv_window) {
+            return true;
+        }
         int win = kv_window;
-        while (win < pos + 1 && win < n_ctx_cap) win *= 2;
-        if (win > n_ctx_cap) win = n_ctx_cap;
-        if (win == kv_window) return true;
+        while (win < pos + 1 && win < n_ctx_cap) {
+            win *= 2;
+        }
+        if (win > n_ctx_cap) {
+            win = n_ctx_cap;
+        }
+        if (win == kv_window) {
+            return true;
+        }
         // Re-fill a wider mask: positions [0, pos) already written for all b.
         std::vector<ggml_fp16_t> wider(static_cast<size_t>(win) * n, f16_ninf);
-        for (int b = 0; b < n; ++b)
-            std::fill(wider.data() + static_cast<size_t>(b) * win,
-                      wider.data() + static_cast<size_t>(b) * win + pos, f16_zero);
+        for (int b = 0; b < n; ++b) {
+            std::fill(wider.data() + static_cast<size_t>(b) * win, wider.data() + static_cast<size_t>(b) * win + pos,
+                      f16_zero);
+        }
         smask.swap(wider);
         kv_window = win;
         return rebuild_step(kv_window);
     };
 
     // Prompt feed: a single decoder_start token (pos 0).
-    for (int b = 0; b < n; ++b) tok_buf[b] = decoder_start;
-    if (run_step(0) != TRANSCRIBE_OK) return TRANSCRIBE_ERR_GGUF;
     for (int b = 0; b < n; ++b) {
-        if (finished[b]) continue;
+        tok_buf[b] = decoder_start;
+    }
+    if (run_step(0) != TRANSCRIBE_OK) {
+        return TRANSCRIBE_ERR_GGUF;
+    }
+    for (int b = 0; b < n; ++b) {
+        if (finished[b]) {
+            continue;
+        }
         next_tok[b] = argmax_buf[b];
-        if (next_tok[b] == eos) finished[b] = 1;
-        else generated[b].push_back(next_tok[b]);
+        if (next_tok[b] == eos) {
+            finished[b] = 1;
+        } else {
+            generated[b].push_back(next_tok[b]);
+        }
     }
     for (int pos = 1; pos < n_ctx_cap; ++pos) {
-        if (cc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
+        if (cc->poll_abort()) {
+            return TRANSCRIBE_ERR_ABORTED;
+        }
         bool all_done = true;
-        for (int b = 0; b < n; ++b) if (!finished[b]) { all_done = false; break; }
-        if (all_done || pos + 1 > n_ctx_cap) break;
-        if (!ensure_window(pos)) return TRANSCRIBE_ERR_GGUF;
-        for (int b = 0; b < n; ++b) tok_buf[b] = finished[b] ? eos : next_tok[b];
-        if (run_step(pos) != TRANSCRIBE_OK) return TRANSCRIBE_ERR_GGUF;
         for (int b = 0; b < n; ++b) {
-            if (finished[b]) continue;
+            if (!finished[b]) {
+                all_done = false;
+                break;
+            }
+        }
+        if (all_done || pos + 1 > n_ctx_cap) {
+            break;
+        }
+        if (!ensure_window(pos)) {
+            return TRANSCRIBE_ERR_GGUF;
+        }
+        for (int b = 0; b < n; ++b) {
+            tok_buf[b] = finished[b] ? eos : next_tok[b];
+        }
+        if (run_step(pos) != TRANSCRIBE_OK) {
+            return TRANSCRIBE_ERR_GGUF;
+        }
+        for (int b = 0; b < n; ++b) {
+            if (finished[b]) {
+                continue;
+            }
             next_tok[b] = argmax_buf[b];
-            if (next_tok[b] == eos) finished[b] = 1;
-            else generated[b].push_back(next_tok[b]);
+            if (next_tok[b] == eos) {
+                finished[b] = 1;
+            } else {
+                generated[b].push_back(next_tok[b]);
+            }
         }
     }
     const int64_t dec_us = ggml_time_us() - t_dec0;
@@ -2195,39 +2129,44 @@ transcribe_status run_batch(
     {
         int n_truncated = 0;
         for (int b = 0; b < n; ++b) {
-            if (valid[b] && !finished[b]) ++n_truncated;
+            if (valid[b] && !finished[b]) {
+                ++n_truncated;
+            }
         }
         if (n_truncated > 0) {
             cc->was_truncated = true;
-            transcribe::log_msg(
-                TRANSCRIBE_LOG_LEVEL_WARN,
-                "moonshine run_batch: %d of %d utterances truncated — decode "
-                "reached the position cap (%d) before end-of-stream; those "
-                "transcripts may be incomplete. This model is intended for "
-                "short utterances. See transcribe_capabilities.max_audio_ms.",
-                n_truncated, n, n_ctx_cap);
+            transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_WARN,
+                                "moonshine run_batch: %d of %d utterances truncated — decode "
+                                "reached the position cap (%d) before end-of-stream; those "
+                                "transcripts may be incomplete. This model is intended for "
+                                "short utterances. See transcribe_capabilities.max_audio_ms.",
+                                n_truncated, n, n_ctx_cap);
         }
     }
 
-    const int valid_count = std::max(1, static_cast<int>(
-        std::count(valid.begin(), valid.end(), char(1))));
+    const int valid_count = std::max(1, static_cast<int>(std::count(valid.begin(), valid.end(), char(1))));
     for (int b = 0; b < n; ++b) {
         transcribe_session::ResultSet rs;
-        if (!valid[b]) { rs.status = TRANSCRIBE_ERR_INVALID_ARG;
-                         cc->batch_results.push_back(std::move(rs)); continue; }
-        std::string full = cm->tok.decode(generated[b].data(),
-                                          static_cast<int>(generated[b].size()));
-        if (!full.empty() && full.front() == ' ') full.erase(full.begin());
-        transcribe_session::SegmentEntry seg {};
-        seg.t0_ms = 0; seg.t1_ms = 0; seg.text = full;
+        if (!valid[b]) {
+            rs.status = TRANSCRIBE_ERR_INVALID_ARG;
+            cc->batch_results.push_back(std::move(rs));
+            continue;
+        }
+        std::string full = cm->tok.decode(generated[b].data(), static_cast<int>(generated[b].size()));
+        if (!full.empty() && full.front() == ' ') {
+            full.erase(full.begin());
+        }
+        transcribe_session::SegmentEntry seg{};
+        seg.t0_ms = 0;
+        seg.t1_ms = 0;
+        seg.text  = full;
         rs.segments.push_back(std::move(seg));
-        rs.full_text = full;
+        rs.full_text   = full;
         rs.result_kind = TRANSCRIBE_TIMESTAMPS_NONE;
-        rs.has_result = true;
+        rs.has_result  = true;
         // Per-utterance truncation parity (offline run_batch, not streaming).
-        rs.status = !finished[b] ? TRANSCRIBE_ERR_OUTPUT_TRUNCATED
-                                 : TRANSCRIBE_OK;
-        rs.t_mel_us = 0;
+        rs.status      = !finished[b] ? TRANSCRIBE_ERR_OUTPUT_TRUNCATED : TRANSCRIBE_OK;
+        rs.t_mel_us    = 0;
         rs.t_encode_us = enc_us / valid_count;
         rs.t_decode_us = dec_us / valid_count;
         cc->batch_results.push_back(std::move(rs));
@@ -2235,14 +2174,14 @@ transcribe_status run_batch(
 
     if (transcribe::env::flag("TRANSCRIBE_PERF_DEBUG")) {
         log_msg(TRANSCRIBE_LOG_LEVEL_DEBUG,
-            "moonshine_streaming run_batch: n=%d T_enc_max=%d kv_window=%d (cap %d)\n"
-            "  enc+adapter=%.1fms (serial x%d)  decode=%.1fms (batched)",
-            n, T_enc_max, kv_window, n_ctx_cap, enc_us / 1000.0, n, dec_us / 1000.0);
+                "moonshine_streaming run_batch: n=%d T_enc_max=%d kv_window=%d (cap %d)\n"
+                "  enc+adapter=%.1fms (serial x%d)  decode=%.1fms (batched)",
+                n, T_enc_max, kv_window, n_ctx_cap, enc_us / 1000.0, n, dec_us / 1000.0);
     }
     return TRANSCRIBE_OK;
 }
 
-} // namespace
+}  // namespace
 
 extern const Arch arch = {
     /* .name             = */ "moonshine_streaming",
@@ -2258,14 +2197,14 @@ extern const Arch arch = {
     /* .accepts_ext_kind = */ accepts_ext_kind,
 };
 
-} // namespace transcribe::moonshine_streaming
+}  // namespace transcribe::moonshine_streaming
 
 // Public moonshine-streaming extension init (global scope, C linkage).
 // Defined in family source so transcribe.cpp stays family-agnostic.
-extern "C" void transcribe_moonshine_streaming_stream_ext_init(
-    struct transcribe_moonshine_streaming_stream_ext * p)
-{
-    if (p == nullptr) { return; }
+extern "C" void transcribe_moonshine_streaming_stream_ext_init(struct transcribe_moonshine_streaming_stream_ext * p) {
+    if (p == nullptr) {
+        return;
+    }
     std::memset(p, 0, sizeof(*p));
     p->ext.size               = sizeof(*p);
     p->ext.kind               = TRANSCRIBE_EXT_KIND_MOONSHINE_STREAMING_STREAM;
diff --git a/src/arch/moonshine_streaming/moonshine_streaming.h b/src/arch/moonshine_streaming/moonshine_streaming.h
index db608a2a..7e2793b5 100644
--- a/src/arch/moonshine_streaming/moonshine_streaming.h
+++ b/src/arch/moonshine_streaming/moonshine_streaming.h
@@ -10,15 +10,14 @@
 
 #pragma once
 
+#include "ggml-backend.h"
+#include "ggml.h"
 #include "transcribe-backend.h"
-#include "transcribe-session.h"
 #include "transcribe-model.h"
+#include "transcribe-session.h"
 #include "transcribe-tokenizer.h"
 #include "weights.h"
 
-#include "ggml.h"
-#include "ggml-backend.h"
-
 #include <cstdint>
 #include <deque>
 #include <string>
@@ -44,19 +43,19 @@ void apply_family_invariants(transcribe_model & model);
 // ---------------------------------------------------------------------------
 
 struct MoonshineStreamingKvCache {
-    ggml_tensor * self_k = nullptr;
-    ggml_tensor * self_v = nullptr;
+    ggml_tensor * self_k  = nullptr;
+    ggml_tensor * self_v  = nullptr;
     ggml_tensor * cross_k = nullptr;
     ggml_tensor * cross_v = nullptr;
 
-    ggml_context * ctx = nullptr;
+    ggml_context *        ctx    = nullptr;
     ggml_backend_buffer_t buffer = nullptr;
 
-    int n_ctx = 0;
-    int n     = 0;
-    int head  = 0;
-    int T_enc = 0;
-    int n_batch = 1;   // utterance batch width (>1 for the offline batched decoder)
+    int n_ctx   = 0;
+    int n       = 0;
+    int head    = 0;
+    int T_enc   = 0;
+    int n_batch = 1;  // utterance batch width (>1 for the offline batched decoder)
 
     bool cross_populated = false;
 
@@ -69,14 +68,14 @@ struct MoonshineStreamingKvCache {
             ggml_free(ctx);
             ctx = nullptr;
         }
-        self_k = nullptr;
-        self_v = nullptr;
-        cross_k = nullptr;
-        cross_v = nullptr;
-        n = 0;
-        head = 0;
-        T_enc = 0;
-        n_batch = 1;
+        self_k          = nullptr;
+        self_v          = nullptr;
+        cross_k         = nullptr;
+        cross_v         = nullptr;
+        n               = 0;
+        head            = 0;
+        T_enc           = 0;
+        n_batch         = 1;
         cross_populated = false;
     }
 };
@@ -105,10 +104,10 @@ bool kv_cache_init_batched(MoonshineStreamingKvCache & cache,
 // ---------------------------------------------------------------------------
 
 struct MoonshineStreamingModel final : public transcribe_model {
-    Tokenizer                   tok;
-    MoonshineStreamingHParams   hparams;
-    MoonshineStreamingWeights   weights;
-    ggml_context *              ctx_meta = nullptr;
+    Tokenizer                 tok;
+    MoonshineStreamingHParams hparams;
+    MoonshineStreamingWeights weights;
+    ggml_context *            ctx_meta = nullptr;
 
     transcribe::BackendPlan plan;
     ggml_backend_buffer_t   backend_buffer = nullptr;
@@ -120,18 +119,17 @@ struct MoonshineStreamingModel final : public transcribe_model {
 };
 
 struct MoonshineStreamingSession final : public transcribe_session {
-    ggml_context *        compute_ctx = nullptr;
-    ggml_backend_sched_t  sched       = nullptr;
+    ggml_context *       compute_ctx = nullptr;
+    ggml_backend_sched_t sched       = nullptr;
 
     // Host-side mirror of the post-adapter encoder hidden. The adapter
     // pos_emb add (and proj when present) is applied once per session;
     // this host buffer feeds the cross_kv precompute graph.
     std::vector<float> adapter_host;
-    int                enc_T = 0;   // T_enc
+    int                enc_T = 0;  // T_enc
 
     MoonshineStreamingKvCache kv_cache;
 
-
     bool encoder_use_flash = true;
     bool decoder_use_flash = true;
 
@@ -160,32 +158,32 @@ struct MoonshineStreamingSession final : public transcribe_session {
     //
     // These fields are NOT touched by clear_result — the family owns its
     // per-utterance audio + encoder scratch.
-    std::vector<float>                stream_pcm_buffer;
-    int64_t                           stream_pcm_start_sample = 0;
-    std::vector<float>                stream_adapter_committed;
-    std::vector<std::vector<float>>   stream_cross_k_committed;
-    std::vector<std::vector<float>>   stream_cross_v_committed;
-    int32_t                           stream_T_emitted             = 0;
+    std::vector<float>               stream_pcm_buffer;
+    int64_t                          stream_pcm_start_sample = 0;
+    std::vector<float>               stream_adapter_committed;
+    std::vector<std::vector<float>>  stream_cross_k_committed;
+    std::vector<std::vector<float>>  stream_cross_v_committed;
+    int32_t                          stream_T_emitted      = 0;
     // T_emitted captured at the last successful partial decode; lets
     // stream_feed / stream_finalize skip a redundant decode when no
     // new encoder frames have been committed since the previous one.
-    int32_t                           stream_last_decoded_T        = 0;
+    int32_t                          stream_last_decoded_T = 0;
     // Recent partial-decode token id sequences, used to compute the
     // longest common prefix that's safe to mark committed across feeds.
     // Reset at stream_begin; updated after every successful partial decode.
-    std::deque<std::vector<int32_t>>  stream_token_id_history;
+    std::deque<std::vector<int32_t>> stream_token_id_history;
     // Geometry, resolved at stream_begin (constant per stream).
-    int32_t                           stream_L_total_frames        = 0;
-    int32_t                           stream_R_total_frames        = 0;
-    int32_t                           stream_frontend_pad_frames   = 0;
-    int32_t                           stream_samples_per_enc_frame = 0;
+    int32_t                          stream_L_total_frames        = 0;
+    int32_t                          stream_R_total_frames        = 0;
+    int32_t                          stream_frontend_pad_frames   = 0;
+    int32_t                          stream_samples_per_enc_frame = 0;
     // Minimum gap (encoder frames) between per-feed AR decode runs, from the
     // family extension. 0 = decode every advance; finalize always decodes once.
-    int32_t                           stream_min_decode_frames     = 0;
-    transcribe_run_params                 stream_run_params {};
+    int32_t                          stream_min_decode_frames     = 0;
+    transcribe_run_params            stream_run_params{};
 
     MoonshineStreamingSession() = default;
     ~MoonshineStreamingSession() override;
 };
 
-} // namespace transcribe::moonshine_streaming
+}  // namespace transcribe::moonshine_streaming
diff --git a/src/arch/moonshine_streaming/weights.cpp b/src/arch/moonshine_streaming/weights.cpp
index 0d988262..63c3bf63 100644
--- a/src/arch/moonshine_streaming/weights.cpp
+++ b/src/arch/moonshine_streaming/weights.cpp
@@ -21,12 +21,11 @@
 
 #include "weights.h"
 
-#include "transcribe-meta.h"
-#include "transcribe-weights-util.h"
-#include "transcribe-log.h"
-
 #include "ggml.h"
 #include "gguf.h"
+#include "transcribe-log.h"
+#include "transcribe-meta.h"
+#include "transcribe-weights-util.h"
 
 #include <cstdio>
 #include <cstring>
@@ -43,10 +42,9 @@ transcribe_status read_optional_u32_kv(const gguf_context * gguf,
                                        const char *         key,
                                        const char *         error_tag,
                                        int32_t              default_value,
-                                       int32_t &            out)
-{
-    uint32_t value = 0;
-    const auto st = transcribe::read_uint32_kv(gguf, key, value);
+                                       int32_t &            out) {
+    uint32_t   value = 0;
+    const auto st    = transcribe::read_uint32_kv(gguf, key, value);
     if (st == transcribe::KvResult::Ok) {
         out = static_cast<int32_t>(value);
         return TRANSCRIBE_OK;
@@ -63,10 +61,9 @@ transcribe_status read_optional_f32_kv(const gguf_context * gguf,
                                        const char *         key,
                                        const char *         error_tag,
                                        float                default_value,
-                                       float &              out)
-{
-    float value = default_value;
-    const auto st = transcribe::read_float32_kv(gguf, key, value);
+                                       float &              out) {
+    float      value = default_value;
+    const auto st    = transcribe::read_float32_kv(gguf, key, value);
     if (st == transcribe::KvResult::Ok) {
         out = value;
         return TRANSCRIBE_OK;
@@ -79,12 +76,13 @@ transcribe_status read_optional_f32_kv(const gguf_context * gguf,
     return TRANSCRIBE_ERR_GGUF;
 }
 
-transcribe_status read_required_u32_array_kv(const gguf_context * gguf,
-                                             const char *         key,
-                                             const char *         error_tag,
-                                             std::vector<int32_t> & out)
-{
-    if (gguf == nullptr) return TRANSCRIBE_ERR_INVALID_ARG;
+transcribe_status read_required_u32_array_kv(const gguf_context *   gguf,
+                                             const char *           key,
+                                             const char *           error_tag,
+                                             std::vector<int32_t> & out) {
+    if (gguf == nullptr) {
+        return TRANSCRIBE_ERR_INVALID_ARG;
+    }
     const int64_t kid = gguf_find_key(gguf, key);
     if (kid < 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: missing required KV %s", error_tag, key);
@@ -96,102 +94,227 @@ transcribe_status read_required_u32_array_kv(const gguf_context * gguf,
     }
     const gguf_type elem_type = gguf_get_arr_type(gguf, kid);
     if (elem_type != GGUF_TYPE_UINT32 && elem_type != GGUF_TYPE_INT32) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "%s: KV %s array element type is not u32/i32 (got %d)",
-                     error_tag, key, static_cast<int>(elem_type));
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: KV %s array element type is not u32/i32 (got %d)", error_tag, key,
+                static_cast<int>(elem_type));
         return TRANSCRIBE_ERR_GGUF;
     }
-    const size_t n = gguf_get_arr_n(gguf, kid);
+    const size_t n    = gguf_get_arr_n(gguf, kid);
     const void * data = gguf_get_arr_data(gguf, kid);
     out.resize(n);
     if (elem_type == GGUF_TYPE_UINT32) {
         const uint32_t * src = static_cast<const uint32_t *>(data);
-        for (size_t i = 0; i < n; ++i) out[i] = static_cast<int32_t>(src[i]);
+        for (size_t i = 0; i < n; ++i) {
+            out[i] = static_cast<int32_t>(src[i]);
+        }
     } else {
         const int32_t * src = static_cast<const int32_t *>(data);
-        for (size_t i = 0; i < n; ++i) out[i] = src[i];
+        for (size_t i = 0; i < n; ++i) {
+            out[i] = src[i];
+        }
     }
     return TRANSCRIBE_OK;
 }
 
-} // namespace
+}  // namespace
 
 // ---------------------------------------------------------------------------
 // Hparams
 // ---------------------------------------------------------------------------
 
-transcribe_status read_moonshine_streaming_hparams(const gguf_context *               gguf,
-                                                    MoonshineStreamingHParams &        hp)
-{
+transcribe_status read_moonshine_streaming_hparams(const gguf_context * gguf, MoonshineStreamingHParams & hp) {
     if (gguf == nullptr) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
 
-    using transcribe::read_required_u32_kv;
-    using transcribe::read_required_string_kv;
     using transcribe::read_optional_bool_kv;
+    using transcribe::read_required_string_kv;
+    using transcribe::read_required_u32_kv;
 
     // Encoder.
-    if (auto st = read_required_u32_kv (gguf, "stt.moonshine_streaming.encoder.n_layers",   kFamilyTag, hp.enc_n_layers);   st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv (gguf, "stt.moonshine_streaming.encoder.d_model",    kFamilyTag, hp.enc_d_model);    st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv (gguf, "stt.moonshine_streaming.encoder.n_heads",    kFamilyTag, hp.enc_n_heads);    st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_u32_kv (gguf, "stt.moonshine_streaming.encoder.n_kv_heads", kFamilyTag, hp.enc_n_heads, hp.enc_n_kv_heads); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv (gguf, "stt.moonshine_streaming.encoder.head_dim",   kFamilyTag, hp.enc_head_dim);   st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv (gguf, "stt.moonshine_streaming.encoder.ffn_dim",    kFamilyTag, hp.enc_ffn_dim);    st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.moonshine_streaming.encoder.activation", kFamilyTag, hp.enc_activation); st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_u32_kv(gguf, "stt.moonshine_streaming.encoder.n_layers", kFamilyTag, hp.enc_n_layers);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.moonshine_streaming.encoder.d_model", kFamilyTag, hp.enc_d_model);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.moonshine_streaming.encoder.n_heads", kFamilyTag, hp.enc_n_heads);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_u32_kv(gguf, "stt.moonshine_streaming.encoder.n_kv_heads", kFamilyTag, hp.enc_n_heads,
+                                       hp.enc_n_kv_heads);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.moonshine_streaming.encoder.head_dim", kFamilyTag, hp.enc_head_dim);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.moonshine_streaming.encoder.ffn_dim", kFamilyTag, hp.enc_ffn_dim);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st =
+            read_required_string_kv(gguf, "stt.moonshine_streaming.encoder.activation", kFamilyTag, hp.enc_activation);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
     {
         float fr = 0.0f;
-        if (auto st = transcribe::read_required_f32_kv(gguf, "stt.moonshine_streaming.encoder.frame_ms", kFamilyTag, fr); st != TRANSCRIBE_OK) return st;
+        if (auto st =
+                transcribe::read_required_f32_kv(gguf, "stt.moonshine_streaming.encoder.frame_ms", kFamilyTag, fr);
+            st != TRANSCRIBE_OK) {
+            return st;
+        }
         hp.enc_frame_ms = fr;
     }
-    if (auto st = read_required_u32_kv (gguf, "stt.moonshine_streaming.encoder.frame_len",   kFamilyTag, hp.enc_frame_len); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_array_kv(gguf, "stt.moonshine_streaming.encoder.sliding_windows", kFamilyTag, hp.enc_sliding_windows); st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_u32_kv(gguf, "stt.moonshine_streaming.encoder.frame_len", kFamilyTag, hp.enc_frame_len);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_array_kv(gguf, "stt.moonshine_streaming.encoder.sliding_windows", kFamilyTag,
+                                             hp.enc_sliding_windows);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Decoder.
-    if (auto st = read_required_u32_kv (gguf, "stt.moonshine_streaming.decoder.n_layers",                kFamilyTag, hp.dec_n_layers);                st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv (gguf, "stt.moonshine_streaming.decoder.d_model",                 kFamilyTag, hp.dec_d_model);                 st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv (gguf, "stt.moonshine_streaming.decoder.n_heads",                 kFamilyTag, hp.dec_n_heads);                 st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_u32_kv (gguf, "stt.moonshine_streaming.decoder.n_kv_heads",              kFamilyTag, hp.dec_n_heads, hp.dec_n_kv_heads); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv (gguf, "stt.moonshine_streaming.decoder.head_dim",                kFamilyTag, hp.dec_head_dim);                st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv (gguf, "stt.moonshine_streaming.decoder.ffn_dim",                 kFamilyTag, hp.dec_ffn_dim);                 st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.moonshine_streaming.decoder.activation",            kFamilyTag, hp.dec_activation);              st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv (gguf, "stt.moonshine_streaming.decoder.vocab_size",              kFamilyTag, hp.dec_vocab_size);              st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv (gguf, "stt.moonshine_streaming.decoder.max_position_embeddings", kFamilyTag, hp.dec_max_position_embeddings); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_bool_kv(gguf, "stt.moonshine_streaming.decoder.tie_word_embeddings",     kFamilyTag, false, hp.dec_tie_word_embeddings); st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_u32_kv(gguf, "stt.moonshine_streaming.decoder.n_layers", kFamilyTag, hp.dec_n_layers);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.moonshine_streaming.decoder.d_model", kFamilyTag, hp.dec_d_model);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.moonshine_streaming.decoder.n_heads", kFamilyTag, hp.dec_n_heads);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_u32_kv(gguf, "stt.moonshine_streaming.decoder.n_kv_heads", kFamilyTag, hp.dec_n_heads,
+                                       hp.dec_n_kv_heads);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.moonshine_streaming.decoder.head_dim", kFamilyTag, hp.dec_head_dim);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.moonshine_streaming.decoder.ffn_dim", kFamilyTag, hp.dec_ffn_dim);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st =
+            read_required_string_kv(gguf, "stt.moonshine_streaming.decoder.activation", kFamilyTag, hp.dec_activation);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st =
+            read_required_u32_kv(gguf, "stt.moonshine_streaming.decoder.vocab_size", kFamilyTag, hp.dec_vocab_size);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.moonshine_streaming.decoder.max_position_embeddings", kFamilyTag,
+                                       hp.dec_max_position_embeddings);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_bool_kv(gguf, "stt.moonshine_streaming.decoder.tie_word_embeddings", kFamilyTag, false,
+                                        hp.dec_tie_word_embeddings);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Special tokens.
-    if (auto st = read_required_u32_kv(gguf, "stt.moonshine_streaming.bos_token_id",           kFamilyTag, hp.bos_token_id);           st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.moonshine_streaming.eos_token_id",           kFamilyTag, hp.eos_token_id);           st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.moonshine_streaming.pad_token_id",           kFamilyTag, hp.pad_token_id);           st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.moonshine_streaming.decoder_start_token_id", kFamilyTag, hp.decoder_start_token_id); st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_u32_kv(gguf, "stt.moonshine_streaming.bos_token_id", kFamilyTag, hp.bos_token_id);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.moonshine_streaming.eos_token_id", kFamilyTag, hp.eos_token_id);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.moonshine_streaming.pad_token_id", kFamilyTag, hp.pad_token_id);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.moonshine_streaming.decoder_start_token_id", kFamilyTag,
+                                       hp.decoder_start_token_id);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Attention / RoPE.
-    if (auto st = read_optional_f32_kv (gguf, "stt.moonshine_streaming.partial_rotary_factor",       kFamilyTag, 0.8f, hp.partial_rotary_factor); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_f32_kv (gguf, "stt.moonshine_streaming.rope_theta",                  kFamilyTag, 10000.0f, hp.rope_theta);        st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_bool_kv(gguf, "stt.moonshine_streaming.attention_bias",              kFamilyTag, false, hp.attention_bias);       st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_u32_kv (gguf, "stt.moonshine_streaming.pad_head_dim_to_multiple_of", kFamilyTag, 0, hp.pad_head_dim_multiple);    st != TRANSCRIBE_OK) return st;
+    if (auto st = read_optional_f32_kv(gguf, "stt.moonshine_streaming.partial_rotary_factor", kFamilyTag, 0.8f,
+                                       hp.partial_rotary_factor);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_f32_kv(gguf, "stt.moonshine_streaming.rope_theta", kFamilyTag, 10000.0f, hp.rope_theta);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st =
+            read_optional_bool_kv(gguf, "stt.moonshine_streaming.attention_bias", kFamilyTag, false, hp.attention_bias);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_u32_kv(gguf, "stt.moonshine_streaming.pad_head_dim_to_multiple_of", kFamilyTag, 0,
+                                       hp.pad_head_dim_multiple);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // CMVN epsilon (informational; the value is fixed in modeling code at 1e-6).
-    if (auto st = read_optional_f32_kv (gguf, "stt.moonshine_streaming.cmvn_eps", kFamilyTag, 1e-6f, hp.cmvn_eps); st != TRANSCRIBE_OK) return st;
+    if (auto st = read_optional_f32_kv(gguf, "stt.moonshine_streaming.cmvn_eps", kFamilyTag, 1e-6f, hp.cmvn_eps);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Adapter.
-    if (auto st = read_optional_u32_kv (gguf, "stt.moonshine_streaming.encoder_hidden_size", kFamilyTag, hp.enc_d_model, hp.encoder_hidden_size); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_bool_kv(gguf, "stt.moonshine_streaming.adapter_has_proj",    kFamilyTag, false, hp.adapter_has_proj);             st != TRANSCRIBE_OK) return st;
+    if (auto st = read_optional_u32_kv(gguf, "stt.moonshine_streaming.encoder_hidden_size", kFamilyTag, hp.enc_d_model,
+                                       hp.encoder_hidden_size);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_bool_kv(gguf, "stt.moonshine_streaming.adapter_has_proj", kFamilyTag, false,
+                                        hp.adapter_has_proj);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Frontend.
-    if (auto st = read_required_string_kv(gguf, "stt.frontend.type",        kFamilyTag, hp.fe_type);        st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv   (gguf, "stt.frontend.sample_rate", kFamilyTag, hp.fe_sample_rate); st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_string_kv(gguf, "stt.frontend.type", kFamilyTag, hp.fe_type); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.sample_rate", kFamilyTag, hp.fe_sample_rate);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Capability flags. Re-read here for in-decoder convenience.
-    if (auto st = read_optional_bool_kv(gguf, "stt.capability.lang_detect", kFamilyTag, false, hp.cap_lang_detect); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_bool_kv(gguf, "stt.capability.translate",   kFamilyTag, false, hp.cap_translate);   st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_bool_kv(gguf, "stt.capability.timestamps",  kFamilyTag, false, hp.cap_timestamps);  st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_bool_kv(gguf, "stt.capability.streaming",   kFamilyTag, true,  hp.cap_streaming);   st != TRANSCRIBE_OK) return st;
+    if (auto st = read_optional_bool_kv(gguf, "stt.capability.lang_detect", kFamilyTag, false, hp.cap_lang_detect);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_bool_kv(gguf, "stt.capability.translate", kFamilyTag, false, hp.cap_translate);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_bool_kv(gguf, "stt.capability.timestamps", kFamilyTag, false, hp.cap_timestamps);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_bool_kv(gguf, "stt.capability.streaming", kFamilyTag, true, hp.cap_streaming);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // ----- Cross-field invariants -----
-    if (hp.enc_n_layers <= 0 || hp.enc_d_model <= 0 || hp.enc_n_heads <= 0 ||
-        hp.enc_head_dim <= 0 || hp.enc_ffn_dim <= 0)
-    {
+    if (hp.enc_n_layers <= 0 || hp.enc_d_model <= 0 || hp.enc_n_heads <= 0 || hp.enc_head_dim <= 0 ||
+        hp.enc_ffn_dim <= 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine_streaming: encoder hparams must be positive");
         return TRANSCRIBE_ERR_GGUF;
     }
@@ -202,88 +325,74 @@ transcribe_status read_moonshine_streaming_hparams(const gguf_context *
     // the residual stream dim in any in-the-wild moonshine_streaming
     // variant; flag the inverted case to catch a malformed config early.
     if (hp.enc_d_model < hp.enc_n_heads * hp.enc_head_dim) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine_streaming: encoder d_model (%d) < n_heads (%d) * head_dim (%d)",
-                     hp.enc_d_model, hp.enc_n_heads, hp.enc_head_dim);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine_streaming: encoder d_model (%d) < n_heads (%d) * head_dim (%d)",
+                hp.enc_d_model, hp.enc_n_heads, hp.enc_head_dim);
         return TRANSCRIBE_ERR_GGUF;
     }
-    if (hp.dec_n_layers <= 0 || hp.dec_d_model <= 0 || hp.dec_n_heads <= 0 ||
-        hp.dec_head_dim <= 0 || hp.dec_ffn_dim <= 0 ||
-        hp.dec_max_position_embeddings <= 0 || hp.dec_vocab_size <= 0)
-    {
+    if (hp.dec_n_layers <= 0 || hp.dec_d_model <= 0 || hp.dec_n_heads <= 0 || hp.dec_head_dim <= 0 ||
+        hp.dec_ffn_dim <= 0 || hp.dec_max_position_embeddings <= 0 || hp.dec_vocab_size <= 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine_streaming: decoder hparams must be positive");
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.dec_d_model != hp.dec_n_heads * hp.dec_head_dim) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine_streaming: decoder d_model (%d) != n_heads (%d) * head_dim (%d)",
-                     hp.dec_d_model, hp.dec_n_heads, hp.dec_head_dim);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine_streaming: decoder d_model (%d) != n_heads (%d) * head_dim (%d)",
+                hp.dec_d_model, hp.dec_n_heads, hp.dec_head_dim);
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.enc_activation != "gelu") {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine_streaming: only \"gelu\" encoder activation supported (got \"%s\")",
-                     hp.enc_activation.c_str());
+                "moonshine_streaming: only \"gelu\" encoder activation supported (got \"%s\")",
+                hp.enc_activation.c_str());
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.dec_activation != "silu") {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine_streaming: only \"silu\" decoder activation supported (got \"%s\")",
-                     hp.dec_activation.c_str());
+                "moonshine_streaming: only \"silu\" decoder activation supported (got \"%s\")",
+                hp.dec_activation.c_str());
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.dec_tie_word_embeddings) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine_streaming: tie_word_embeddings=true is not supported "
-                     "(reference always carries a separate proj_out.weight)");
+                "moonshine_streaming: tie_word_embeddings=true is not supported "
+                "(reference always carries a separate proj_out.weight)");
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.attention_bias) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine_streaming: attention_bias=true is not supported");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine_streaming: attention_bias=true is not supported");
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.partial_rotary_factor <= 0.0f || hp.partial_rotary_factor > 1.0f) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine_streaming: invalid partial_rotary_factor=%g (expected (0, 1])",
-                     hp.partial_rotary_factor);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine_streaming: invalid partial_rotary_factor=%g (expected (0, 1])",
+                hp.partial_rotary_factor);
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.fe_type != "raw") {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine_streaming: unsupported frontend type \"%s\" (only \"raw\")",
-                     hp.fe_type.c_str());
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine_streaming: unsupported frontend type \"%s\" (only \"raw\")",
+                hp.fe_type.c_str());
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.fe_sample_rate != 16000) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine_streaming: unsupported sample_rate=%d (only 16000 Hz)",
-                     hp.fe_sample_rate);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine_streaming: unsupported sample_rate=%d (only 16000 Hz)",
+                hp.fe_sample_rate);
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.enc_frame_len <= 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine_streaming: invalid encoder frame_len=%d",
-                     hp.enc_frame_len);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine_streaming: invalid encoder frame_len=%d", hp.enc_frame_len);
         return TRANSCRIBE_ERR_GGUF;
     }
-    if (hp.enc_sliding_windows.size() !=
-        static_cast<size_t>(hp.enc_n_layers) * 2)
-    {
+    if (hp.enc_sliding_windows.size() != static_cast<size_t>(hp.enc_n_layers) * 2) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine_streaming: encoder.sliding_windows length %zu != 2 * n_layers (%d)",
-                     hp.enc_sliding_windows.size(), hp.enc_n_layers);
+                "moonshine_streaming: encoder.sliding_windows length %zu != 2 * n_layers (%d)",
+                hp.enc_sliding_windows.size(), hp.enc_n_layers);
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.encoder_hidden_size != hp.enc_d_model) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "moonshine_streaming: encoder_hidden_size (%d) disagrees with encoder.d_model (%d)",
-                     hp.encoder_hidden_size, hp.enc_d_model);
+                "moonshine_streaming: encoder_hidden_size (%d) disagrees with encoder.d_model (%d)",
+                hp.encoder_hidden_size, hp.enc_d_model);
         return TRANSCRIBE_ERR_GGUF;
     }
-    if (hp.bos_token_id < 0 || hp.eos_token_id < 0 ||
-        hp.pad_token_id < 0 || hp.decoder_start_token_id < 0)
-    {
+    if (hp.bos_token_id < 0 || hp.eos_token_id < 0 || hp.pad_token_id < 0 || hp.decoder_start_token_id < 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "moonshine_streaming: special token IDs must be set");
         return TRANSCRIBE_ERR_GGUF;
     }
@@ -301,42 +410,41 @@ using transcribe::weights::lname;
 
 constexpr const char * kTag = kFamilyTag;
 
-#define GET_F32(slot, name, ...) \
-    do { \
-        ggml_tensor * _t = transcribe::weights::find_tensor( \
-            ctx_meta, (name), \
-            {GGML_TYPE_F32}, {__VA_ARGS__}, kTag); \
-        if (_t == nullptr) return TRANSCRIBE_ERR_GGUF; \
-        (slot) = _t; \
+#define GET_F32(slot, name, ...)                                                                          \
+    do {                                                                                                  \
+        ggml_tensor * _t =                                                                                \
+            transcribe::weights::find_tensor(ctx_meta, (name), { GGML_TYPE_F32 }, { __VA_ARGS__ }, kTag); \
+        if (_t == nullptr)                                                                                \
+            return TRANSCRIBE_ERR_GGUF;                                                                   \
+        (slot) = _t;                                                                                      \
     } while (0)
 
-#define GET_CONV(slot, name, ...) \
-    do { \
-        ggml_tensor * _t = transcribe::weights::find_tensor( \
-            ctx_meta, (name), \
-            {TRANSCRIBE_QUANT_CONV_TYPES}, \
-            {__VA_ARGS__}, kTag); \
-        if (_t == nullptr) return TRANSCRIBE_ERR_GGUF; \
-        (slot) = _t; \
+#define GET_CONV(slot, name, ...)                                                                              \
+    do {                                                                                                       \
+        ggml_tensor * _t = transcribe::weights::find_tensor(ctx_meta, (name), { TRANSCRIBE_QUANT_CONV_TYPES }, \
+                                                            { __VA_ARGS__ }, kTag);                            \
+        if (_t == nullptr)                                                                                     \
+            return TRANSCRIBE_ERR_GGUF;                                                                        \
+        (slot) = _t;                                                                                           \
     } while (0)
 
-#define GET_LIN(slot, name, ...) \
-    do { \
-        ggml_tensor * _t = transcribe::weights::find_tensor( \
-            ctx_meta, (name), \
-            {TRANSCRIBE_QUANT_LINEAR_TYPES}, \
-            {__VA_ARGS__}, kTag); \
-        if (_t == nullptr) return TRANSCRIBE_ERR_GGUF; \
-        (slot) = _t; \
+#define GET_LIN(slot, name, ...)                                                                                 \
+    do {                                                                                                         \
+        ggml_tensor * _t = transcribe::weights::find_tensor(ctx_meta, (name), { TRANSCRIBE_QUANT_LINEAR_TYPES }, \
+                                                            { __VA_ARGS__ }, kTag);                              \
+        if (_t == nullptr)                                                                                       \
+            return TRANSCRIBE_ERR_GGUF;                                                                          \
+        (slot) = _t;                                                                                             \
     } while (0)
 
-} // namespace
+}  // namespace
 
-transcribe_status build_moonshine_streaming_weights(ggml_context *                      ctx_meta,
-                                                     const MoonshineStreamingHParams &  hp,
-                                                     MoonshineStreamingWeights &        weights)
-{
-    if (ctx_meta == nullptr) return TRANSCRIBE_ERR_INVALID_ARG;
+transcribe_status build_moonshine_streaming_weights(ggml_context *                    ctx_meta,
+                                                    const MoonshineStreamingHParams & hp,
+                                                    MoonshineStreamingWeights &       weights) {
+    if (ctx_meta == nullptr) {
+        return TRANSCRIBE_ERR_INVALID_ARG;
+    }
 
     const int64_t enc_h     = hp.enc_d_model;
     const int64_t enc_ff    = hp.enc_ffn_dim;
@@ -349,12 +457,12 @@ transcribe_status build_moonshine_streaming_weights(ggml_context *
     // ----- encoder embedder -----
     // PyTorch Conv1d weight: [out_channels, in_channels, K]; ggml ne is [K, in, out].
     // Linear weight: [out, in] in PyTorch → ggml ne [in, out].
-    GET_F32 (weights.embedder.comp_log_k, "enc.embedder.comp.log_k",  /*ne0=*/1);
-    GET_LIN (weights.embedder.linear_w,   "enc.embedder.linear.weight", frame_len, enc_h);
-    GET_CONV(weights.embedder.conv1_w,    "enc.embedder.conv1.weight", /*K=*/5, /*in=*/enc_h,     /*out=*/2 * enc_h);
-    GET_F32 (weights.embedder.conv1_b,    "enc.embedder.conv1.bias",   /*ne0=*/2 * enc_h);
-    GET_CONV(weights.embedder.conv2_w,    "enc.embedder.conv2.weight", /*K=*/5, /*in=*/2 * enc_h, /*out=*/enc_h);
-    GET_F32 (weights.embedder.conv2_b,    "enc.embedder.conv2.bias",   /*ne0=*/enc_h);
+    GET_F32(weights.embedder.comp_log_k, "enc.embedder.comp.log_k", /*ne0=*/1);
+    GET_LIN(weights.embedder.linear_w, "enc.embedder.linear.weight", frame_len, enc_h);
+    GET_CONV(weights.embedder.conv1_w, "enc.embedder.conv1.weight", /*K=*/5, /*in=*/enc_h, /*out=*/2 * enc_h);
+    GET_F32(weights.embedder.conv1_b, "enc.embedder.conv1.bias", /*ne0=*/2 * enc_h);
+    GET_CONV(weights.embedder.conv2_w, "enc.embedder.conv2.weight", /*K=*/5, /*in=*/2 * enc_h, /*out=*/enc_h);
+    GET_F32(weights.embedder.conv2_b, "enc.embedder.conv2.bias", /*ne0=*/enc_h);
 
     // ----- encoder top -----
     GET_F32(weights.enc_top.final_norm_w, "enc.final_norm.weight", enc_h);
@@ -370,16 +478,16 @@ transcribe_status build_moonshine_streaming_weights(ggml_context *
         auto & b = weights.enc_blocks[i];
 
         GET_F32(b.norm_attn_w, lname("enc.blocks.%d.norm_attn.weight", i), enc_h);
-        GET_LIN(b.attn_q_w,    lname("enc.blocks.%d.attn.q.weight",    i), enc_h,      enc_attn_h);
-        GET_LIN(b.attn_k_w,    lname("enc.blocks.%d.attn.k.weight",    i), enc_h,      enc_attn_h);
-        GET_LIN(b.attn_v_w,    lname("enc.blocks.%d.attn.v.weight",    i), enc_h,      enc_attn_h);
-        GET_LIN(b.attn_out_w,  lname("enc.blocks.%d.attn.out.weight",  i), enc_attn_h, enc_h);
-
-        GET_F32(b.norm_ffn_w,  lname("enc.blocks.%d.norm_ffn.weight",  i), enc_h);
-        GET_LIN(b.ffn_fc1_w,   lname("enc.blocks.%d.ffn.fc1.weight",   i), enc_h, enc_ff);
-        GET_F32(b.ffn_fc1_b,   lname("enc.blocks.%d.ffn.fc1.bias",     i), enc_ff);
-        GET_LIN(b.ffn_fc2_w,   lname("enc.blocks.%d.ffn.fc2.weight",   i), enc_ff, enc_h);
-        GET_F32(b.ffn_fc2_b,   lname("enc.blocks.%d.ffn.fc2.bias",     i), enc_h);
+        GET_LIN(b.attn_q_w, lname("enc.blocks.%d.attn.q.weight", i), enc_h, enc_attn_h);
+        GET_LIN(b.attn_k_w, lname("enc.blocks.%d.attn.k.weight", i), enc_h, enc_attn_h);
+        GET_LIN(b.attn_v_w, lname("enc.blocks.%d.attn.v.weight", i), enc_h, enc_attn_h);
+        GET_LIN(b.attn_out_w, lname("enc.blocks.%d.attn.out.weight", i), enc_attn_h, enc_h);
+
+        GET_F32(b.norm_ffn_w, lname("enc.blocks.%d.norm_ffn.weight", i), enc_h);
+        GET_LIN(b.ffn_fc1_w, lname("enc.blocks.%d.ffn.fc1.weight", i), enc_h, enc_ff);
+        GET_F32(b.ffn_fc1_b, lname("enc.blocks.%d.ffn.fc1.bias", i), enc_ff);
+        GET_LIN(b.ffn_fc2_w, lname("enc.blocks.%d.ffn.fc2.weight", i), enc_ff, enc_h);
+        GET_F32(b.ffn_fc2_b, lname("enc.blocks.%d.ffn.fc2.bias", i), enc_h);
     }
 
     // ----- adapter -----
@@ -392,7 +500,7 @@ transcribe_status build_moonshine_streaming_weights(ggml_context *
     // ----- decoder top -----
     GET_LIN(weights.dec_top.token_embd_w, "dec.token_embd.weight", dec_h, vocab);
     GET_F32(weights.dec_top.final_norm_w, "dec.final_norm.weight", dec_h);
-    GET_LIN(weights.dec_top.lm_head_w,    "dec.lm_head.weight",    dec_h, vocab);
+    GET_LIN(weights.dec_top.lm_head_w, "dec.lm_head.weight", dec_h, vocab);
 
     // ----- decoder blocks -----
     weights.dec_blocks.assign(hp.dec_n_layers, MoonshineStreamingDecBlock{});
@@ -400,27 +508,27 @@ transcribe_status build_moonshine_streaming_weights(ggml_context *
         auto & b = weights.dec_blocks[i];
 
         // Self-attn (bias-less).
-        GET_F32(b.norm_self_w, lname("dec.blocks.%d.norm_self.weight",    i), dec_h);
-        GET_LIN(b.self_q_w,    lname("dec.blocks.%d.self_attn.q.weight",  i), dec_h, dec_h);
-        GET_LIN(b.self_k_w,    lname("dec.blocks.%d.self_attn.k.weight",  i), dec_h, dec_h);
-        GET_LIN(b.self_v_w,    lname("dec.blocks.%d.self_attn.v.weight",  i), dec_h, dec_h);
-        GET_LIN(b.self_out_w,  lname("dec.blocks.%d.self_attn.out.weight",i), dec_h, dec_h);
+        GET_F32(b.norm_self_w, lname("dec.blocks.%d.norm_self.weight", i), dec_h);
+        GET_LIN(b.self_q_w, lname("dec.blocks.%d.self_attn.q.weight", i), dec_h, dec_h);
+        GET_LIN(b.self_k_w, lname("dec.blocks.%d.self_attn.k.weight", i), dec_h, dec_h);
+        GET_LIN(b.self_v_w, lname("dec.blocks.%d.self_attn.v.weight", i), dec_h, dec_h);
+        GET_LIN(b.self_out_w, lname("dec.blocks.%d.self_attn.out.weight", i), dec_h, dec_h);
 
         // Cross-attn (bias-less). Decoder hidden_size is used for both
         // sides (cross-attn projects `dec_h → dec_h` per HF — encoder
         // output is already in `dec_h` after the adapter).
-        GET_F32(b.norm_cross_w, lname("dec.blocks.%d.norm_cross.weight",     i), dec_h);
-        GET_LIN(b.cross_q_w,    lname("dec.blocks.%d.cross_attn.q.weight",   i), dec_h, dec_h);
-        GET_LIN(b.cross_k_w,    lname("dec.blocks.%d.cross_attn.k.weight",   i), dec_h, dec_h);
-        GET_LIN(b.cross_v_w,    lname("dec.blocks.%d.cross_attn.v.weight",   i), dec_h, dec_h);
-        GET_LIN(b.cross_out_w,  lname("dec.blocks.%d.cross_attn.out.weight", i), dec_h, dec_h);
+        GET_F32(b.norm_cross_w, lname("dec.blocks.%d.norm_cross.weight", i), dec_h);
+        GET_LIN(b.cross_q_w, lname("dec.blocks.%d.cross_attn.q.weight", i), dec_h, dec_h);
+        GET_LIN(b.cross_k_w, lname("dec.blocks.%d.cross_attn.k.weight", i), dec_h, dec_h);
+        GET_LIN(b.cross_v_w, lname("dec.blocks.%d.cross_attn.v.weight", i), dec_h, dec_h);
+        GET_LIN(b.cross_out_w, lname("dec.blocks.%d.cross_attn.out.weight", i), dec_h, dec_h);
 
         // SwiGLU MLP (with biases). fc1 emits 2·ffn_dim.
         GET_F32(b.norm_ffn_w, lname("dec.blocks.%d.norm_ffn.weight", i), dec_h);
-        GET_LIN(b.ffn_fc1_w,  lname("dec.blocks.%d.ffn.fc1.weight",  i), dec_h,  2 * dec_ff);
-        GET_F32(b.ffn_fc1_b,  lname("dec.blocks.%d.ffn.fc1.bias",    i), 2 * dec_ff);
-        GET_LIN(b.ffn_fc2_w,  lname("dec.blocks.%d.ffn.fc2.weight",  i), dec_ff, dec_h);
-        GET_F32(b.ffn_fc2_b,  lname("dec.blocks.%d.ffn.fc2.bias",    i), dec_h);
+        GET_LIN(b.ffn_fc1_w, lname("dec.blocks.%d.ffn.fc1.weight", i), dec_h, 2 * dec_ff);
+        GET_F32(b.ffn_fc1_b, lname("dec.blocks.%d.ffn.fc1.bias", i), 2 * dec_ff);
+        GET_LIN(b.ffn_fc2_w, lname("dec.blocks.%d.ffn.fc2.weight", i), dec_ff, dec_h);
+        GET_F32(b.ffn_fc2_b, lname("dec.blocks.%d.ffn.fc2.bias", i), dec_h);
     }
 
     return TRANSCRIBE_OK;
@@ -430,4 +538,4 @@ transcribe_status build_moonshine_streaming_weights(ggml_context *
 #undef GET_CONV
 #undef GET_LIN
 
-} // namespace transcribe::moonshine_streaming
+}  // namespace transcribe::moonshine_streaming
diff --git a/src/arch/moonshine_streaming/weights.h b/src/arch/moonshine_streaming/weights.h
index e4a89add..f7e14f4f 100644
--- a/src/arch/moonshine_streaming/weights.h
+++ b/src/arch/moonshine_streaming/weights.h
@@ -51,29 +51,29 @@ namespace transcribe::moonshine_streaming {
 
 struct MoonshineStreamingHParams {
     // Encoder.
-    int32_t enc_n_layers     = 0;
-    int32_t enc_d_model      = 0;
-    int32_t enc_n_heads      = 0;
-    int32_t enc_n_kv_heads   = 0;   // streaming-tiny has no GQA: == n_heads
-    int32_t enc_head_dim     = 0;   // explicit head_dim in config
-    int32_t enc_ffn_dim      = 0;   // intermediate_size
-    std::string enc_activation;     // "gelu"
-    float   enc_frame_ms     = 0.0f;
-    int32_t enc_frame_len    = 0;   // = round(sample_rate * frame_ms / 1000)
+    int32_t              enc_n_layers   = 0;
+    int32_t              enc_d_model    = 0;
+    int32_t              enc_n_heads    = 0;
+    int32_t              enc_n_kv_heads = 0;  // streaming-tiny has no GQA: == n_heads
+    int32_t              enc_head_dim   = 0;  // explicit head_dim in config
+    int32_t              enc_ffn_dim    = 0;  // intermediate_size
+    std::string          enc_activation;      // "gelu"
+    float                enc_frame_ms  = 0.0f;
+    int32_t              enc_frame_len = 0;   // = round(sample_rate * frame_ms / 1000)
     // Flattened per-layer (left, right) windows: 2 ints per layer.
     std::vector<int32_t> enc_sliding_windows;
 
     // Decoder.
-    int32_t dec_n_layers     = 0;
-    int32_t dec_d_model      = 0;
-    int32_t dec_n_heads      = 0;
-    int32_t dec_n_kv_heads   = 0;
-    int32_t dec_head_dim     = 0;
-    int32_t dec_ffn_dim      = 0;
-    int32_t dec_max_position_embeddings = 0;
-    int32_t dec_vocab_size   = 0;
-    std::string dec_activation;     // "silu"
-    bool    dec_tie_word_embeddings = false;
+    int32_t     dec_n_layers                = 0;
+    int32_t     dec_d_model                 = 0;
+    int32_t     dec_n_heads                 = 0;
+    int32_t     dec_n_kv_heads              = 0;
+    int32_t     dec_head_dim                = 0;
+    int32_t     dec_ffn_dim                 = 0;
+    int32_t     dec_max_position_embeddings = 0;
+    int32_t     dec_vocab_size              = 0;
+    std::string dec_activation;  // "silu"
+    bool        dec_tie_word_embeddings = false;
 
     // Special tokens.
     int32_t bos_token_id           = -1;  // 1
@@ -88,15 +88,15 @@ struct MoonshineStreamingHParams {
     int32_t pad_head_dim_multiple = 0;
 
     // Frontend (raw waveform — converted to frames inside the encoder).
-    std::string fe_type;            // "raw"
-    int32_t     fe_sample_rate = 0; // 16000
+    std::string fe_type;             // "raw"
+    int32_t     fe_sample_rate = 0;  // 16000
 
     // CMVN epsilon (fixed at 1e-6 in the reference).
-    float   cmvn_eps              = 1e-6f;
+    float cmvn_eps = 1e-6f;
 
     // Adapter.
-    int32_t encoder_hidden_size = 0;     // mirrors enc_d_model; convenience read
-    bool    adapter_has_proj     = false;
+    int32_t encoder_hidden_size = 0;  // mirrors enc_d_model; convenience read
+    bool    adapter_has_proj    = false;
 
     // Capability flags.
     bool cap_lang_detect = false;
@@ -117,13 +117,18 @@ struct MoonshineStreamingHParams {
     int32_t enc_head_dim_padded() const {
         const int32_t hd = enc_head_dim;
         const int32_t m  = pad_head_dim_multiple;
-        if (m <= 0 || hd <= 0) return hd;
+        if (m <= 0 || hd <= 0) {
+            return hd;
+        }
         return ((hd + m - 1) / m) * m;
     }
+
     int32_t dec_head_dim_padded() const {
         const int32_t hd = dec_head_dim;
         const int32_t m  = pad_head_dim_multiple;
-        if (m <= 0 || hd <= 0) return hd;
+        if (m <= 0 || hd <= 0) {
+            return hd;
+        }
         return ((hd + m - 1) / m) * m;
     }
 
@@ -133,12 +138,11 @@ struct MoonshineStreamingHParams {
     int32_t dec_head_dim_rot() const {
         const int32_t hd = dec_head_dim;
         const int32_t r  = static_cast<int32_t>(static_cast<float>(hd) * partial_rotary_factor);
-        return r & ~int32_t{1};
+        return r & ~int32_t{ 1 };
     }
 };
 
-transcribe_status read_moonshine_streaming_hparams(const gguf_context *               gguf,
-                                                    MoonshineStreamingHParams &        hp);
+transcribe_status read_moonshine_streaming_hparams(const gguf_context * gguf, MoonshineStreamingHParams & hp);
 
 // ---------------------------------------------------------------------------
 // Weight slots
@@ -154,45 +158,45 @@ transcribe_status read_moonshine_streaming_hparams(const gguf_context *
 //   conv2.weight      [k=5, 2·hidden, hidden]
 //   conv2.bias        [hidden]
 struct MoonshineStreamingEmbedder {
-    ggml_tensor * comp_log_k    = nullptr;  // [1] f32 — learned scalar
-    ggml_tensor * linear_w      = nullptr;  // [frame_len, hidden] no bias
-    ggml_tensor * conv1_w       = nullptr;  // [5, hidden, 2·hidden]
-    ggml_tensor * conv1_b       = nullptr;  // [2·hidden]
-    ggml_tensor * conv2_w       = nullptr;  // [5, 2·hidden, hidden]
-    ggml_tensor * conv2_b       = nullptr;  // [hidden]
+    ggml_tensor * comp_log_k = nullptr;  // [1] f32 — learned scalar
+    ggml_tensor * linear_w   = nullptr;  // [frame_len, hidden] no bias
+    ggml_tensor * conv1_w    = nullptr;  // [5, hidden, 2·hidden]
+    ggml_tensor * conv1_b    = nullptr;  // [2·hidden]
+    ggml_tensor * conv2_w    = nullptr;  // [5, 2·hidden, hidden]
+    ggml_tensor * conv2_b    = nullptr;  // [hidden]
 };
 
 struct MoonshineStreamingEncTop {
-    ggml_tensor * final_norm_w  = nullptr;  // [hidden]  (pre-folded gain)
+    ggml_tensor * final_norm_w = nullptr;  // [hidden]  (pre-folded gain)
 };
 
 // One encoder transformer block. attention_bias=False on q/k/v/o.
 // LayerNorm scales are pre-folded (gain = original γ + 1.0).
 struct MoonshineStreamingEncBlock {
-    ggml_tensor * norm_attn_w   = nullptr;
-    ggml_tensor * attn_q_w      = nullptr;
-    ggml_tensor * attn_k_w      = nullptr;
-    ggml_tensor * attn_v_w      = nullptr;
-    ggml_tensor * attn_out_w    = nullptr;
-
-    ggml_tensor * norm_ffn_w    = nullptr;
-    ggml_tensor * ffn_fc1_w     = nullptr;  // [hidden, ffn_dim]
-    ggml_tensor * ffn_fc1_b     = nullptr;  // [ffn_dim]
-    ggml_tensor * ffn_fc2_w     = nullptr;  // [ffn_dim, hidden]
-    ggml_tensor * ffn_fc2_b     = nullptr;  // [hidden]
+    ggml_tensor * norm_attn_w = nullptr;
+    ggml_tensor * attn_q_w    = nullptr;
+    ggml_tensor * attn_k_w    = nullptr;
+    ggml_tensor * attn_v_w    = nullptr;
+    ggml_tensor * attn_out_w  = nullptr;
+
+    ggml_tensor * norm_ffn_w = nullptr;
+    ggml_tensor * ffn_fc1_w  = nullptr;  // [hidden, ffn_dim]
+    ggml_tensor * ffn_fc1_b  = nullptr;  // [ffn_dim]
+    ggml_tensor * ffn_fc2_w  = nullptr;  // [ffn_dim, hidden]
+    ggml_tensor * ffn_fc2_b  = nullptr;  // [hidden]
 };
 
 // Adapter: pos_emb add (+ proj when enc_hidden != dec_hidden).
 struct MoonshineStreamingAdapter {
-    ggml_tensor * pos_emb_w     = nullptr;  // [max_pos, enc_hidden] always present
-    ggml_tensor * proj_w        = nullptr;  // [enc_hidden, dec_hidden] optional
+    ggml_tensor * pos_emb_w = nullptr;  // [max_pos, enc_hidden] always present
+    ggml_tensor * proj_w    = nullptr;  // [enc_hidden, dec_hidden] optional
 };
 
 // Decoder top: untied embed + final LN + lm_head.
 struct MoonshineStreamingDecTop {
-    ggml_tensor * token_embd_w  = nullptr;  // [hidden, vocab]
-    ggml_tensor * final_norm_w  = nullptr;  // [hidden] (no offset trick)
-    ggml_tensor * lm_head_w     = nullptr;  // [hidden, vocab]  separate from token_embd
+    ggml_tensor * token_embd_w = nullptr;  // [hidden, vocab]
+    ggml_tensor * final_norm_w = nullptr;  // [hidden] (no offset trick)
+    ggml_tensor * lm_head_w    = nullptr;  // [hidden, vocab]  separate from token_embd
 };
 
 // One decoder block. q_proj/k_proj/v_proj from MoonshineStreamingAttention
@@ -200,38 +204,38 @@ struct MoonshineStreamingDecTop {
 // (line 603 of modeling). norm_self/norm_cross/norm_ffn are vanilla LN.
 struct MoonshineStreamingDecBlock {
     // Self-attention.
-    ggml_tensor * norm_self_w   = nullptr;
-    ggml_tensor * self_q_w      = nullptr;
-    ggml_tensor * self_k_w      = nullptr;
-    ggml_tensor * self_v_w      = nullptr;
-    ggml_tensor * self_out_w    = nullptr;
+    ggml_tensor * norm_self_w = nullptr;
+    ggml_tensor * self_q_w    = nullptr;
+    ggml_tensor * self_k_w    = nullptr;
+    ggml_tensor * self_v_w    = nullptr;
+    ggml_tensor * self_out_w  = nullptr;
 
     // Cross-attention (no RoPE).
-    ggml_tensor * norm_cross_w  = nullptr;
-    ggml_tensor * cross_q_w     = nullptr;
-    ggml_tensor * cross_k_w     = nullptr;
-    ggml_tensor * cross_v_w     = nullptr;
-    ggml_tensor * cross_out_w   = nullptr;
+    ggml_tensor * norm_cross_w = nullptr;
+    ggml_tensor * cross_q_w    = nullptr;
+    ggml_tensor * cross_k_w    = nullptr;
+    ggml_tensor * cross_v_w    = nullptr;
+    ggml_tensor * cross_out_w  = nullptr;
 
     // SwiGLU MLP (with biases).
-    ggml_tensor * norm_ffn_w    = nullptr;
-    ggml_tensor * ffn_fc1_w     = nullptr;  // [hidden, 2·ffn_dim]
-    ggml_tensor * ffn_fc1_b     = nullptr;  // [2·ffn_dim]
-    ggml_tensor * ffn_fc2_w     = nullptr;  // [ffn_dim, hidden]
-    ggml_tensor * ffn_fc2_b     = nullptr;  // [hidden]
+    ggml_tensor * norm_ffn_w = nullptr;
+    ggml_tensor * ffn_fc1_w  = nullptr;  // [hidden, 2·ffn_dim]
+    ggml_tensor * ffn_fc1_b  = nullptr;  // [2·ffn_dim]
+    ggml_tensor * ffn_fc2_w  = nullptr;  // [ffn_dim, hidden]
+    ggml_tensor * ffn_fc2_b  = nullptr;  // [hidden]
 };
 
 struct MoonshineStreamingWeights {
-    MoonshineStreamingEmbedder                     embedder;
-    MoonshineStreamingEncTop                       enc_top;
-    std::vector<MoonshineStreamingEncBlock>        enc_blocks;
-    MoonshineStreamingAdapter                      adapter;
-    MoonshineStreamingDecTop                       dec_top;
-    std::vector<MoonshineStreamingDecBlock>        dec_blocks;
+    MoonshineStreamingEmbedder              embedder;
+    MoonshineStreamingEncTop                enc_top;
+    std::vector<MoonshineStreamingEncBlock> enc_blocks;
+    MoonshineStreamingAdapter               adapter;
+    MoonshineStreamingDecTop                dec_top;
+    std::vector<MoonshineStreamingDecBlock> dec_blocks;
 };
 
-transcribe_status build_moonshine_streaming_weights(ggml_context *                      ctx_meta,
-                                                     const MoonshineStreamingHParams &  hp,
-                                                     MoonshineStreamingWeights &        weights);
+transcribe_status build_moonshine_streaming_weights(ggml_context *                    ctx_meta,
+                                                    const MoonshineStreamingHParams & hp,
+                                                    MoonshineStreamingWeights &       weights);
 
-} // namespace transcribe::moonshine_streaming
+}  // namespace transcribe::moonshine_streaming
diff --git a/src/arch/parakeet/capabilities.cpp b/src/arch/parakeet/capabilities.cpp
index e7d20b9a..d9d0fda2 100644
--- a/src/arch/parakeet/capabilities.cpp
+++ b/src/arch/parakeet/capabilities.cpp
@@ -32,4 +32,4 @@ void apply_family_invariants(transcribe_model & model) {
     transcribe::set_feature(&model, TRANSCRIBE_FEATURE_CANCELLATION, true);
 }
 
-} // namespace transcribe::parakeet
+}  // namespace transcribe::parakeet
diff --git a/src/arch/parakeet/decoder.cpp b/src/arch/parakeet/decoder.cpp
index 99524065..c020ef60 100644
--- a/src/arch/parakeet/decoder.cpp
+++ b/src/arch/parakeet/decoder.cpp
@@ -14,29 +14,28 @@
 #include "decoder.h"
 
 #include "parakeet.h"
-#include "weights.h"
-
 #include "transcribe-batch-util.h"
 #include "transcribe-debug.h"
 #include "transcribe-log.h"
+#include "weights.h"
 
 // ggml-backend.h, not ggml-cpu.h: under GGML_BACKEND_DL the CPU backend
 // is a loadable module, so backend-specific entry points must be reached
 // through the registry (ggml_backend_init_by_type / get_proc_address),
 // never by direct link-time reference.
-#include "ggml.h"
-#include "ggml-backend.h"
 #include "ggml-alloc.h"
-#include "ggml-cpu.h"   // ggml_threadpool_params_default (rest via registry)
+#include "ggml-backend.h"
+#include "ggml-cpu.h"  // ggml_threadpool_params_default (rest via registry)
+#include "ggml.h"
 
 #include <thread>
 
 #if TRANSCRIBE_HAS_BLAS
-#  ifdef __APPLE__
-#    include <Accelerate/Accelerate.h>
-#  else
-#    include <cblas.h>
-#  endif
+#    ifdef __APPLE__
+#        include <Accelerate/Accelerate.h>
+#    else
+#        include <cblas.h>
+#    endif
 #endif
 
 #include <algorithm>
@@ -61,24 +60,20 @@ namespace {
 // Q*/IQ*). ggml_backend_tensor_get is universal (memcpy on host buffers,
 // readback on discrete GPUs); we stage the raw bytes then materialize
 // fp32 in `out`. Returns false on missing-trait / size errors.
-bool read_tensor_to_f32(const ggml_tensor * t,
-                        std::vector<float> & out)
-{
+bool read_tensor_to_f32(const ggml_tensor * t, std::vector<float> & out) {
     if (t == nullptr) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "parakeet decoder: read_tensor_to_f32: null tensor");
         return false;
     }
     const size_t nbytes = ggml_nbytes(t);
     if (nbytes == 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "parakeet decoder: tensor \"%s\" has 0 bytes", t->name);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "parakeet decoder: tensor \"%s\" has 0 bytes", t->name);
         return false;
     }
     const int64_t nelem = ggml_nelements(t);
     if (nelem <= 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "parakeet decoder: tensor \"%s\" has nelem=%lld",
-                     t->name, static_cast<long long>(nelem));
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "parakeet decoder: tensor \"%s\" has nelem=%lld", t->name,
+                static_cast<long long>(nelem));
         return false;
     }
 
@@ -89,10 +84,9 @@ bool read_tensor_to_f32(const ggml_tensor * t,
     if (t->type == GGML_TYPE_F32) {
         if (nbytes != static_cast<size_t>(nelem) * sizeof(float)) {
             log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "parakeet decoder: tensor \"%s\" f32 nbytes %zu "
-                         "!= nelem*sizeof(float) %zu",
-                         t->name, nbytes,
-                         static_cast<size_t>(nelem) * sizeof(float));
+                    "parakeet decoder: tensor \"%s\" f32 nbytes %zu "
+                    "!= nelem*sizeof(float) %zu",
+                    t->name, nbytes, static_cast<size_t>(nelem) * sizeof(float));
             return false;
         }
         ggml_backend_tensor_get(t, out.data(), 0, nbytes);
@@ -103,9 +97,8 @@ bool read_tensor_to_f32(const ggml_tensor * t,
     // then walk the type's to_float to materialize fp32.
     const auto * tt = ggml_get_type_traits(t->type);
     if (tt == nullptr || tt->to_float == nullptr) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "parakeet decoder: tensor \"%s\" type %s has no to_float",
-                     t->name, ggml_type_name(t->type));
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "parakeet decoder: tensor \"%s\" type %s has no to_float", t->name,
+                ggml_type_name(t->type));
         return false;
     }
 
@@ -125,12 +118,25 @@ bool build_joint_weight(HostJoint & j, const ggml_tensor * src_out_w) {
     const int joint_n = j.joint_n;
 
     auto fail = [&]() -> bool {
-        if (j.w_buf     != nullptr) { ggml_backend_buffer_free(j.w_buf); j.w_buf = nullptr; }
-        if (j.w_ctx     != nullptr) { ggml_free(j.w_ctx);                j.w_ctx = nullptr; }
-        if (j.w_backend != nullptr) { ggml_backend_free(j.w_backend);    j.w_backend = nullptr; }
-        j.g_enc_w = nullptr; j.g_enc_b = nullptr;
-        j.g_pred_w = nullptr; j.g_pred_b = nullptr;
-        j.gw_w = nullptr; j.gw_b = nullptr; j.w_ready = false;
+        if (j.w_buf != nullptr) {
+            ggml_backend_buffer_free(j.w_buf);
+            j.w_buf = nullptr;
+        }
+        if (j.w_ctx != nullptr) {
+            ggml_free(j.w_ctx);
+            j.w_ctx = nullptr;
+        }
+        if (j.w_backend != nullptr) {
+            ggml_backend_free(j.w_backend);
+            j.w_backend = nullptr;
+        }
+        j.g_enc_w  = nullptr;
+        j.g_enc_b  = nullptr;
+        j.g_pred_w = nullptr;
+        j.g_pred_b = nullptr;
+        j.gw_w     = nullptr;
+        j.gw_b     = nullptr;
+        j.w_ready  = false;
         return false;
     };
 
@@ -142,35 +148,41 @@ bool build_joint_weight(HostJoint & j, const ggml_tensor * src_out_w) {
         return fail();
     }
 
-    ggml_init_params ip {};
+    ggml_init_params ip{};
     ip.mem_size   = ggml_tensor_overhead() * 8;
     ip.mem_buffer = nullptr;
     ip.no_alloc   = true;
-    j.w_ctx = ggml_init(ip);
-    if (j.w_ctx == nullptr) return fail();
+    j.w_ctx       = ggml_init(ip);
+    if (j.w_ctx == nullptr) {
+        return fail();
+    }
 
-    j.g_enc_w  = ggml_new_tensor_2d(j.w_ctx, GGML_TYPE_F32, j.d_enc,       joint_h);
+    j.g_enc_w  = ggml_new_tensor_2d(j.w_ctx, GGML_TYPE_F32, j.d_enc, joint_h);
     j.g_enc_b  = ggml_new_tensor_1d(j.w_ctx, GGML_TYPE_F32, joint_h);
     j.g_pred_w = ggml_new_tensor_2d(j.w_ctx, GGML_TYPE_F32, j.pred_hidden, joint_h);
     j.g_pred_b = ggml_new_tensor_1d(j.w_ctx, GGML_TYPE_F32, joint_h);
-    j.gw_w     = ggml_new_tensor_2d(j.w_ctx, GGML_TYPE_F32, joint_h,       joint_n);
+    j.gw_w     = ggml_new_tensor_2d(j.w_ctx, GGML_TYPE_F32, joint_h, joint_n);
     j.gw_b     = ggml_new_tensor_1d(j.w_ctx, GGML_TYPE_F32, joint_n);
 
     j.w_buf = ggml_backend_alloc_ctx_tensors(j.w_ctx, j.w_backend);
-    if (j.w_buf == nullptr) return fail();
+    if (j.w_buf == nullptr) {
+        return fail();
+    }
 
     // out_w: dequantize the model tensor to fp32 once.
     {
         std::vector<float> tmp;
-        if (!read_tensor_to_f32(src_out_w, tmp)) return fail();
+        if (!read_tensor_to_f32(src_out_w, tmp)) {
+            return fail();
+        }
         ggml_backend_tensor_set(j.gw_w, tmp.data(), 0, tmp.size() * sizeof(float));
     }
     // The rest come from the host mirrors.
-    ggml_backend_tensor_set(j.g_enc_w,  j.enc_w.data(),  0, j.enc_w.size()  * sizeof(float));
-    ggml_backend_tensor_set(j.g_enc_b,  j.enc_b.data(),  0, j.enc_b.size()  * sizeof(float));
+    ggml_backend_tensor_set(j.g_enc_w, j.enc_w.data(), 0, j.enc_w.size() * sizeof(float));
+    ggml_backend_tensor_set(j.g_enc_b, j.enc_b.data(), 0, j.enc_b.size() * sizeof(float));
     ggml_backend_tensor_set(j.g_pred_w, j.pred_w.data(), 0, j.pred_w.size() * sizeof(float));
     ggml_backend_tensor_set(j.g_pred_b, j.pred_b.data(), 0, j.pred_b.size() * sizeof(float));
-    ggml_backend_tensor_set(j.gw_b,     j.out_b.data(),  0, j.out_b.size()  * sizeof(float));
+    ggml_backend_tensor_set(j.gw_b, j.out_b.data(), 0, j.out_b.size() * sizeof(float));
 
     // Host mirrors are now resident in ggml — release them (load-time scratch).
     std::vector<float>().swap(j.enc_w);
@@ -192,13 +204,28 @@ bool build_pred_weights(HostPredictor & p) {
     const int H      = p.pred_hidden;
     const int four_H = 4 * H;
     const int L      = static_cast<int>(p.lstm.size());
-    if (L == 0 || H == 0) return false;
+    if (L == 0 || H == 0) {
+        return false;
+    }
 
     auto fail = [&]() -> bool {
-        if (p.lstm_w_buf     != nullptr) { ggml_backend_buffer_free(p.lstm_w_buf); p.lstm_w_buf = nullptr; }
-        if (p.lstm_w_ctx     != nullptr) { ggml_free(p.lstm_w_ctx);                p.lstm_w_ctx = nullptr; }
-        if (p.lstm_w_backend != nullptr) { ggml_backend_free(p.lstm_w_backend);    p.lstm_w_backend = nullptr; }
-        for (auto & lh : p.lstm) { lh.g_Wx = nullptr; lh.g_Wh = nullptr; lh.g_b = nullptr; }
+        if (p.lstm_w_buf != nullptr) {
+            ggml_backend_buffer_free(p.lstm_w_buf);
+            p.lstm_w_buf = nullptr;
+        }
+        if (p.lstm_w_ctx != nullptr) {
+            ggml_free(p.lstm_w_ctx);
+            p.lstm_w_ctx = nullptr;
+        }
+        if (p.lstm_w_backend != nullptr) {
+            ggml_backend_free(p.lstm_w_backend);
+            p.lstm_w_backend = nullptr;
+        }
+        for (auto & lh : p.lstm) {
+            lh.g_Wx = nullptr;
+            lh.g_Wh = nullptr;
+            lh.g_b  = nullptr;
+        }
         p.lstm_ready = false;
         return false;
     };
@@ -210,28 +237,32 @@ bool build_pred_weights(HostPredictor & p) {
         return fail();
     }
 
-    ggml_init_params ip {};
+    ggml_init_params ip{};
     ip.mem_size   = ggml_tensor_overhead() * static_cast<size_t>(L * 3 + 1);
     ip.mem_buffer = nullptr;
     ip.no_alloc   = true;
-    p.lstm_w_ctx = ggml_init(ip);
-    if (p.lstm_w_ctx == nullptr) return fail();
+    p.lstm_w_ctx  = ggml_init(ip);
+    if (p.lstm_w_ctx == nullptr) {
+        return fail();
+    }
 
     for (int l = 0; l < L; ++l) {
         auto & lh = p.lstm[l];
-        lh.g_Wx = ggml_new_tensor_2d(p.lstm_w_ctx, GGML_TYPE_F32, H, four_H);
-        lh.g_Wh = ggml_new_tensor_2d(p.lstm_w_ctx, GGML_TYPE_F32, H, four_H);
-        lh.g_b  = ggml_new_tensor_1d(p.lstm_w_ctx, GGML_TYPE_F32, four_H);
+        lh.g_Wx   = ggml_new_tensor_2d(p.lstm_w_ctx, GGML_TYPE_F32, H, four_H);
+        lh.g_Wh   = ggml_new_tensor_2d(p.lstm_w_ctx, GGML_TYPE_F32, H, four_H);
+        lh.g_b    = ggml_new_tensor_1d(p.lstm_w_ctx, GGML_TYPE_F32, four_H);
     }
 
     p.lstm_w_buf = ggml_backend_alloc_ctx_tensors(p.lstm_w_ctx, p.lstm_w_backend);
-    if (p.lstm_w_buf == nullptr) return fail();
+    if (p.lstm_w_buf == nullptr) {
+        return fail();
+    }
 
     for (int l = 0; l < L; ++l) {
         auto & lh = p.lstm[l];
         ggml_backend_tensor_set(lh.g_Wx, lh.Wx.data(), 0, lh.Wx.size() * sizeof(float));
         ggml_backend_tensor_set(lh.g_Wh, lh.Wh.data(), 0, lh.Wh.size() * sizeof(float));
-        ggml_backend_tensor_set(lh.g_b,  lh.b.data(),  0, lh.b.size()  * sizeof(float));
+        ggml_backend_tensor_set(lh.g_b, lh.b.data(), 0, lh.b.size() * sizeof(float));
         // Host mirrors now resident in ggml — release them.
         std::vector<float>().swap(lh.Wx);
         std::vector<float>().swap(lh.Wh);
@@ -242,7 +273,7 @@ bool build_pred_weights(HostPredictor & p) {
     return true;
 }
 
-} // namespace
+}  // namespace
 
 // Per-call joint compute graph (the mutable half of the joint network):
 //   pred_proj = pred_w @ pred_in + pred_b      [joint_h]
@@ -258,20 +289,26 @@ namespace {
 
 struct JointGraph {
     ggml_context *        ctx     = nullptr;
-    ggml_backend_t        backend = nullptr; // BORROWED (PredGraph's); NOT freed here
+    ggml_backend_t        backend = nullptr;  // BORROWED (PredGraph's); NOT freed here
     ggml_backend_buffer_t buf     = nullptr;
     ggml_cgraph *         graph   = nullptr;
-    ggml_tensor *         pred_in = nullptr; // [pred_hidden] fp32 input (decoder out)
-    ggml_tensor *         enc_in  = nullptr; // [joint_h] fp32 input (enc_proj frame)
-    ggml_tensor *         logits  = nullptr; // [joint_n] fp32 output
+    ggml_tensor *         pred_in = nullptr;  // [pred_hidden] fp32 input (decoder out)
+    ggml_tensor *         enc_in  = nullptr;  // [joint_h] fp32 input (enc_proj frame)
+    ggml_tensor *         logits  = nullptr;  // [joint_n] fp32 output
     bool                  ready   = false;
 
     JointGraph() = default;
+
     ~JointGraph() {
-        if (buf != nullptr) ggml_backend_buffer_free(buf);
-        if (ctx != nullptr) ggml_free(ctx);
+        if (buf != nullptr) {
+            ggml_backend_buffer_free(buf);
+        }
+        if (ctx != nullptr) {
+            ggml_free(ctx);
+        }
         // backend is borrowed from PredGraph — do NOT free here.
     }
+
     JointGraph(const JointGraph &)             = delete;
     JointGraph & operator=(const JointGraph &) = delete;
 };
@@ -280,26 +317,40 @@ struct JointGraph {
 // Returns false if the resident weights are absent or any ggml step
 // fails (→ hard decode error).
 bool build_joint_graph(JointGraph & g, const HostJoint & j, ggml_backend_t backend) {
-    if (backend == nullptr) return false;
-    if (!j.w_ready || j.gw_w == nullptr || j.gw_b == nullptr ||
-        j.g_pred_w == nullptr || j.g_pred_b == nullptr) return false;
+    if (backend == nullptr) {
+        return false;
+    }
+    if (!j.w_ready || j.gw_w == nullptr || j.gw_b == nullptr || j.g_pred_w == nullptr || j.g_pred_b == nullptr) {
+        return false;
+    }
 
-    g.backend = backend; // borrowed
+    g.backend = backend;  // borrowed
 
     auto fail = [&]() -> bool {
-        if (g.buf != nullptr) { ggml_backend_buffer_free(g.buf); g.buf = nullptr; }
-        if (g.ctx != nullptr) { ggml_free(g.ctx);                g.ctx = nullptr; }
-        g.pred_in = nullptr; g.enc_in = nullptr; g.logits = nullptr;
-        g.graph = nullptr; g.ready = false;
+        if (g.buf != nullptr) {
+            ggml_backend_buffer_free(g.buf);
+            g.buf = nullptr;
+        }
+        if (g.ctx != nullptr) {
+            ggml_free(g.ctx);
+            g.ctx = nullptr;
+        }
+        g.pred_in = nullptr;
+        g.enc_in  = nullptr;
+        g.logits  = nullptr;
+        g.graph   = nullptr;
+        g.ready   = false;
         return false;
     };
 
-    ggml_init_params ip {};
+    ggml_init_params ip{};
     ip.mem_size   = ggml_tensor_overhead() * 16 + ggml_graph_overhead();
     ip.mem_buffer = nullptr;
     ip.no_alloc   = true;
-    g.ctx = ggml_init(ip);
-    if (g.ctx == nullptr) return fail();
+    g.ctx         = ggml_init(ip);
+    if (g.ctx == nullptr) {
+        return fail();
+    }
 
     g.pred_in = ggml_new_tensor_1d(g.ctx, GGML_TYPE_F32, j.pred_hidden);
     ggml_set_input(g.pred_in);
@@ -307,26 +358,27 @@ bool build_joint_graph(JointGraph & g, const HostJoint & j, ggml_backend_t backe
     ggml_set_input(g.enc_in);
 
     // pred_proj = pred_w @ pred_in + pred_b   [joint_h]
-    ggml_tensor * pred_proj = ggml_add(g.ctx,
-        ggml_mul_mat(g.ctx, j.g_pred_w, g.pred_in), j.g_pred_b);
+    ggml_tensor * pred_proj = ggml_add(g.ctx, ggml_mul_mat(g.ctx, j.g_pred_w, g.pred_in), j.g_pred_b);
     // summed = enc_proj + pred_proj           [joint_h]
-    ggml_tensor * summed = ggml_add(g.ctx, g.enc_in, pred_proj);
+    ggml_tensor * summed    = ggml_add(g.ctx, g.enc_in, pred_proj);
     // activation — loader allow-list guarantees exactly one of relu/sigmoid/tanh.
     ggml_tensor * activated;
     if (j.activation == "relu") {
         activated = ggml_relu(g.ctx, summed);
     } else if (j.activation == "sigmoid") {
         activated = ggml_sigmoid(g.ctx, summed);
-    } else { // "tanh"
+    } else {  // "tanh"
         activated = ggml_tanh(g.ctx, summed);
     }
     // logits = out_w @ activated + out_b      [joint_n]
     ggml_tensor * mm = ggml_mul_mat(g.ctx, j.gw_w, activated);
-    g.logits = ggml_add(g.ctx, mm, j.gw_b);
+    g.logits         = ggml_add(g.ctx, mm, j.gw_b);
     ggml_set_output(g.logits);
 
     g.buf = ggml_backend_alloc_ctx_tensors(g.ctx, g.backend);
-    if (g.buf == nullptr) return fail();
+    if (g.buf == nullptr) {
+        return fail();
+    }
 
     g.graph = ggml_new_graph(g.ctx);
     ggml_build_forward_expand(g.graph, g.logits);
@@ -338,19 +390,21 @@ bool build_joint_graph(JointGraph & g, const HostJoint & j, ggml_backend_t backe
 // the library stays DL-safe (under GGML_BACKEND_DL these symbols are not
 // directly linkable). Resolved via ggml_backend_reg_get_proc_address.
 typedef ggml_threadpool_t (*pfn_threadpool_new)(ggml_threadpool_params *);
-typedef void              (*pfn_threadpool_free)(ggml_threadpool_t);
-typedef void              (*pfn_set_threadpool)(ggml_backend_t, ggml_threadpool_t);
+typedef void (*pfn_threadpool_free)(ggml_threadpool_t);
+typedef void (*pfn_set_threadpool)(ggml_backend_t, ggml_threadpool_t);
 
 static void * cpu_backend_proc(ggml_backend_t backend, const char * name) {
     ggml_backend_dev_t dev = backend != nullptr ? ggml_backend_get_device(backend) : nullptr;
-    ggml_backend_reg_t reg = dev     != nullptr ? ggml_backend_dev_backend_reg(dev) : nullptr;
+    ggml_backend_reg_t reg = dev != nullptr ? ggml_backend_dev_backend_reg(dev) : nullptr;
     return reg != nullptr ? ggml_backend_reg_get_proc_address(reg, name) : nullptr;
 }
 
 // Free a CPU-backend threadpool via the registry. Resolving the free fn needs
 // the backend alive, so callers must invoke this BEFORE freeing the backend.
 static void free_cpu_threadpool(ggml_backend_t backend, ggml_threadpool_t tp) {
-    if (tp == nullptr || backend == nullptr) return;
+    if (tp == nullptr || backend == nullptr) {
+        return;
+    }
     if (auto fn = (pfn_threadpool_free) cpu_backend_proc(backend, "ggml_threadpool_free")) {
         fn(tp);
     }
@@ -368,22 +422,30 @@ struct PredGraph {
     ggml_backend_buffer_t      buf     = nullptr;
     ggml_cgraph *              graph   = nullptr;
     ggml_threadpool_t          tp      = nullptr;
-    ggml_tensor *              x       = nullptr; // [H] input embedding
-    std::vector<ggml_tensor *> ph;                // [H] prev hidden per layer (input)
-    std::vector<ggml_tensor *> pc;                // [H] prev cell   per layer (input)
-    std::vector<ggml_tensor *> nh;                // [H] new  hidden per layer (output)
-    std::vector<ggml_tensor *> nc;                // [H] new  cell   per layer (output)
-    int  H = 0;
-    int  L = 0;
-    bool ready = false;
+    ggml_tensor *              x       = nullptr;  // [H] input embedding
+    std::vector<ggml_tensor *> ph;                 // [H] prev hidden per layer (input)
+    std::vector<ggml_tensor *> pc;                 // [H] prev cell   per layer (input)
+    std::vector<ggml_tensor *> nh;                 // [H] new  hidden per layer (output)
+    std::vector<ggml_tensor *> nc;                 // [H] new  cell   per layer (output)
+    int                        H     = 0;
+    int                        L     = 0;
+    bool                       ready = false;
 
     PredGraph() = default;
+
     ~PredGraph() {
-        if (buf != nullptr) ggml_backend_buffer_free(buf);
-        if (ctx != nullptr) ggml_free(ctx);
-        free_cpu_threadpool(backend, tp); // before ggml_backend_free(backend)
-        if (backend != nullptr) ggml_backend_free(backend);
+        if (buf != nullptr) {
+            ggml_backend_buffer_free(buf);
+        }
+        if (ctx != nullptr) {
+            ggml_free(ctx);
+        }
+        free_cpu_threadpool(backend, tp);  // before ggml_backend_free(backend)
+        if (backend != nullptr) {
+            ggml_backend_free(backend);
+        }
     }
+
     PredGraph(const PredGraph &)             = delete;
     PredGraph & operator=(const PredGraph &) = delete;
 };
@@ -392,31 +454,53 @@ struct PredGraph {
 // Returns false if the resident weights are absent or any ggml step fails
 // (→ hard decode error). n_threads is the resolved (>0) thread count.
 bool build_pred_graph(PredGraph & g, const HostPredictor & p, int n_threads) {
-    if (!p.lstm_ready) return false;
+    if (!p.lstm_ready) {
+        return false;
+    }
     const int H = p.pred_hidden;
     const int L = static_cast<int>(p.lstm.size());
-    if (H == 0 || L == 0) return false;
+    if (H == 0 || L == 0) {
+        return false;
+    }
 
     auto fail = [&]() -> bool {
-        if (g.buf != nullptr) { ggml_backend_buffer_free(g.buf); g.buf = nullptr; }
-        if (g.ctx != nullptr) { ggml_free(g.ctx);                g.ctx = nullptr; }
-        free_cpu_threadpool(g.backend, g.tp); g.tp = nullptr; // before freeing backend
-        if (g.backend != nullptr) { ggml_backend_free(g.backend); g.backend = nullptr; }
-        g.x = nullptr; g.graph = nullptr; g.ready = false;
-        g.ph.clear(); g.pc.clear(); g.nh.clear(); g.nc.clear();
+        if (g.buf != nullptr) {
+            ggml_backend_buffer_free(g.buf);
+            g.buf = nullptr;
+        }
+        if (g.ctx != nullptr) {
+            ggml_free(g.ctx);
+            g.ctx = nullptr;
+        }
+        free_cpu_threadpool(g.backend, g.tp);
+        g.tp = nullptr;  // before freeing backend
+        if (g.backend != nullptr) {
+            ggml_backend_free(g.backend);
+            g.backend = nullptr;
+        }
+        g.x     = nullptr;
+        g.graph = nullptr;
+        g.ready = false;
+        g.ph.clear();
+        g.pc.clear();
+        g.nh.clear();
+        g.nc.clear();
         return false;
     };
 
-    g.H = H; g.L = L;
+    g.H = H;
+    g.L = L;
 
     g.backend = ggml_backend_init_by_type(GGML_BACKEND_DEVICE_TYPE_CPU, nullptr);
-    if (g.backend == nullptr) return fail();
+    if (g.backend == nullptr) {
+        return fail();
+    }
     if (ggml_backend_dev_t dev = ggml_backend_get_device(g.backend)) {
-        auto set_n_threads = (ggml_backend_set_n_threads_t)
-            ggml_backend_reg_get_proc_address(
-                ggml_backend_dev_backend_reg(dev),
-                "ggml_backend_set_n_threads");
-        if (set_n_threads != nullptr) set_n_threads(g.backend, std::max(1, n_threads));
+        auto set_n_threads = (ggml_backend_set_n_threads_t) ggml_backend_reg_get_proc_address(
+            ggml_backend_dev_backend_reg(dev), "ggml_backend_set_n_threads");
+        if (set_n_threads != nullptr) {
+            set_n_threads(g.backend, std::max(1, n_threads));
+        }
     }
     // Persistent threadpool so the per-step graph_compute reuses workers instead
     // of spawning a transient pool each call. ggml's default hybrid-polling
@@ -428,20 +512,24 @@ bool build_pred_graph(PredGraph & g, const HostPredictor & p, int n_threads) {
         auto tp_set = (pfn_set_threadpool) cpu_backend_proc(g.backend, "ggml_backend_cpu_set_threadpool");
         if (tp_new != nullptr && tp_set != nullptr) {
             ggml_threadpool_params tpp = ggml_threadpool_params_default(std::max(1, n_threads));
-            g.tp = tp_new(&tpp);
-            if (g.tp != nullptr) tp_set(g.backend, g.tp);
+            g.tp                       = tp_new(&tpp);
+            if (g.tp != nullptr) {
+                tp_set(g.backend, g.tp);
+            }
         }
         // If unresolved (non-CPU exotic backend), g.tp stays null and each
         // graph_compute spawns a transient pool — correct, just less tuned.
     }
 
-    ggml_init_params ip {};
+    ggml_init_params ip{};
     // ~17 op nodes/layer + (1 + 2L) input tensors; generous headroom.
     ip.mem_size   = ggml_tensor_overhead() * static_cast<size_t>(32 * L + 16) + ggml_graph_overhead();
     ip.mem_buffer = nullptr;
     ip.no_alloc   = true;
-    g.ctx = ggml_init(ip);
-    if (g.ctx == nullptr) return fail();
+    g.ctx         = ggml_init(ip);
+    if (g.ctx == nullptr) {
+        return fail();
+    }
 
     g.x = ggml_new_tensor_1d(g.ctx, GGML_TYPE_F32, H);
     ggml_set_input(g.x);
@@ -450,31 +538,29 @@ bool build_pred_graph(PredGraph & g, const HostPredictor & p, int n_threads) {
     g.nh.assign(static_cast<size_t>(L), nullptr);
     g.nc.assign(static_cast<size_t>(L), nullptr);
     for (int l = 0; l < L; ++l) {
-        g.ph[l] = ggml_new_tensor_1d(g.ctx, GGML_TYPE_F32, H); ggml_set_input(g.ph[l]);
-        g.pc[l] = ggml_new_tensor_1d(g.ctx, GGML_TYPE_F32, H); ggml_set_input(g.pc[l]);
+        g.ph[l] = ggml_new_tensor_1d(g.ctx, GGML_TYPE_F32, H);
+        ggml_set_input(g.ph[l]);
+        g.pc[l] = ggml_new_tensor_1d(g.ctx, GGML_TYPE_F32, H);
+        ggml_set_input(g.pc[l]);
     }
 
     // gates = Wx@x + Wh@h_prev + b; split [i,f,g,o]; c' = f*c + i*g; h' = o*tanh(c').
     // Gate order [i, f, g, o] (PyTorch standard).
     ggml_tensor * in = g.x;
     for (int l = 0; l < L; ++l) {
-        const auto & lh = p.lstm[static_cast<size_t>(l)];
-        ggml_tensor * gates = ggml_add(g.ctx,
-            ggml_add(g.ctx,
-                ggml_mul_mat(g.ctx, lh.g_Wx, in),
-                ggml_mul_mat(g.ctx, lh.g_Wh, g.ph[l])),
-            lh.g_b); // [4H]
+        const auto &  lh = p.lstm[static_cast<size_t>(l)];
+        ggml_tensor * gates =
+            ggml_add(g.ctx, ggml_add(g.ctx, ggml_mul_mat(g.ctx, lh.g_Wx, in), ggml_mul_mat(g.ctx, lh.g_Wh, g.ph[l])),
+                     lh.g_b);  // [4H]
         auto part = [&](int k) {
             return ggml_view_1d(g.ctx, gates, H,
                                 static_cast<size_t>(k) * static_cast<size_t>(H) * ggml_element_size(gates));
         };
         ggml_tensor * i_ = ggml_sigmoid(g.ctx, part(0));
         ggml_tensor * f_ = ggml_sigmoid(g.ctx, part(1));
-        ggml_tensor * gg = ggml_tanh   (g.ctx, part(2));
+        ggml_tensor * gg = ggml_tanh(g.ctx, part(2));
         ggml_tensor * o_ = ggml_sigmoid(g.ctx, part(3));
-        g.nc[l] = ggml_add(g.ctx,
-            ggml_mul(g.ctx, f_, g.pc[l]),
-            ggml_mul(g.ctx, i_, gg));
+        g.nc[l]          = ggml_add(g.ctx, ggml_mul(g.ctx, f_, g.pc[l]), ggml_mul(g.ctx, i_, gg));
         ggml_set_output(g.nc[l]);
         g.nh[l] = ggml_mul(g.ctx, o_, ggml_tanh(g.ctx, g.nc[l]));
         ggml_set_output(g.nh[l]);
@@ -482,7 +568,9 @@ bool build_pred_graph(PredGraph & g, const HostPredictor & p, int n_threads) {
     }
 
     g.buf = ggml_backend_alloc_ctx_tensors(g.ctx, g.backend);
-    if (g.buf == nullptr) return fail();
+    if (g.buf == nullptr) {
+        return fail();
+    }
 
     g.graph = ggml_new_graph(g.ctx);
     for (int l = 0; l < L; ++l) {
@@ -493,40 +581,54 @@ bool build_pred_graph(PredGraph & g, const HostPredictor & p, int n_threads) {
     return true;
 }
 
-} // namespace
+}  // namespace
 
 HostJoint::~HostJoint() {
-    if (w_buf     != nullptr) ggml_backend_buffer_free(w_buf);
-    if (w_ctx     != nullptr) ggml_free(w_ctx);
-    if (w_backend != nullptr) ggml_backend_free(w_backend);
+    if (w_buf != nullptr) {
+        ggml_backend_buffer_free(w_buf);
+    }
+    if (w_ctx != nullptr) {
+        ggml_free(w_ctx);
+    }
+    if (w_backend != nullptr) {
+        ggml_backend_free(w_backend);
+    }
 }
 
 HostPredictor::~HostPredictor() {
-    if (lstm_w_buf     != nullptr) ggml_backend_buffer_free(lstm_w_buf);
-    if (lstm_w_ctx     != nullptr) ggml_free(lstm_w_ctx);
-    if (lstm_w_backend != nullptr) ggml_backend_free(lstm_w_backend);
+    if (lstm_w_buf != nullptr) {
+        ggml_backend_buffer_free(lstm_w_buf);
+    }
+    if (lstm_w_ctx != nullptr) {
+        ggml_free(lstm_w_ctx);
+    }
+    if (lstm_w_backend != nullptr) {
+        ggml_backend_free(lstm_w_backend);
+    }
 }
 
 // Resolve a decode thread count: n_threads <= 0 means "auto" →
 // default_n_threads() (min(8, usable cpus)), matching the encoder.
 static int resolve_decode_threads(int n_threads) {
-    return n_threads > 0
-        ? n_threads
-        : transcribe::default_n_threads();
+    return n_threads > 0 ? n_threads : transcribe::default_n_threads();
 }
 
-transcribe_status build_host_decoder_weights(const ParakeetModel & model,
-                                             HostDecoderWeights &  out)
-{
-    const ParakeetHParams &  hp = model.hparams;
-    const ParakeetWeights &  w  = model.weights;
+transcribe_status build_host_decoder_weights(const ParakeetModel & model, HostDecoderWeights & out) {
+    const ParakeetHParams & hp = model.hparams;
+    const ParakeetWeights & w  = model.weights;
 
     // Head-kind dispatch. CTC skips predictor/joint entirely; RNNT and
     // TDT share the predictor + joint mirror code below.
     switch (hp.head_kind) {
-        case HeadKind::TDT:  out.head_kind = HostHeadKind::TDT;  break;
-        case HeadKind::RNNT: out.head_kind = HostHeadKind::RNNT; break;
-        case HeadKind::CTC:  out.head_kind = HostHeadKind::CTC;  break;
+        case HeadKind::TDT:
+            out.head_kind = HostHeadKind::TDT;
+            break;
+        case HeadKind::RNNT:
+            out.head_kind = HostHeadKind::RNNT;
+            break;
+        case HeadKind::CTC:
+            out.head_kind = HostHeadKind::CTC;
+            break;
     }
 
     if (hp.head_kind == HeadKind::CTC) {
@@ -535,7 +637,7 @@ transcribe_status build_host_decoder_weights(const ParakeetModel & model,
         // [n_classes, d_model] as the host decoder consumes them. Bias is
         // [n_classes].
         out.ctc_head.n_classes = hp.head_ctc_n_classes;
-        out.ctc_head.blank_id  = hp.head_ctc_n_classes - 1; // NeMo convention
+        out.ctc_head.blank_id  = hp.head_ctc_n_classes - 1;  // NeMo convention
         out.ctc_head.d_enc     = hp.enc_d_model;
 
         if (!read_tensor_to_f32(w.ctc_head.weight, out.ctc_head.weight)) {
@@ -545,28 +647,26 @@ transcribe_status build_host_decoder_weights(const ParakeetModel & model,
             return TRANSCRIBE_ERR_GGUF;
         }
 
-        const size_t expected_w =
-            static_cast<size_t>(out.ctc_head.n_classes) *
-            static_cast<size_t>(out.ctc_head.d_enc);
+        const size_t expected_w = static_cast<size_t>(out.ctc_head.n_classes) * static_cast<size_t>(out.ctc_head.d_enc);
         if (out.ctc_head.weight.size() != expected_w) {
             log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "parakeet decoder: head.ctc.weight size %zu "
-                         "!= n_classes*d_enc %zu",
-                         out.ctc_head.weight.size(), expected_w);
+                    "parakeet decoder: head.ctc.weight size %zu "
+                    "!= n_classes*d_enc %zu",
+                    out.ctc_head.weight.size(), expected_w);
             return TRANSCRIBE_ERR_GGUF;
         }
         if (static_cast<int>(out.ctc_head.bias.size()) != out.ctc_head.n_classes) {
             log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "parakeet decoder: head.ctc.bias size %zu "
-                         "!= n_classes %d",
-                         out.ctc_head.bias.size(), out.ctc_head.n_classes);
+                    "parakeet decoder: head.ctc.bias size %zu "
+                    "!= n_classes %d",
+                    out.ctc_head.bias.size(), out.ctc_head.n_classes);
             return TRANSCRIBE_ERR_GGUF;
         }
 
         out.tdt_durations.clear();
         out.tdt_max_symbols = 0;
-        out.blank_id = out.ctc_head.blank_id;
-        out.n_vocab  = out.ctc_head.n_classes - 1;
+        out.blank_id        = out.ctc_head.blank_id;
+        out.n_vocab         = out.ctc_head.n_classes - 1;
         return TRANSCRIBE_OK;
     }
 
@@ -579,13 +679,12 @@ transcribe_status build_host_decoder_weights(const ParakeetModel & model,
     }
     // Sanity-check the flattened size against the catalog shape.
     {
-        const size_t expected =
-            static_cast<size_t>(hp.pred_vocab) * static_cast<size_t>(hp.pred_hidden);
+        const size_t expected = static_cast<size_t>(hp.pred_vocab) * static_cast<size_t>(hp.pred_hidden);
         if (out.predictor.embed_w.size() != expected) {
             log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "parakeet decoder: pred.embed.weight size %zu "
-                         "!= pred_vocab*pred_hidden %zu",
-                         out.predictor.embed_w.size(), expected);
+                    "parakeet decoder: pred.embed.weight size %zu "
+                    "!= pred_vocab*pred_hidden %zu",
+                    out.predictor.embed_w.size(), expected);
             return TRANSCRIBE_ERR_GGUF;
         }
     }
@@ -593,21 +692,25 @@ transcribe_status build_host_decoder_weights(const ParakeetModel & model,
     out.predictor.lstm.assign(hp.pred_n_layers, HostLstmLayer{});
     for (int i = 0; i < hp.pred_n_layers; ++i) {
         const auto & lw = w.predictor.lstm[i];
-        auto       & lh = out.predictor.lstm[i];
-        if (!read_tensor_to_f32(lw.Wx, lh.Wx)) return TRANSCRIBE_ERR_GGUF;
-        if (!read_tensor_to_f32(lw.Wh, lh.Wh)) return TRANSCRIBE_ERR_GGUF;
-        if (!read_tensor_to_f32(lw.b,  lh.b))  return TRANSCRIBE_ERR_GGUF;
+        auto &       lh = out.predictor.lstm[i];
+        if (!read_tensor_to_f32(lw.Wx, lh.Wx)) {
+            return TRANSCRIBE_ERR_GGUF;
+        }
+        if (!read_tensor_to_f32(lw.Wh, lh.Wh)) {
+            return TRANSCRIBE_ERR_GGUF;
+        }
+        if (!read_tensor_to_f32(lw.b, lh.b)) {
+            return TRANSCRIBE_ERR_GGUF;
+        }
 
         const size_t gates    = static_cast<size_t>(4 * hp.pred_hidden);
         const size_t mat_size = gates * static_cast<size_t>(hp.pred_hidden);
         if (lh.Wx.size() != mat_size || lh.Wh.size() != mat_size) {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "parakeet decoder: pred.lstm.%d Wx/Wh wrong size", i);
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "parakeet decoder: pred.lstm.%d Wx/Wh wrong size", i);
             return TRANSCRIBE_ERR_GGUF;
         }
         if (lh.b.size() != gates) {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "parakeet decoder: pred.lstm.%d bias wrong size", i);
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "parakeet decoder: pred.lstm.%d bias wrong size", i);
             return TRANSCRIBE_ERR_GGUF;
         }
     }
@@ -615,8 +718,7 @@ transcribe_status build_host_decoder_weights(const ParakeetModel & model,
     // Make the predictor LSTM weights resident. Fatal: a failure means
     // the model cannot decode — fail fast at load.
     if (!build_pred_weights(out.predictor)) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "parakeet decoder: predictor ggml weight build failed");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "parakeet decoder: predictor ggml weight build failed");
         return TRANSCRIBE_ERR_BACKEND;
     }
 
@@ -629,11 +731,21 @@ transcribe_status build_host_decoder_weights(const ParakeetModel & model,
 
     // enc/pred/out_b are mirrored to host fp32; out_w is NOT mirrored
     // here (build_joint_weight dequantizes it from the model tensor).
-    if (!read_tensor_to_f32(w.joint.enc_w,  out.joint.enc_w))  return TRANSCRIBE_ERR_GGUF;
-    if (!read_tensor_to_f32(w.joint.enc_b,  out.joint.enc_b))  return TRANSCRIBE_ERR_GGUF;
-    if (!read_tensor_to_f32(w.joint.pred_w, out.joint.pred_w)) return TRANSCRIBE_ERR_GGUF;
-    if (!read_tensor_to_f32(w.joint.pred_b, out.joint.pred_b)) return TRANSCRIBE_ERR_GGUF;
-    if (!read_tensor_to_f32(w.joint.out_b,  out.joint.out_b))  return TRANSCRIBE_ERR_GGUF;
+    if (!read_tensor_to_f32(w.joint.enc_w, out.joint.enc_w)) {
+        return TRANSCRIBE_ERR_GGUF;
+    }
+    if (!read_tensor_to_f32(w.joint.enc_b, out.joint.enc_b)) {
+        return TRANSCRIBE_ERR_GGUF;
+    }
+    if (!read_tensor_to_f32(w.joint.pred_w, out.joint.pred_w)) {
+        return TRANSCRIBE_ERR_GGUF;
+    }
+    if (!read_tensor_to_f32(w.joint.pred_b, out.joint.pred_b)) {
+        return TRANSCRIBE_ERR_GGUF;
+    }
+    if (!read_tensor_to_f32(w.joint.out_b, out.joint.out_b)) {
+        return TRANSCRIBE_ERR_GGUF;
+    }
 
     // Make the joint weights resident as fp32 ggml tensors. Fatal: a
     // failure means the model cannot decode — fail fast at load.
@@ -644,9 +756,8 @@ transcribe_status build_host_decoder_weights(const ParakeetModel & model,
     const int ne0 = static_cast<int>(w.joint.out_w->ne[0]);
     const int ne1 = static_cast<int>(w.joint.out_w->ne[1]);
     if (ne0 != out.joint.joint_h || ne1 != out.joint.joint_n) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "parakeet decoder: out_w ne [%d,%d] != [joint_h=%d, joint_n=%d]",
-            ne0, ne1, out.joint.joint_h, out.joint.joint_n);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "parakeet decoder: out_w ne [%d,%d] != [joint_h=%d, joint_n=%d]", ne0, ne1,
+                out.joint.joint_h, out.joint.joint_n);
         return TRANSCRIBE_ERR_GGUF;
     }
     if (!build_joint_weight(out.joint, w.joint.out_w)) {
@@ -657,8 +768,8 @@ transcribe_status build_host_decoder_weights(const ParakeetModel & model,
     // ----- TDT params -----
     out.tdt_durations   = hp.tdt_durations;
     out.tdt_max_symbols = hp.tdt_max_symbols;
-    out.n_vocab         = hp.pred_vocab - 1; // raw SP vocab size
-    out.blank_id        = hp.pred_vocab - 1; // blank lives at vocab_size
+    out.n_vocab         = hp.pred_vocab - 1;  // raw SP vocab size
+    out.blank_id        = hp.pred_vocab - 1;  // blank lives at vocab_size
 
     return TRANSCRIBE_OK;
 }
@@ -671,10 +782,8 @@ void LstmState::reset(int n_layers, int pred_hidden) {
     h.resize(static_cast<size_t>(n_layers));
     c.resize(static_cast<size_t>(n_layers));
     for (int layer = 0; layer < n_layers; ++layer) {
-        h[static_cast<size_t>(layer)].assign(
-            static_cast<size_t>(pred_hidden), 0.0f);
-        c[static_cast<size_t>(layer)].assign(
-            static_cast<size_t>(pred_hidden), 0.0f);
+        h[static_cast<size_t>(layer)].assign(static_cast<size_t>(pred_hidden), 0.0f);
+        c[static_cast<size_t>(layer)].assign(static_cast<size_t>(pred_hidden), 0.0f);
     }
 }
 
@@ -694,8 +803,7 @@ const float * predictor_step_ggml(const HostPredictor & predictor,
                                   int                   last_token,
                                   const LstmState &     prev_state,
                                   LstmState &           new_state,
-                                  std::vector<float> &  scratch_x)
-{
+                                  std::vector<float> &  scratch_x) {
     const int H = predictor.pred_hidden;
     if (static_cast<int>(scratch_x.size()) < H) {
         scratch_x.resize(static_cast<size_t>(H));
@@ -705,11 +813,8 @@ const float * predictor_step_ggml(const HostPredictor & predictor,
     if (last_token < 0) {
         std::fill_n(scratch_x.data(), H, 0.0f);
     } else {
-        const size_t row_off =
-            static_cast<size_t>(last_token) * static_cast<size_t>(H);
-        std::memcpy(scratch_x.data(),
-                    predictor.embed_w.data() + row_off,
-                    static_cast<size_t>(H) * sizeof(float));
+        const size_t row_off = static_cast<size_t>(last_token) * static_cast<size_t>(H);
+        std::memcpy(scratch_x.data(), predictor.embed_w.data() + row_off, static_cast<size_t>(H) * sizeof(float));
     }
 
     const size_t hb = static_cast<size_t>(H) * sizeof(float);
@@ -739,22 +844,20 @@ const float * predictor_step_ggml(const HostPredictor & predictor,
 //   activated = activation(summed)               [joint_h]
 //   logits    = out_w @ activated   + out_b      [joint_n]
 // Activation is one of {relu, sigmoid, tanh} (loader allow-list).
-void joint_step(const HostJoint &     j,
-                const JointGraph &    g,
-                const float *         enc_proj,
-                const float *         pred_state,
-                std::vector<float> &  out_logits)
-{
-    if (static_cast<int>(out_logits.size()) < j.joint_n) out_logits.resize(static_cast<size_t>(j.joint_n));
+void joint_step(const HostJoint &    j,
+                const JointGraph &   g,
+                const float *        enc_proj,
+                const float *        pred_state,
+                std::vector<float> & out_logits) {
+    if (static_cast<int>(out_logits.size()) < j.joint_n) {
+        out_logits.resize(static_cast<size_t>(j.joint_n));
+    }
 
     // Full joint on the shared decoder pool, one graph, one dispatch.
-    ggml_backend_tensor_set(g.pred_in, pred_state, 0,
-                            static_cast<size_t>(j.pred_hidden) * sizeof(float));
-    ggml_backend_tensor_set(g.enc_in, enc_proj, 0,
-                            static_cast<size_t>(j.joint_h) * sizeof(float));
+    ggml_backend_tensor_set(g.pred_in, pred_state, 0, static_cast<size_t>(j.pred_hidden) * sizeof(float));
+    ggml_backend_tensor_set(g.enc_in, enc_proj, 0, static_cast<size_t>(j.joint_h) * sizeof(float));
     ggml_backend_graph_compute(g.backend, g.graph);
-    ggml_backend_tensor_get(g.logits, out_logits.data(), 0,
-                            static_cast<size_t>(j.joint_n) * sizeof(float));
+    ggml_backend_tensor_get(g.logits, out_logits.data(), 0, static_cast<size_t>(j.joint_n) * sizeof(float));
 
     // log_softmax over the full joint output matches NeMo's CPU-inference
     // representation of joint_after_projection. It is a uniform per-row
@@ -766,7 +869,9 @@ void joint_step(const HostJoint &     j,
     if (transcribe::debug::enabled()) {
         float max_v = out_logits[0];
         for (int i = 1; i < j.joint_n; ++i) {
-            if (out_logits[i] > max_v) max_v = out_logits[i];
+            if (out_logits[i] > max_v) {
+                max_v = out_logits[i];
+            }
         }
         double sum = 0.0;
         for (int i = 0; i < j.joint_n; ++i) {
@@ -790,30 +895,35 @@ bool precompute_enc_proj_ggml(const HostJoint &    j,
                               const float *        enc_out,
                               int                  T,
                               int                  d_enc,
-                              std::vector<float> & out)
-{
-    if (backend == nullptr || j.g_enc_w == nullptr || j.g_enc_b == nullptr) return false;
+                              std::vector<float> & out) {
+    if (backend == nullptr || j.g_enc_w == nullptr || j.g_enc_b == nullptr) {
+        return false;
+    }
     const int joint_h = j.joint_h;
     out.resize(static_cast<size_t>(T) * static_cast<size_t>(joint_h));
 
-    ggml_init_params ip {};
-    ip.mem_size   = ggml_tensor_overhead() * 6 + ggml_graph_overhead();
-    ip.mem_buffer = nullptr;
-    ip.no_alloc   = true;
+    ggml_init_params ip{};
+    ip.mem_size        = ggml_tensor_overhead() * 6 + ggml_graph_overhead();
+    ip.mem_buffer      = nullptr;
+    ip.no_alloc        = true;
     ggml_context * ctx = ggml_init(ip);
-    if (ctx == nullptr) return false;
+    if (ctx == nullptr) {
+        return false;
+    }
 
     ggml_tensor * in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, d_enc, T);
     ggml_set_input(in);
-    ggml_tensor * mm  = ggml_mul_mat(ctx, j.g_enc_w, in); // [joint_h, T]
-    ggml_tensor * res = ggml_add(ctx, mm, j.g_enc_b);     // + [joint_h] (broadcast over T)
+    ggml_tensor * mm  = ggml_mul_mat(ctx, j.g_enc_w, in);  // [joint_h, T]
+    ggml_tensor * res = ggml_add(ctx, mm, j.g_enc_b);      // + [joint_h] (broadcast over T)
     ggml_set_output(res);
 
     ggml_backend_buffer_t buf = ggml_backend_alloc_ctx_tensors(ctx, backend);
-    if (buf == nullptr) { ggml_free(ctx); return false; }
+    if (buf == nullptr) {
+        ggml_free(ctx);
+        return false;
+    }
 
-    ggml_backend_tensor_set(in, enc_out, 0,
-                            static_cast<size_t>(T) * static_cast<size_t>(d_enc) * sizeof(float));
+    ggml_backend_tensor_set(in, enc_out, 0, static_cast<size_t>(T) * static_cast<size_t>(d_enc) * sizeof(float));
 
     ggml_cgraph * graph = ggml_new_graph(ctx);
     ggml_build_forward_expand(graph, res);
@@ -823,8 +933,7 @@ bool precompute_enc_proj_ggml(const HostJoint &    j,
         return false;
     }
 
-    ggml_backend_tensor_get(res, out.data(), 0,
-                            static_cast<size_t>(T) * static_cast<size_t>(joint_h) * sizeof(float));
+    ggml_backend_tensor_get(res, out.data(), 0, static_cast<size_t>(T) * static_cast<size_t>(joint_h) * sizeof(float));
 
     ggml_backend_buffer_free(buf);
     ggml_free(ctx);
@@ -859,30 +968,29 @@ int argmax_range(const float * data, int n) {
 // The result lives in [0, 1] modulo the +1e-10 epsilon (which
 // matches the reference verbatim, including its slight
 // negative-bias for nearly-uniform distributions).
-float token_confidence(const float * token_logits,
-                       int           n_token_classes,
-                       std::vector<float> & scratch_probs) {
+float token_confidence(const float * token_logits, int n_token_classes, std::vector<float> & scratch_probs) {
     // Numerically stable softmax: subtract max before exp.
     float max_logit = token_logits[0];
     for (int i = 1; i < n_token_classes; ++i) {
-        if (token_logits[i] > max_logit) max_logit = token_logits[i];
+        if (token_logits[i] > max_logit) {
+            max_logit = token_logits[i];
+        }
     }
     if (static_cast<int>(scratch_probs.size()) < n_token_classes) {
         scratch_probs.resize(static_cast<size_t>(n_token_classes));
     }
     double sum_exp = 0.0;
     for (int i = 0; i < n_token_classes; ++i) {
-        const float e = std::exp(token_logits[i] - max_logit);
+        const float e                         = std::exp(token_logits[i] - max_logit);
         scratch_probs[static_cast<size_t>(i)] = e;
         sum_exp += static_cast<double>(e);
     }
     const float inv_sum = static_cast<float>(1.0 / sum_exp);
-    double entropy = 0.0;
+    double      entropy = 0.0;
     for (int i = 0; i < n_token_classes; ++i) {
         const float p = scratch_probs[static_cast<size_t>(i)] * inv_sum;
         // +1e-10 matches the reference.
-        entropy -= static_cast<double>(p) *
-                   std::log(static_cast<double>(p) + 1e-10);
+        entropy -= static_cast<double>(p) * std::log(static_cast<double>(p) + 1e-10);
     }
     const double max_entropy = std::log(static_cast<double>(n_token_classes));
     if (max_entropy <= 0.0) {
@@ -891,7 +999,7 @@ float token_confidence(const float * token_logits,
     return static_cast<float>(1.0 - entropy / max_entropy);
 }
 
-} // namespace
+}  // namespace
 
 // ---------------------------------------------------------------------------
 // Greedy decode driver
@@ -902,37 +1010,38 @@ transcribe_status decode_tdt_greedy(const HostDecoderWeights & w,
                                     int                        T_enc,
                                     int                        d_enc,
                                     int                        n_threads,
-                                    std::vector<TdtToken> &    out_tokens)
-{
+                                    std::vector<TdtToken> &    out_tokens) {
     if (enc_out == nullptr || T_enc <= 0 || d_enc <= 0) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
     if (d_enc != w.joint.d_enc) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "parakeet decoder: enc d_model mismatch (got %d, "
-                     "expected %d)", d_enc, w.joint.d_enc);
+                "parakeet decoder: enc d_model mismatch (got %d, "
+                "expected %d)",
+                d_enc, w.joint.d_enc);
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
 
-    const int nt           = resolve_decode_threads(n_threads);
-    const int n_layers     = static_cast<int>(w.predictor.lstm.size());
-    const int H            = w.predictor.pred_hidden;
-    const int n_token_cls  = w.predictor.pred_vocab; // == vocab_size + 1
-    const int n_dur        = static_cast<int>(w.tdt_durations.size());
-    const int blank_id     = w.blank_id;
+    const int nt          = resolve_decode_threads(n_threads);
+    const int n_layers    = static_cast<int>(w.predictor.lstm.size());
+    const int H           = w.predictor.pred_hidden;
+    const int n_token_cls = w.predictor.pred_vocab;  // == vocab_size + 1
+    const int n_dur       = static_cast<int>(w.tdt_durations.size());
+    const int blank_id    = w.blank_id;
 
     // All-ggml decode on ONE shared threadpool: PredGraph owns the
     // backend + pool; enc_proj and the joint graph borrow it. pg is
     // declared first so it is destroyed LAST (jg's buffer lives on pg's
     // backend). Built per decode call, reentrant. A build failure is a
     // hard decode error.
-    PredGraph pg;
+    PredGraph  pg;
     JointGraph jg;
     build_pred_graph(pg, w.predictor, nt);
-    if (pg.ready) build_joint_graph(jg, w.joint, pg.backend);
+    if (pg.ready) {
+        build_joint_graph(jg, w.joint, pg.backend);
+    }
     if (!pg.ready || !jg.ready) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "parakeet decoder: ggml decode graph build failed");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "parakeet decoder: ggml decode graph build failed");
         return TRANSCRIBE_ERR_BACKEND;
     }
 
@@ -948,9 +1057,9 @@ transcribe_status decode_tdt_greedy(const HostDecoderWeights & w,
 
     // Precompute encoder projections for all T_enc frames (decode-state
     // independent; one sgemm before the loop). See precompute_enc_proj_ggml.
-    const int joint_h = w.joint.joint_h;
+    const int          joint_h = w.joint.joint_h;
     std::vector<float> enc_proj_all;
-    const int64_t t_enc_proj_start = ggml_time_us();
+    const int64_t      t_enc_proj_start = ggml_time_us();
     if (!precompute_enc_proj_ggml(w.joint, pg.backend, enc_out, T_enc, d_enc, enc_proj_all)) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "parakeet decoder: enc_proj graph failed");
         return TRANSCRIBE_ERR_BACKEND;
@@ -962,14 +1071,14 @@ transcribe_status decode_tdt_greedy(const HostDecoderWeights & w,
     std::vector<float> scratch_probs;
     std::vector<float> logits;
 
-    int last_token  = -1; // sentinel: no previous token (start state)
+    int last_token  = -1;  // sentinel: no previous token (start state)
     int step        = 0;
     int new_symbols = 0;
 
     // Runaway-protection cap; legitimate transcriptions never approach it.
     const int max_iters = 16 * T_enc + 1024;
-    int iter = 0;
-    int64_t t_pred_us = 0, t_joint_us = 0, t_conf_us = 0;
+    int       iter      = 0;
+    int64_t   t_pred_us = 0, t_joint_us = 0, t_conf_us = 0;
 
     // On a blank emission (last_token, state) are preserved, so the
     // predictor would write the same next_state next iteration. Skip the
@@ -985,8 +1094,7 @@ transcribe_status decode_tdt_greedy(const HostDecoderWeights & w,
         const int64_t t0 = ggml_time_us();
         const float * decoder_out;
         if (predictor_dirty) {
-            decoder_out = predictor_step_ggml(
-                w.predictor, pg, last_token, state, next_state, scratch_x);
+            decoder_out     = predictor_step_ggml(w.predictor, pg, last_token, state, next_state, scratch_x);
             predictor_dirty = false;
         } else {
             decoder_out = next_state.h.back().data();
@@ -994,11 +1102,10 @@ transcribe_status decode_tdt_greedy(const HostDecoderWeights & w,
         const int64_t t1 = ggml_time_us();
 
         // ----- Joint (using precomputed encoder projection) -----
-        const float * enc_proj =
-            enc_proj_all.data() + static_cast<size_t>(step) * static_cast<size_t>(joint_h);
+        const float * enc_proj = enc_proj_all.data() + static_cast<size_t>(step) * static_cast<size_t>(joint_h);
         joint_step(w.joint, jg, enc_proj, decoder_out, logits);
         const int64_t t2 = ggml_time_us();
-        t_pred_us  += t1 - t0;
+        t_pred_us += t1 - t0;
         t_joint_us += t2 - t1;
 
         // ----- Argmax (token + duration) -----
@@ -1009,42 +1116,32 @@ transcribe_status decode_tdt_greedy(const HostDecoderWeights & w,
         const int decision   = argmax_range(duration_logits, n_dur);
         const int duration   = w.tdt_durations[static_cast<size_t>(decision)];
 
-
         // Optional dump of the first decode step (start state, encoder
         // frame 0): embed input, per-layer LSTM h, joint logits. Mirrors
         // the Python reference dumper's decode subcommand.
         if (iter == 1 && transcribe::debug::enabled()) {
             // Predictor scratch_x at start: zeros (vector of length H).
             const long long s_h = H;
-            transcribe::debug::dump_host_f32(
-                "dec.embed.0", scratch_x.data(), s_h, &s_h, 1,
-                "decoder.embed");
+            transcribe::debug::dump_host_f32("dec.embed.0", scratch_x.data(), s_h, &s_h, 1, "decoder.embed");
 
             for (int layer = 0; layer < n_layers; ++layer) {
                 char name_h[64];
                 char name_c[64];
                 std::snprintf(name_h, sizeof(name_h), "dec.lstm.%d.h.0", layer);
                 std::snprintf(name_c, sizeof(name_c), "dec.lstm.%d.c.0", layer);
-                transcribe::debug::dump_host_f32(
-                    name_h, next_state.h[layer].data(), s_h, &s_h, 1,
-                    "decoder.lstm");
-                transcribe::debug::dump_host_f32(
-                    name_c, next_state.c[layer].data(), s_h, &s_h, 1,
-                    "decoder.lstm");
+                transcribe::debug::dump_host_f32(name_h, next_state.h[layer].data(), s_h, &s_h, 1, "decoder.lstm");
+                transcribe::debug::dump_host_f32(name_c, next_state.c[layer].data(), s_h, &s_h, 1, "decoder.lstm");
             }
 
             const long long s_n = w.joint.joint_n;
-            transcribe::debug::dump_host_f32(
-                "dec.joint.0", logits.data(), s_n, &s_n, 1,
-                "decoder.joint");
+            transcribe::debug::dump_host_f32("dec.joint.0", logits.data(), s_n, &s_n, 1, "decoder.joint");
         }
 
         // ----- TDT emit + state advance -----
         const bool is_blank = (pred_token == blank_id);
         if (!is_blank) {
             const int64_t tc0 = ggml_time_us();
-            const float p = token_confidence(token_logits, n_token_cls,
-                                             scratch_probs);
+            const float   p   = token_confidence(token_logits, n_token_cls, scratch_probs);
             t_conf_us += ggml_time_us() - tc0;
             TdtToken tok;
             tok.id              = pred_token;
@@ -1054,7 +1151,7 @@ transcribe_status decode_tdt_greedy(const HostDecoderWeights & w,
             out_tokens.push_back(tok);
 
             last_token = pred_token;
-            std::swap(state, next_state); // commit
+            std::swap(state, next_state);  // commit
             predictor_dirty = true;
         }
 
@@ -1086,21 +1183,18 @@ transcribe_status decode_tdt_greedy(const HostDecoderWeights & w,
     }
 
     log_msg(TRANSCRIBE_LOG_LEVEL_DEBUG,
-                 "decoder: %d iters, %d tokens, T_enc=%d  "
-                 "enc_proj=%.1f ms  pred=%.1f ms  joint=%.1f ms  conf=%.1f ms  "
-                 "total=%.1f ms  per_iter=%.0f us",
-                 iter, static_cast<int>(out_tokens.size()), T_enc,
-                 t_enc_proj_us / 1000.0,
-                 t_pred_us  / 1000.0,
-                 t_joint_us / 1000.0,
-                 t_conf_us  / 1000.0,
-                 (t_enc_proj_us + t_pred_us + t_joint_us + t_conf_us) / 1000.0,
-                 static_cast<double>(t_pred_us + t_joint_us) / std::max(iter, 1));
+            "decoder: %d iters, %d tokens, T_enc=%d  "
+            "enc_proj=%.1f ms  pred=%.1f ms  joint=%.1f ms  conf=%.1f ms  "
+            "total=%.1f ms  per_iter=%.0f us",
+            iter, static_cast<int>(out_tokens.size()), T_enc, t_enc_proj_us / 1000.0, t_pred_us / 1000.0,
+            t_joint_us / 1000.0, t_conf_us / 1000.0, (t_enc_proj_us + t_pred_us + t_joint_us + t_conf_us) / 1000.0,
+            static_cast<double>(t_pred_us + t_joint_us) / std::max(iter, 1));
 
     if (iter >= max_iters) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "parakeet decoder: hit iteration cap (%d) — pathological "
-                     "logits or loop bug", max_iters);
+                "parakeet decoder: hit iteration cap (%d) — pathological "
+                "logits or loop bug",
+                max_iters);
         return TRANSCRIBE_ERR_BACKEND;
     }
     return TRANSCRIBE_OK;
@@ -1135,32 +1229,33 @@ transcribe_status decode_rnnt_greedy(const HostDecoderWeights & w,
                                      int                        T_enc,
                                      int                        d_enc,
                                      int                        n_threads,
-                                     std::vector<TdtToken> &    out_tokens)
-{
+                                     std::vector<TdtToken> &    out_tokens) {
     if (enc_out == nullptr || T_enc <= 0 || d_enc <= 0) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
     if (d_enc != w.joint.d_enc) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "parakeet decoder (rnnt): enc d_model mismatch (got %d, "
-                     "expected %d)", d_enc, w.joint.d_enc);
+                "parakeet decoder (rnnt): enc d_model mismatch (got %d, "
+                "expected %d)",
+                d_enc, w.joint.d_enc);
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
 
-    const int nt           = resolve_decode_threads(n_threads);
-    const int n_layers     = static_cast<int>(w.predictor.lstm.size());
-    const int H            = w.predictor.pred_hidden;
-    const int n_token_cls  = w.predictor.pred_vocab; // == vocab + 1
-    const int blank_id     = w.blank_id;
+    const int nt          = resolve_decode_threads(n_threads);
+    const int n_layers    = static_cast<int>(w.predictor.lstm.size());
+    const int H           = w.predictor.pred_hidden;
+    const int n_token_cls = w.predictor.pred_vocab;  // == vocab + 1
+    const int blank_id    = w.blank_id;
 
     // Per-call decode graphs (see decode_tdt_greedy for the lifecycle).
-    PredGraph pg;
+    PredGraph  pg;
     JointGraph jg;
     build_pred_graph(pg, w.predictor, nt);
-    if (pg.ready) build_joint_graph(jg, w.joint, pg.backend);
+    if (pg.ready) {
+        build_joint_graph(jg, w.joint, pg.backend);
+    }
     if (!pg.ready || !jg.ready) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "parakeet decoder: ggml decode graph build failed");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "parakeet decoder: ggml decode graph build failed");
         return TRANSCRIBE_ERR_BACKEND;
     }
 
@@ -1170,9 +1265,9 @@ transcribe_status decode_rnnt_greedy(const HostDecoderWeights & w,
     next_state.reset(n_layers, H);
 
     // Precompute encoder projections for all T_enc frames (same as TDT).
-    const int joint_h = w.joint.joint_h;
+    const int          joint_h = w.joint.joint_h;
     std::vector<float> enc_proj_all;
-    const int64_t t_enc_proj_start = ggml_time_us();
+    const int64_t      t_enc_proj_start = ggml_time_us();
     if (!precompute_enc_proj_ggml(w.joint, pg.backend, enc_out, T_enc, d_enc, enc_proj_all)) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "parakeet decoder: enc_proj graph failed");
         return TRANSCRIBE_ERR_BACKEND;
@@ -1188,8 +1283,8 @@ transcribe_status decode_rnnt_greedy(const HostDecoderWeights & w,
     int new_symbols = 0;
 
     const int max_iters = 16 * T_enc + 1024;
-    int iter = 0;
-    int64_t t_pred_us = 0, t_joint_us = 0, t_conf_us = 0;
+    int       iter      = 0;
+    int64_t   t_pred_us = 0, t_joint_us = 0, t_conf_us = 0;
 
     // Predictor-step cache (see decode_tdt_greedy). Bit-exact with the
     // unconditional path; elides 60-80% of predictor work on a typical
@@ -1202,56 +1297,45 @@ transcribe_status decode_rnnt_greedy(const HostDecoderWeights & w,
         const int64_t t0 = ggml_time_us();
         const float * decoder_out;
         if (predictor_dirty) {
-            decoder_out = predictor_step_ggml(
-                w.predictor, pg, last_token, state, next_state, scratch_x);
+            decoder_out     = predictor_step_ggml(w.predictor, pg, last_token, state, next_state, scratch_x);
             predictor_dirty = false;
         } else {
             decoder_out = next_state.h.back().data();
         }
         const int64_t t1 = ggml_time_us();
 
-        const float * enc_proj =
-            enc_proj_all.data() + static_cast<size_t>(step) * static_cast<size_t>(joint_h);
+        const float * enc_proj = enc_proj_all.data() + static_cast<size_t>(step) * static_cast<size_t>(joint_h);
         joint_step(w.joint, jg, enc_proj, decoder_out, logits);
         const int64_t t2 = ggml_time_us();
-        t_pred_us  += t1 - t0;
+        t_pred_us += t1 - t0;
         t_joint_us += t2 - t1;
 
         // RNNT joint output is just `n_token_cls` floats (no duration extras).
         const float * token_logits = logits.data();
-        const int pred_token = argmax_range(token_logits, n_token_cls);
+        const int     pred_token   = argmax_range(token_logits, n_token_cls);
 
         if (iter == 1 && transcribe::debug::enabled()) {
             const long long s_h = H;
-            transcribe::debug::dump_host_f32(
-                "dec.embed.0", scratch_x.data(), s_h, &s_h, 1,
-                "decoder.embed");
+            transcribe::debug::dump_host_f32("dec.embed.0", scratch_x.data(), s_h, &s_h, 1, "decoder.embed");
             for (int layer = 0; layer < n_layers; ++layer) {
                 char name_h[64];
                 char name_c[64];
                 std::snprintf(name_h, sizeof(name_h), "dec.lstm.%d.h.0", layer);
                 std::snprintf(name_c, sizeof(name_c), "dec.lstm.%d.c.0", layer);
-                transcribe::debug::dump_host_f32(
-                    name_h, next_state.h[layer].data(), s_h, &s_h, 1,
-                    "decoder.lstm");
-                transcribe::debug::dump_host_f32(
-                    name_c, next_state.c[layer].data(), s_h, &s_h, 1,
-                    "decoder.lstm");
+                transcribe::debug::dump_host_f32(name_h, next_state.h[layer].data(), s_h, &s_h, 1, "decoder.lstm");
+                transcribe::debug::dump_host_f32(name_c, next_state.c[layer].data(), s_h, &s_h, 1, "decoder.lstm");
             }
             const long long s_n = w.joint.joint_n;
-            transcribe::debug::dump_host_f32(
-                "dec.joint.0", logits.data(), s_n, &s_n, 1,
-                "decoder.joint");
+            transcribe::debug::dump_host_f32("dec.joint.0", logits.data(), s_n, &s_n, 1, "decoder.joint");
         }
 
         const bool is_blank = (pred_token == blank_id);
         if (is_blank) {
-            step       += 1;
+            step += 1;
             new_symbols = 0;
         } else {
             const int64_t tc0 = ggml_time_us();
-            const float p = token_confidence(token_logits, n_token_cls,
-                                             scratch_probs);
+            const float   p   = token_confidence(token_logits, n_token_cls, scratch_probs);
             t_conf_us += ggml_time_us() - tc0;
             TdtToken tok;
             tok.id              = pred_token;
@@ -1266,27 +1350,24 @@ transcribe_status decode_rnnt_greedy(const HostDecoderWeights & w,
 
             new_symbols += 1;
             if (w.tdt_max_symbols > 0 && new_symbols >= w.tdt_max_symbols) {
-                step       += 1;
+                step += 1;
                 new_symbols = 0;
             }
         }
     }
 
     log_msg(TRANSCRIBE_LOG_LEVEL_DEBUG,
-                 "decoder (rnnt): %d iters, %d tokens, T_enc=%d  "
-                 "enc_proj=%.1f ms  pred=%.1f ms  joint=%.1f ms  conf=%.1f ms  "
-                 "total=%.1f ms",
-                 iter, static_cast<int>(out_tokens.size()), T_enc,
-                 t_enc_proj_us / 1000.0,
-                 t_pred_us  / 1000.0,
-                 t_joint_us / 1000.0,
-                 t_conf_us  / 1000.0,
-                 (t_enc_proj_us + t_pred_us + t_joint_us + t_conf_us) / 1000.0);
+            "decoder (rnnt): %d iters, %d tokens, T_enc=%d  "
+            "enc_proj=%.1f ms  pred=%.1f ms  joint=%.1f ms  conf=%.1f ms  "
+            "total=%.1f ms",
+            iter, static_cast<int>(out_tokens.size()), T_enc, t_enc_proj_us / 1000.0, t_pred_us / 1000.0,
+            t_joint_us / 1000.0, t_conf_us / 1000.0, (t_enc_proj_us + t_pred_us + t_joint_us + t_conf_us) / 1000.0);
 
     if (iter >= max_iters) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "parakeet decoder (rnnt): hit iteration cap (%d) — "
-                     "pathological logits or loop bug", max_iters);
+                "parakeet decoder (rnnt): hit iteration cap (%d) — "
+                "pathological logits or loop bug",
+                max_iters);
         return TRANSCRIBE_ERR_BACKEND;
     }
     return TRANSCRIBE_OK;
@@ -1300,17 +1381,15 @@ transcribe_status decode_rnnt_greedy(const HostDecoderWeights & w,
 // LSTM state (state_io) and previous token (last_token_io). The
 // chunk's encoder frames are decoded in stream-wide coordinates
 // (step_at_emit = frame_offset + local_step). No timing log.
-transcribe_status decode_rnnt_greedy_streaming(
-    const HostDecoderWeights & w,
-    const float *              enc_out,
-    int                        T_enc_new,
-    int                        d_enc,
-    LstmState &                state_io,
-    int &                      last_token_io,
-    int                        frame_offset,
-    int                        n_threads,
-    std::vector<TdtToken> &    out_tokens)
-{
+transcribe_status decode_rnnt_greedy_streaming(const HostDecoderWeights & w,
+                                               const float *              enc_out,
+                                               int                        T_enc_new,
+                                               int                        d_enc,
+                                               LstmState &                state_io,
+                                               int &                      last_token_io,
+                                               int                        frame_offset,
+                                               int                        n_threads,
+                                               std::vector<TdtToken> &    out_tokens) {
     if (enc_out == nullptr || T_enc_new <= 0 || d_enc <= 0) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
@@ -1319,46 +1398,44 @@ transcribe_status decode_rnnt_greedy_streaming(
     // than mis-decode a hypothetical future TDT/CTC streaming model.
     if (w.head_kind != HostHeadKind::RNNT) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "parakeet decoder (rnnt-stream): streaming decode "
-                     "requires an RNN-T head; this model's head is not "
-                     "RNN-T");
+                "parakeet decoder (rnnt-stream): streaming decode "
+                "requires an RNN-T head; this model's head is not "
+                "RNN-T");
         return TRANSCRIBE_ERR_NOT_IMPLEMENTED;
     }
     if (d_enc != w.joint.d_enc) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "parakeet decoder (rnnt-stream): enc d_model mismatch "
-                     "(got %d, expected %d)", d_enc, w.joint.d_enc);
+                "parakeet decoder (rnnt-stream): enc d_model mismatch "
+                "(got %d, expected %d)",
+                d_enc, w.joint.d_enc);
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
 
-    const int nt           = resolve_decode_threads(n_threads);
-    const int n_layers     = static_cast<int>(w.predictor.lstm.size());
-    const int H            = w.predictor.pred_hidden;
-    const int n_token_cls  = w.predictor.pred_vocab;
-    const int blank_id     = w.blank_id;
+    const int nt          = resolve_decode_threads(n_threads);
+    const int n_layers    = static_cast<int>(w.predictor.lstm.size());
+    const int H           = w.predictor.pred_hidden;
+    const int n_token_cls = w.predictor.pred_vocab;
+    const int blank_id    = w.blank_id;
 
     // Per-call decode graphs (see decode_tdt_greedy for the lifecycle).
-    PredGraph pg;
+    PredGraph  pg;
     JointGraph jg;
     build_pred_graph(pg, w.predictor, nt);
-    if (pg.ready) build_joint_graph(jg, w.joint, pg.backend);
+    if (pg.ready) {
+        build_joint_graph(jg, w.joint, pg.backend);
+    }
     if (!pg.ready || !jg.ready) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "parakeet decoder: ggml decode graph build failed");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "parakeet decoder: ggml decode graph build failed");
         return TRANSCRIBE_ERR_BACKEND;
     }
 
     // Validate state_io shape; reset if degenerate.
-    if (static_cast<int>(state_io.h.size()) != n_layers ||
-        static_cast<int>(state_io.c.size()) != n_layers)
-    {
+    if (static_cast<int>(state_io.h.size()) != n_layers || static_cast<int>(state_io.c.size()) != n_layers) {
         state_io.reset(n_layers, H);
         last_token_io = -1;
     }
     for (int l = 0; l < n_layers; ++l) {
-        if (static_cast<int>(state_io.h[l].size()) != H ||
-            static_cast<int>(state_io.c[l].size()) != H)
-        {
+        if (static_cast<int>(state_io.h[l].size()) != H || static_cast<int>(state_io.c[l].size()) != H) {
             state_io.reset(n_layers, H);
             last_token_io = -1;
             break;
@@ -1366,7 +1443,7 @@ transcribe_status decode_rnnt_greedy_streaming(
     }
 
     // Precompute encoder projections for this chunk only.
-    const int joint_h = w.joint.joint_h;
+    const int          joint_h = w.joint.joint_h;
     std::vector<float> enc_proj_all;
     if (!precompute_enc_proj_ggml(w.joint, pg.backend, enc_out, T_enc_new, d_enc, enc_proj_all)) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "parakeet decoder (rnnt-stream): enc_proj graph failed");
@@ -1376,7 +1453,7 @@ transcribe_status decode_rnnt_greedy_streaming(
     // Working state. On return, `state` (committed after the last
     // non-blank emission, or unchanged for an all-blank chunk) and
     // last_token are copied back into state_io / last_token_io.
-    LstmState state     = state_io;
+    LstmState state = state_io;
     LstmState next_state;
     next_state.reset(n_layers, H);
 
@@ -1389,7 +1466,7 @@ transcribe_status decode_rnnt_greedy_streaming(
     int new_symbols = 0;
 
     const int max_iters = 16 * T_enc_new + 1024;
-    int iter = 0;
+    int       iter      = 0;
 
     bool predictor_dirty = true;
 
@@ -1398,28 +1475,25 @@ transcribe_status decode_rnnt_greedy_streaming(
 
         const float * decoder_out;
         if (predictor_dirty) {
-            decoder_out = predictor_step_ggml(
-                w.predictor, pg, last_token, state, next_state, scratch_x);
+            decoder_out     = predictor_step_ggml(w.predictor, pg, last_token, state, next_state, scratch_x);
             predictor_dirty = false;
         } else {
             decoder_out = next_state.h.back().data();
         }
 
-        const float * enc_proj = enc_proj_all.data() +
-            static_cast<size_t>(step) * static_cast<size_t>(joint_h);
+        const float * enc_proj = enc_proj_all.data() + static_cast<size_t>(step) * static_cast<size_t>(joint_h);
         joint_step(w.joint, jg, enc_proj, decoder_out, logits);
 
         const float * token_logits = logits.data();
-        const int pred_token = argmax_range(token_logits, n_token_cls);
+        const int     pred_token   = argmax_range(token_logits, n_token_cls);
 
         const bool is_blank = (pred_token == blank_id);
         if (is_blank) {
-            step       += 1;
+            step += 1;
             new_symbols = 0;
         } else {
-            const float p = token_confidence(token_logits, n_token_cls,
-                                             scratch_probs);
-            TdtToken tok;
+            const float p = token_confidence(token_logits, n_token_cls, scratch_probs);
+            TdtToken    tok;
             tok.id              = pred_token;
             tok.p               = p;
             tok.step_at_emit    = frame_offset + step;
@@ -1432,16 +1506,14 @@ transcribe_status decode_rnnt_greedy_streaming(
 
             new_symbols += 1;
             if (w.tdt_max_symbols > 0 && new_symbols >= w.tdt_max_symbols) {
-                step       += 1;
+                step += 1;
                 new_symbols = 0;
             }
         }
     }
 
     if (iter >= max_iters) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "parakeet decoder (rnnt-stream): hit iteration cap (%d)",
-                     max_iters);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "parakeet decoder (rnnt-stream): hit iteration cap (%d)", max_iters);
         return TRANSCRIBE_ERR_BACKEND;
     }
 
@@ -1462,15 +1534,15 @@ transcribe_status decode_ctc_greedy(const HostDecoderWeights & w,
                                     int                        T_enc,
                                     int                        d_enc,
                                     int                        n_threads,
-                                    std::vector<TdtToken> &    out_tokens)
-{
+                                    std::vector<TdtToken> &    out_tokens) {
     if (enc_out == nullptr || T_enc <= 0 || d_enc <= 0) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
     if (d_enc != w.ctc_head.d_enc) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "parakeet decoder (ctc): enc d_model mismatch "
-                     "(got %d, expected %d)", d_enc, w.ctc_head.d_enc);
+                "parakeet decoder (ctc): enc d_model mismatch "
+                "(got %d, expected %d)",
+                d_enc, w.ctc_head.d_enc);
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
 
@@ -1478,30 +1550,28 @@ transcribe_status decode_ctc_greedy(const HostDecoderWeights & w,
     const int blank_id  = w.ctc_head.blank_id;
 
     // Compute T_enc frames of logits: [T_enc, n_classes] = enc_out[T_enc, d_enc] @ W^T + b.
-    std::vector<float> logits_all(
-        static_cast<size_t>(T_enc) * static_cast<size_t>(n_classes));
+    std::vector<float> logits_all(static_cast<size_t>(T_enc) * static_cast<size_t>(n_classes));
 
     const int64_t t_proj_start = ggml_time_us();
 #if TRANSCRIBE_HAS_BLAS
-    cblas_sgemm(CblasRowMajor, CblasNoTrans, CblasTrans,
-                T_enc, n_classes, d_enc,
-                1.0f, enc_out, d_enc,
-                w.ctc_head.weight.data(), d_enc,
-                0.0f, logits_all.data(), n_classes);
+    cblas_sgemm(CblasRowMajor, CblasNoTrans, CblasTrans, T_enc, n_classes, d_enc, 1.0f, enc_out, d_enc,
+                w.ctc_head.weight.data(), d_enc, 0.0f, logits_all.data(), n_classes);
 #else
     // No BLAS: project all T frames in parallel over parallel_for_all
     // (rows within a frame are a serial, auto-vectorized dot). Bias folded
     // in below.
     {
-        const int nt    = resolve_decode_threads(n_threads);
+        const int     nt = resolve_decode_threads(n_threads);
         const float * Wc = w.ctc_head.weight.data();
         transcribe::parallel_for_all(T_enc, nt, [&](int t) {
             const float * frame = enc_out + static_cast<size_t>(t) * static_cast<size_t>(d_enc);
-            float * row = logits_all.data() + static_cast<size_t>(t) * static_cast<size_t>(n_classes);
+            float *       row   = logits_all.data() + static_cast<size_t>(t) * static_cast<size_t>(n_classes);
             for (int r = 0; r < n_classes; ++r) {
-                const float * wr = Wc + static_cast<size_t>(r) * static_cast<size_t>(d_enc);
-                float acc = 0.0f;
-                for (int c = 0; c < d_enc; ++c) acc += wr[c] * frame[c];
+                const float * wr  = Wc + static_cast<size_t>(r) * static_cast<size_t>(d_enc);
+                float         acc = 0.0f;
+                for (int c = 0; c < d_enc; ++c) {
+                    acc += wr[c] * frame[c];
+                }
                 row[r] = acc;
             }
             return true;
@@ -1519,10 +1589,12 @@ transcribe_status decode_ctc_greedy(const HostDecoderWeights & w,
     // Per-frame log-softmax in place. The reference dumps log-probs,
     // not raw logits.
     for (int t = 0; t < T_enc; ++t) {
-        float * row = logits_all.data() + static_cast<size_t>(t) * static_cast<size_t>(n_classes);
-        float max_v = row[0];
+        float * row   = logits_all.data() + static_cast<size_t>(t) * static_cast<size_t>(n_classes);
+        float   max_v = row[0];
         for (int c = 1; c < n_classes; ++c) {
-            if (row[c] > max_v) max_v = row[c];
+            if (row[c] > max_v) {
+                max_v = row[c];
+            }
         }
         double sum = 0.0;
         for (int c = 0; c < n_classes; ++c) {
@@ -1539,14 +1611,12 @@ transcribe_status decode_ctc_greedy(const HostDecoderWeights & w,
     // [n_classes, T_enc]).
     if (transcribe::debug::enabled()) {
         const long long s_n = n_classes;
-        transcribe::debug::dump_host_f32(
-            "dec.ctc.logprobs.0", logits_all.data(), s_n, &s_n, 1,
-            "decoder.ctc.logprobs.0");
+        transcribe::debug::dump_host_f32("dec.ctc.logprobs.0", logits_all.data(), s_n, &s_n, 1,
+                                         "decoder.ctc.logprobs.0");
         const long long shape_full[2] = { T_enc, n_classes };
-        transcribe::debug::dump_host_f32(
-            "dec.ctc.logprobs", logits_all.data(),
-            static_cast<long long>(logits_all.size()),
-            shape_full, 2, "decoder.ctc.logprobs");
+        transcribe::debug::dump_host_f32("dec.ctc.logprobs", logits_all.data(),
+                                         static_cast<long long>(logits_all.size()), shape_full, 2,
+                                         "decoder.ctc.logprobs");
     }
 
     // Greedy collapse: drop runs of identical labels, then drop blanks.
@@ -1554,11 +1624,15 @@ transcribe_status decode_ctc_greedy(const HostDecoderWeights & w,
     // first changed; duration_frames = 1.
     int prev_label = -1;
     for (int t = 0; t < T_enc; ++t) {
-        const float * row = logits_all.data() + static_cast<size_t>(t) * static_cast<size_t>(n_classes);
-        const int label = argmax_range(row, n_classes);
-        if (label == prev_label) continue; // run-length collapse
+        const float * row   = logits_all.data() + static_cast<size_t>(t) * static_cast<size_t>(n_classes);
+        const int     label = argmax_range(row, n_classes);
+        if (label == prev_label) {
+            continue;  // run-length collapse
+        }
         prev_label = label;
-        if (label == blank_id) continue;
+        if (label == blank_id) {
+            continue;
+        }
         TdtToken tok;
         tok.id              = label;
         // CTC greedy confidence = exp(top log-prob); this is the
@@ -1569,12 +1643,10 @@ transcribe_status decode_ctc_greedy(const HostDecoderWeights & w,
         out_tokens.push_back(tok);
     }
 
-    log_msg(TRANSCRIBE_LOG_LEVEL_DEBUG,
-                 "decoder (ctc): T_enc=%d  proj=%.1f ms  emitted=%d",
-                 T_enc, t_proj_us / 1000.0,
-                 static_cast<int>(out_tokens.size()));
+    log_msg(TRANSCRIBE_LOG_LEVEL_DEBUG, "decoder (ctc): T_enc=%d  proj=%.1f ms  emitted=%d", T_enc, t_proj_us / 1000.0,
+            static_cast<int>(out_tokens.size()));
 
     return TRANSCRIBE_OK;
 }
 
-} // namespace transcribe::parakeet
+}  // namespace transcribe::parakeet
diff --git a/src/arch/parakeet/decoder.h b/src/arch/parakeet/decoder.h
index c3b50557..e4de9dfa 100644
--- a/src/arch/parakeet/decoder.h
+++ b/src/arch/parakeet/decoder.h
@@ -27,10 +27,9 @@
 
 #pragma once
 
-#include "transcribe.h"
-
-#include "ggml.h"
 #include "ggml-backend.h"
+#include "ggml.h"
+#include "transcribe.h"
 
 #include <cstdint>
 #include <string>
@@ -74,10 +73,10 @@ struct HostLstmLayer {
 };
 
 struct HostPredictor {
-    int                       pred_hidden = 0;
-    int                       pred_vocab  = 0; // includes the +1 start row
-    std::vector<float>        embed_w;          // [pred_vocab, pred_hidden]
-    std::vector<HostLstmLayer> lstm;            // pred_n_layers entries
+    int                        pred_hidden = 0;
+    int                        pred_vocab  = 0;  // includes the +1 start row
+    std::vector<float>         embed_w;          // [pred_vocab, pred_hidden]
+    std::vector<HostLstmLayer> lstm;             // pred_n_layers entries
 
     // --- resident ggml LSTM weights (immutable, model-owned) ---
     // fp32 mirror of the per-layer Wx/Wh/b, made resident once at load so
@@ -86,7 +85,7 @@ struct HostPredictor {
     // closest to the host reference at no speed cost. Owned here, freed by
     // dtor. On build failure lstm_ready stays false (hard decode error).
     ggml_context *        lstm_w_ctx     = nullptr;
-    ggml_backend_t        lstm_w_backend = nullptr; // alloc-only; never compute'd
+    ggml_backend_t        lstm_w_backend = nullptr;  // alloc-only; never compute'd
     ggml_backend_buffer_t lstm_w_buf     = nullptr;
     bool                  lstm_ready     = false;
 
@@ -99,20 +98,20 @@ struct HostPredictor {
 };
 
 struct HostJoint {
-    int         d_enc       = 0; // encoder d_model
+    int         d_enc       = 0;  // encoder d_model
     int         pred_hidden = 0;
     int         joint_h     = 0;
-    int         joint_n     = 0; // total output classes (vocab+blank+durations)
+    int         joint_n     = 0;  // total output classes (vocab+blank+durations)
     std::string activation;       // "relu" / "sigmoid" / "tanh"
 
     // Host fp32 weight mirrors — LOAD-TIME SCRATCH ONLY: filled at load,
     // uploaded into the resident ggml tensors below, then freed. (out_w is
     // not mirrored — gw_w is built straight from the model tensor.)
-    std::vector<float> enc_w;    // [joint_h, d_enc]       (freed after load)
-    std::vector<float> enc_b;    // [joint_h]              (freed after load)
-    std::vector<float> pred_w;   // [joint_h, pred_hidden] (freed after load)
-    std::vector<float> pred_b;   // [joint_h]              (freed after load)
-    std::vector<float> out_b;    // [joint_n]              (freed after load)
+    std::vector<float> enc_w;   // [joint_h, d_enc]       (freed after load)
+    std::vector<float> enc_b;   // [joint_h]              (freed after load)
+    std::vector<float> pred_w;  // [joint_h, pred_hidden] (freed after load)
+    std::vector<float> pred_b;  // [joint_h]              (freed after load)
+    std::vector<float> out_b;   // [joint_n]              (freed after load)
 
     // --- resident ggml weights (immutable, model-owned) ---
     // The whole joint runs as one ggml graph (build_joint_graph), so
@@ -122,14 +121,14 @@ struct HostJoint {
     // context; the mutable per-decode state lives in a stack-local
     // JointGraph (reentrant). Owned here, freed by dtor.
     ggml_context *        w_ctx     = nullptr;
-    ggml_backend_t        w_backend = nullptr; // alloc-only; never graph_compute'd
+    ggml_backend_t        w_backend = nullptr;  // alloc-only; never graph_compute'd
     ggml_backend_buffer_t w_buf     = nullptr;
-    ggml_tensor *         g_enc_w   = nullptr; // [d_enc, joint_h] fp32 weight
-    ggml_tensor *         g_enc_b   = nullptr; // [joint_h] fp32 bias
-    ggml_tensor *         g_pred_w  = nullptr; // [pred_hidden, joint_h] fp32 weight
-    ggml_tensor *         g_pred_b  = nullptr; // [joint_h] fp32 bias
-    ggml_tensor *         gw_w      = nullptr; // [joint_h, joint_n] fp32 weight
-    ggml_tensor *         gw_b      = nullptr; // [joint_n] fp32 bias
+    ggml_tensor *         g_enc_w   = nullptr;  // [d_enc, joint_h] fp32 weight
+    ggml_tensor *         g_enc_b   = nullptr;  // [joint_h] fp32 bias
+    ggml_tensor *         g_pred_w  = nullptr;  // [pred_hidden, joint_h] fp32 weight
+    ggml_tensor *         g_pred_b  = nullptr;  // [joint_h] fp32 bias
+    ggml_tensor *         gw_w      = nullptr;  // [joint_h, joint_n] fp32 weight
+    ggml_tensor *         gw_b      = nullptr;  // [joint_n] fp32 bias
     bool                  w_ready   = false;
 
     HostJoint() = default;
@@ -144,11 +143,11 @@ struct HostJoint {
 // projecting d_enc -> n_classes (= vocab + 1 blank). Stored row-major
 // [n_classes, d_enc] so per-frame logits = W @ enc_t + b.
 struct HostCtcHead {
-    int                 n_classes = 0; // == vocab + 1
-    int                 blank_id  = 0; // NeMo convention: blank lives at n_classes - 1
-    int                 d_enc     = 0;
-    std::vector<float>  weight;        // [n_classes, d_enc]
-    std::vector<float>  bias;          // [n_classes]
+    int                n_classes = 0;  // == vocab + 1
+    int                blank_id  = 0;  // NeMo convention: blank lives at n_classes - 1
+    int                d_enc     = 0;
+    std::vector<float> weight;         // [n_classes, d_enc]
+    std::vector<float> bias;           // [n_classes]
 };
 
 // Decoder head selector. Mirrors ParakeetHParams::HeadKind so the
@@ -162,22 +161,21 @@ enum class HostHeadKind { TDT, RNNT, CTC };
 // empty; for RNNT tdt_durations is empty and only the tdt_max_symbols
 // cap is reused.
 struct HostDecoderWeights {
-    HostHeadKind           head_kind        = HostHeadKind::TDT;
-    HostPredictor          predictor;        // empty for CTC
-    HostJoint              joint;            // empty for CTC
-    HostCtcHead            ctc_head;         // empty for TDT/RNNT
-    std::vector<int32_t>   tdt_durations;    // empty for RNNT/CTC
-    int                    tdt_max_symbols  = 0;
-    int                    blank_id         = 0; // unified: TDT/RNNT == pred_vocab - 1; CTC == ctc_head.blank_id
-    int                    n_vocab          = 0; // raw SP vocab size (excludes blank)
+    HostHeadKind         head_kind = HostHeadKind::TDT;
+    HostPredictor        predictor;            // empty for CTC
+    HostJoint            joint;                // empty for CTC
+    HostCtcHead          ctc_head;             // empty for TDT/RNNT
+    std::vector<int32_t> tdt_durations;        // empty for RNNT/CTC
+    int                  tdt_max_symbols = 0;
+    int                  blank_id        = 0;  // unified: TDT/RNNT == pred_vocab - 1; CTC == ctc_head.blank_id
+    int                  n_vocab         = 0;  // raw SP vocab size (excludes blank)
 };
 
 // Build host mirrors from a loaded ParakeetModel. Reads tensor bytes
 // via ggml_backend_tensor_get so it works on every backend. Returns
 // TRANSCRIBE_OK on success; on failure logs to stderr and leaves
 // `out` in an indeterminate state.
-transcribe_status build_host_decoder_weights(const ParakeetModel & model,
-                                             HostDecoderWeights &  out);
+transcribe_status build_host_decoder_weights(const ParakeetModel & model, HostDecoderWeights & out);
 
 // One (h, c) pair per LSTM layer. The decoder owns one "current"
 // (committed) state and one "scratch" state (computed each iteration,
@@ -198,7 +196,7 @@ struct LstmState {
 // hop_length / sample_rate) for the public result accessors.
 struct TdtToken {
     int   id              = 0;
-    float p               = 0.0f; // entropy-based confidence
+    float p               = 0.0f;  // entropy-based confidence
     int   step_at_emit    = 0;
     int   duration_frames = 0;
 };
@@ -244,16 +242,15 @@ transcribe_status decode_rnnt_greedy(const HostDecoderWeights & w,
 // index of this chunk's first frame (so step_at_emit lands in
 // stream-wide coordinates). state_io must have been reset to a fresh
 // start-of-sequence state at stream_begin (last_token_io = -1).
-transcribe_status decode_rnnt_greedy_streaming(
-    const HostDecoderWeights & w,
-    const float *              enc_out,
-    int                        T_enc_new,
-    int                        d_enc,
-    LstmState &                state_io,
-    int &                      last_token_io,
-    int                        frame_offset,
-    int                        n_threads,
-    std::vector<TdtToken> &    out_tokens);
+transcribe_status decode_rnnt_greedy_streaming(const HostDecoderWeights & w,
+                                               const float *              enc_out,
+                                               int                        T_enc_new,
+                                               int                        d_enc,
+                                               LstmState &                state_io,
+                                               int &                      last_token_io,
+                                               int                        frame_offset,
+                                               int                        n_threads,
+                                               std::vector<TdtToken> &    out_tokens);
 
 // Run CTC greedy decode end-to-end. Per-frame: logits = W @ enc[t] + b,
 // argmax; collapse rule "drop adjacent duplicates, then drop blanks"
@@ -267,4 +264,4 @@ transcribe_status decode_ctc_greedy(const HostDecoderWeights & w,
                                     int                        n_threads,
                                     std::vector<TdtToken> &    out_tokens);
 
-} // namespace transcribe::parakeet
+}  // namespace transcribe::parakeet
diff --git a/src/arch/parakeet/encoder.cpp b/src/arch/parakeet/encoder.cpp
index 0d9b4b64..0bea80ee 100644
--- a/src/arch/parakeet/encoder.cpp
+++ b/src/arch/parakeet/encoder.cpp
@@ -22,18 +22,16 @@
 
 #include "encoder.h"
 
-#include "weights.h"
-
 #include "conformer/conformer.h"
+#include "ggml.h"
 #include "transcribe-debug.h"
 #include "transcribe-flash-policy.h"
 #include "transcribe-log.h"
-
-#include "ggml.h"
+#include "weights.h"
 
 #include <algorithm>
-#include <cstdio>
 #include <cmath>
+#include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <vector>
@@ -50,9 +48,8 @@ namespace conf = transcribe::conformer;
 // backend (faster than the 31x im2col expansion). Env vars override
 // both sites.
 bool detect_direct_dw_in_block(const char * backend) {
-    (void)backend;
-    return conf::resolve_conv_direct("TRANSCRIBE_CONV_DIRECT_DW",
-                                     "TRANSCRIBE_CONV_NO_DIRECT_DW",
+    (void) backend;
+    return conf::resolve_conv_direct("TRANSCRIBE_CONV_DIRECT_DW", "TRANSCRIBE_CONV_NO_DIRECT_DW",
                                      /*backend_default=*/true);
 }
 
@@ -62,11 +59,9 @@ bool detect_direct_dw_in_block(const char * backend) {
 // CONV_2D_DW; the direct path avoids the ~31x im2col expansion and the
 // degenerate per-channel [1 x K] matmul (~40-50ms here).
 bool detect_direct_dw_in_pre_encode(const char * backend) {
-    const bool is_metal = backend != nullptr &&
-        (std::strstr(backend, "Metal") != nullptr ||
-         std::strstr(backend, "metal") != nullptr);
-    return conf::resolve_conv_direct("TRANSCRIBE_CONV_DIRECT_DW",
-                                     "TRANSCRIBE_CONV_NO_DIRECT_DW",
+    const bool is_metal =
+        backend != nullptr && (std::strstr(backend, "Metal") != nullptr || std::strstr(backend, "metal") != nullptr);
+    return conf::resolve_conv_direct("TRANSCRIBE_CONV_DIRECT_DW", "TRANSCRIBE_CONV_NO_DIRECT_DW",
                                      /*backend_default=*/!is_metal);
 }
 
@@ -74,12 +69,18 @@ bool detect_direct_dw_in_pre_encode(const char * backend) {
 
 conf::PreEncodeView to_view(const ParakeetPreEncode & pe) {
     conf::PreEncodeView v;
-    v.conv0_w = pe.conv0_w; v.conv0_b = pe.conv0_b;
-    v.conv2_w = pe.conv2_w; v.conv2_b = pe.conv2_b;
-    v.conv3_w = pe.conv3_w; v.conv3_b = pe.conv3_b;
-    v.conv5_w = pe.conv5_w; v.conv5_b = pe.conv5_b;
-    v.conv6_w = pe.conv6_w; v.conv6_b = pe.conv6_b;
-    v.out_w   = pe.out_w;   v.out_b   = pe.out_b;
+    v.conv0_w = pe.conv0_w;
+    v.conv0_b = pe.conv0_b;
+    v.conv2_w = pe.conv2_w;
+    v.conv2_b = pe.conv2_b;
+    v.conv3_w = pe.conv3_w;
+    v.conv3_b = pe.conv3_b;
+    v.conv5_w = pe.conv5_w;
+    v.conv5_b = pe.conv5_b;
+    v.conv6_w = pe.conv6_w;
+    v.conv6_b = pe.conv6_b;
+    v.out_w   = pe.out_w;
+    v.out_b   = pe.out_b;
     return v;
 }
 
@@ -90,7 +91,7 @@ conf::BlockView to_view(const ParakeetBlock & b) {
     v.norm_ff1_w = b.norm_ff1_w;
     v.norm_ff1_b = b.norm_ff1_b;
     v.ff1_lin1_w = b.ff1_lin1_w;
-    v.ff1_lin1_b = b.ff1_lin1_b; // null when use_bias=false
+    v.ff1_lin1_b = b.ff1_lin1_b;  // null when use_bias=false
     v.ff1_lin2_w = b.ff1_lin2_w;
     v.ff1_lin2_b = b.ff1_lin2_b;
 
@@ -98,10 +99,14 @@ conf::BlockView to_view(const ParakeetBlock & b) {
     // is bias-free in NeMo regardless.
     v.norm_attn_w = b.norm_attn_w;
     v.norm_attn_b = b.norm_attn_b;
-    v.attn_q_w    = b.attn_q_w;   v.attn_q_b   = b.attn_q_b;
-    v.attn_k_w    = b.attn_k_w;   v.attn_k_b   = b.attn_k_b;
-    v.attn_v_w    = b.attn_v_w;   v.attn_v_b   = b.attn_v_b;
-    v.attn_out_w  = b.attn_out_w; v.attn_out_b = b.attn_out_b;
+    v.attn_q_w    = b.attn_q_w;
+    v.attn_q_b    = b.attn_q_b;
+    v.attn_k_w    = b.attn_k_w;
+    v.attn_k_b    = b.attn_k_b;
+    v.attn_v_w    = b.attn_v_w;
+    v.attn_v_b    = b.attn_v_b;
+    v.attn_out_w  = b.attn_out_w;
+    v.attn_out_b  = b.attn_out_b;
     v.attn_pos_w  = b.attn_pos_w;
     v.attn_pos_u  = b.attn_pos_u;
     v.attn_pos_v  = b.attn_pos_v;
@@ -147,12 +152,11 @@ struct Block0DumpSink {
     EncoderDumps * dumps;
 };
 
-void parakeet_block0_observer_cb(void *        user,
-                                 const char *  tag,
-                                 ggml_tensor * t)
-{
+void parakeet_block0_observer_cb(void * user, const char * tag, ggml_tensor * t) {
     auto * sink = static_cast<Block0DumpSink *>(user);
-    if (sink == nullptr || sink->dumps == nullptr || t == nullptr) return;
+    if (sink == nullptr || sink->dumps == nullptr || t == nullptr) {
+        return;
+    }
 
     char name_buf[64];
     std::snprintf(name_buf, sizeof(name_buf), "enc.block.0.%s", tag);
@@ -185,25 +189,27 @@ struct SubBlockSink {
     EncoderDumps * dumps;
 };
 
-void parakeet_subblock_observer_cb(void *        user,
-                                   const char *  tag,
-                                   ggml_tensor * t)
-{
+void parakeet_subblock_observer_cb(void * user, const char * tag, ggml_tensor * t) {
     auto * sink = static_cast<SubBlockSink *>(user);
-    if (sink == nullptr || sink->dumps == nullptr || t == nullptr) return;
+    if (sink == nullptr || sink->dumps == nullptr || t == nullptr) {
+        return;
+    }
 
     const char * short_tag = tag;
-    if (std::strcmp(tag, "after_ff1") == 0)  short_tag = "ff1";
-    else if (std::strcmp(tag, "after_attn") == 0) short_tag = "attn";
-    else if (std::strcmp(tag, "after_conv") == 0) short_tag = "conv";
-    else if (std::strcmp(tag, "after_ff2") == 0)  short_tag = "ff2";
-    else if (std::strcmp(tag, "out") == 0) {
-        return; // block.<i>.out covered elsewhere
+    if (std::strcmp(tag, "after_ff1") == 0) {
+        short_tag = "ff1";
+    } else if (std::strcmp(tag, "after_attn") == 0) {
+        short_tag = "attn";
+    } else if (std::strcmp(tag, "after_conv") == 0) {
+        short_tag = "conv";
+    } else if (std::strcmp(tag, "after_ff2") == 0) {
+        short_tag = "ff2";
+    } else if (std::strcmp(tag, "out") == 0) {
+        return;  // block.<i>.out covered elsewhere
     }
 
     char name_buf[64];
-    std::snprintf(name_buf, sizeof(name_buf), "enc.block.%d.%s",
-                  sink->block_idx, short_tag);
+    std::snprintf(name_buf, sizeof(name_buf), "enc.block.%d.%s", sink->block_idx, short_tag);
     ggml_set_name(t, name_buf);
     transcribe::debug::mark_tensor_for_dump(t);
     sink->dumps->sub_block_dumps.emplace_back(std::string(name_buf), t);
@@ -211,19 +217,26 @@ void parakeet_subblock_observer_cb(void *        user,
 
 // Parse "0,12,22,23" into a sorted unique vector of block indices.
 // Returns empty if the env var is unset or empty.
-std::vector<int> parse_sub_block_env(int n_layers)
-{
+std::vector<int> parse_sub_block_env(int n_layers) {
     std::vector<int> out;
-    const char * raw = transcribe::debug::dump_sub_blocks_spec();
-    if (raw == nullptr || *raw == '\0') return out;
+    const char *     raw = transcribe::debug::dump_sub_blocks_spec();
+    if (raw == nullptr || *raw == '\0') {
+        return out;
+    }
     const char * p = raw;
     while (*p != '\0') {
         // Skip leading separators.
-        while (*p == ',' || *p == ' ' || *p == '\t') ++p;
-        if (*p == '\0') break;
+        while (*p == ',' || *p == ' ' || *p == '\t') {
+            ++p;
+        }
+        if (*p == '\0') {
+            break;
+        }
         char * end = nullptr;
-        long v = std::strtol(p, &end, 10);
-        if (end == p) break;  // no progress — malformed
+        long   v   = std::strtol(p, &end, 10);
+        if (end == p) {
+            break;  // no progress — malformed
+        }
         if (v >= 0 && v < n_layers) {
             out.push_back(static_cast<int>(v));
         }
@@ -234,21 +247,22 @@ std::vector<int> parse_sub_block_env(int n_layers)
     return out;
 }
 
-} // namespace
-
-EncoderBuild build_encoder_graph(ggml_context *                      ctx,
-                                 const ParakeetWeights &             w,
-                                 const ParakeetHParams &             hp,
-                                 int                                 n_mel_frames,
-                                 ggml_type                           kv_type,
-                                 const char *                        backend_name,
-                                 const BufferedStreamMaskOverride *  buf_mask,
-                                 int                                 n_batch,
-                                 bool                                batch_var_len)
-{
-    if (n_batch < 1) n_batch = 1;
-    const bool var_len_masks = batch_var_len && n_batch > 1;
-    conf::ConvPolicy policy {};
+}  // namespace
+
+EncoderBuild build_encoder_graph(ggml_context *                     ctx,
+                                 const ParakeetWeights &            w,
+                                 const ParakeetHParams &            hp,
+                                 int                                n_mel_frames,
+                                 ggml_type                          kv_type,
+                                 const char *                       backend_name,
+                                 const BufferedStreamMaskOverride * buf_mask,
+                                 int                                n_batch,
+                                 bool                               batch_var_len) {
+    if (n_batch < 1) {
+        n_batch = 1;
+    }
+    const bool       var_len_masks = batch_var_len && n_batch > 1;
+    conf::ConvPolicy policy{};
     policy.direct_pw               = conf::detect_direct_pw(backend_name);
     policy.direct_dw_in_block      = detect_direct_dw_in_block(backend_name);
     policy.direct_dw_in_pre_encode = detect_direct_dw_in_pre_encode(backend_name);
@@ -256,17 +270,15 @@ EncoderBuild build_encoder_graph(ggml_context *                      ctx,
     // CausalConv2D for the pre-encode subsample (left=k-1, right=stride-1).
     // Inferred from the attention style — only ChunkedLimited is causal.
     // Independent of the conformer conv-module's conv_context.
-    policy.causal_pre_encode =
-        (hp.enc_att_context_style ==
-             ParakeetHParams::AttContextStyle::ChunkedLimited);
+    policy.causal_pre_encode       = (hp.enc_att_context_style == ParakeetHParams::AttContextStyle::ChunkedLimited);
 
-    EncoderBuild eb {};
+    EncoderBuild eb{};
 
     if (ctx == nullptr || n_mel_frames <= 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "parakeet encoder: invalid arg "
-                     "(ctx=%p, n_mel_frames=%d)",
-                     static_cast<void *>(ctx), n_mel_frames);
+                "parakeet encoder: invalid arg "
+                "(ctx=%p, n_mel_frames=%d)",
+                static_cast<void *>(ctx), n_mel_frames);
         return eb;
     }
 
@@ -274,27 +286,25 @@ EncoderBuild build_encoder_graph(ggml_context *                      ctx,
     // a different factor would need a build_pre_encode rework.
     if (hp.enc_subsampling_factor != 8) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "parakeet encoder: unsupported subsampling_factor=%d "
-                     "(only 8 implemented)",
-                     hp.enc_subsampling_factor);
+                "parakeet encoder: unsupported subsampling_factor=%d "
+                "(only 8 implemented)",
+                hp.enc_subsampling_factor);
         return eb;
     }
     if (hp.fe_num_mels <= 0 || (hp.fe_num_mels % hp.enc_subsampling_factor) != 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "parakeet encoder: n_mels=%d not divisible by "
-                     "subsampling_factor=%d",
-                     hp.fe_num_mels, hp.enc_subsampling_factor);
+                "parakeet encoder: n_mels=%d not divisible by "
+                "subsampling_factor=%d",
+                hp.fe_num_mels, hp.enc_subsampling_factor);
         return eb;
     }
 
     // Mel input handle. ne=[T_mel, n_mels, 1, n_batch] matches the
     // MelFrontend's row-major [n_mels, n_frames] byte for byte; utterance
     // b is the contiguous slab at offset b * n_mel_frames * n_mels.
-    eb.mel_in = ggml_new_tensor_4d(ctx, GGML_TYPE_F32,
-                                   n_mel_frames, hp.fe_num_mels, 1, n_batch);
+    eb.mel_in = ggml_new_tensor_4d(ctx, GGML_TYPE_F32, n_mel_frames, hp.fe_num_mels, 1, n_batch);
     if (eb.mel_in == nullptr) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "parakeet encoder: failed to allocate mel_in tensor");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "parakeet encoder: failed to allocate mel_in tensor");
         return eb;
     }
     ggml_set_name(eb.mel_in, "mel.in");
@@ -307,12 +317,10 @@ EncoderBuild build_encoder_graph(ggml_context *                      ctx,
     // enables masked subsampling (zero each conv intermediate's padded
     // time region). Only the non-causal pre-encode is masked.
     conf::PreEncodeValidMasks pe_masks;
-    const bool mask_pre_encode = var_len_masks && !policy.causal_pre_encode;
-    ggml_tensor * x = conf::build_pre_encode(ctx, to_view(w.pre_encode),
-                                             eb.mel_in, policy,
+    const bool                mask_pre_encode = var_len_masks && !policy.causal_pre_encode;
+    ggml_tensor * x = conf::build_pre_encode(ctx, to_view(w.pre_encode), eb.mel_in, policy,
                                              /*name_prefix=*/"enc.pre_encode",
-                                             /*error_tag=*/"parakeet",
-                                             mask_pre_encode ? &pe_masks : nullptr);
+                                             /*error_tag=*/"parakeet", mask_pre_encode ? &pe_masks : nullptr);
     if (mask_pre_encode) {
         eb.pre_encode_mask_s1_in = pe_masks.mask_s1;
         eb.pre_encode_mask_s2_in = pe_masks.mask_s2;
@@ -336,8 +344,8 @@ EncoderBuild build_encoder_graph(ggml_context *                      ctx,
     // on ctc/rnnt.
     if (hp.enc_xscaling) {
         const float scale = std::sqrt(static_cast<float>(hp.enc_d_model));
-        x = ggml_scale(ctx, x, scale);
-        x = conf::named(x, "enc.pre_encode.xscaled");
+        x                 = ggml_scale(ctx, x, scale);
+        x                 = conf::named(x, "enc.pre_encode.xscaled");
     }
 
     // ----- Conformer blocks -----
@@ -356,20 +364,13 @@ EncoderBuild build_encoder_graph(ggml_context *                      ctx,
         // full 2T-1 and uses a separate mask. ChunkedLimitedWithRc engages
         // the mask only when buf_mask is non-null (offline runs full attn).
         const bool is_chunked =
-            (hp.enc_att_context_style ==
-                 ParakeetHParams::AttContextStyle::ChunkedLimited) ||
-            (hp.enc_att_context_style ==
-                 ParakeetHParams::AttContextStyle::ChunkedLimitedWithRc
-             && buf_mask != nullptr);
-        const bool is_local_pe =
-            (!is_chunked) &&
-            (hp.enc_att_context_left >= 0 && hp.enc_att_context_right >= 0);
-        const int64_t pos_len = is_local_pe
-            ? static_cast<int64_t>(hp.enc_att_context_left
-                                   + hp.enc_att_context_right + 1)
-            : (2 * T_enc - 1);
-        eb.pos_emb_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32,
-                                           hp.enc_d_model, pos_len);
+            (hp.enc_att_context_style == ParakeetHParams::AttContextStyle::ChunkedLimited) ||
+            (hp.enc_att_context_style == ParakeetHParams::AttContextStyle::ChunkedLimitedWithRc && buf_mask != nullptr);
+        const bool    is_local_pe = (!is_chunked) && (hp.enc_att_context_left >= 0 && hp.enc_att_context_right >= 0);
+        const int64_t pos_len     = is_local_pe ?
+                                        static_cast<int64_t>(hp.enc_att_context_left + hp.enc_att_context_right + 1) :
+                                        (2 * T_enc - 1);
+        eb.pos_emb_in             = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, hp.enc_d_model, pos_len);
         ggml_set_name(eb.pos_emb_in, "pos_emb.in");
         ggml_set_input(eb.pos_emb_in);
 
@@ -378,20 +379,15 @@ EncoderBuild build_encoder_graph(ggml_context *                      ctx,
         // Broadcasts across heads inside rel_pos_mhsa.
         ggml_tensor * chunked_mask_in = nullptr;
         if (is_chunked) {
-            chunked_mask_in = ggml_new_tensor_4d(ctx, GGML_TYPE_F32,
-                                                 T_enc, T_enc, 1, 1);
+            chunked_mask_in = ggml_new_tensor_4d(ctx, GGML_TYPE_F32, T_enc, T_enc, 1, 1);
             ggml_set_name(chunked_mask_in, "attn.chunked_mask.in");
             ggml_set_input(chunked_mask_in);
             eb.chunked_mask_in = chunked_mask_in;
         }
 
         ggml_tensor * conv_pad_mask_in = nullptr;
-        if (buf_mask != nullptr &&
-            buf_mask->valid_frames >= 0 &&
-            buf_mask->valid_frames < T_enc)
-        {
-            conv_pad_mask_in = ggml_new_tensor_4d(ctx, GGML_TYPE_F32,
-                                                  T_enc, 1, 1, 1);
+        if (buf_mask != nullptr && buf_mask->valid_frames >= 0 && buf_mask->valid_frames < T_enc) {
+            conv_pad_mask_in = ggml_new_tensor_4d(ctx, GGML_TYPE_F32, T_enc, 1, 1, 1);
             ggml_set_name(conv_pad_mask_in, "conv.pad_mask.in");
             ggml_set_input(conv_pad_mask_in);
             eb.conv_pad_mask_in = conv_pad_mask_in;
@@ -409,24 +405,22 @@ EncoderBuild build_encoder_graph(ggml_context *                      ctx,
         //     buffered path is mutually exclusive with offline batching.
         ggml_tensor * attn_pad_mask_in = nullptr;
         if (var_len_masks) {
-            attn_pad_mask_in = ggml_new_tensor_4d(ctx, GGML_TYPE_F32,
-                                                  T_enc, 1, 1, n_batch);
+            attn_pad_mask_in = ggml_new_tensor_4d(ctx, GGML_TYPE_F32, T_enc, 1, 1, n_batch);
             ggml_set_name(attn_pad_mask_in, "attn.pad_mask.in");
             ggml_set_input(attn_pad_mask_in);
             eb.attn_pad_mask_in = attn_pad_mask_in;
 
-            conv_pad_mask_in = ggml_new_tensor_4d(ctx, GGML_TYPE_F32,
-                                                  T_enc, 1, n_batch, 1);
+            conv_pad_mask_in = ggml_new_tensor_4d(ctx, GGML_TYPE_F32, T_enc, 1, n_batch, 1);
             ggml_set_name(conv_pad_mask_in, "conv.pad_mask.batch.in");
             ggml_set_input(conv_pad_mask_in);
             eb.conv_pad_mask_in = conv_pad_mask_in;
         }
 
-        conf::BlockParams bparams {};
-        bparams.d_model           = hp.enc_d_model;
-        bparams.n_head            = hp.enc_n_heads;
-        bparams.conv_kernel       = hp.enc_conv_kernel;
-        bparams.kv_type           = kv_type;
+        conf::BlockParams bparams{};
+        bparams.d_model     = hp.enc_d_model;
+        bparams.n_head      = hp.enc_n_heads;
+        bparams.conv_kernel = hp.enc_conv_kernel;
+        bparams.kv_type     = kv_type;
         // Flash attention by default. Flash batches correctly (the batched
         // encoder output is bit-identical to single-shot flash), so the batch
         // axis does not change the path. TRANSCRIBE_NO_FLASH forces the manual
@@ -436,75 +430,66 @@ EncoderBuild build_encoder_graph(ggml_context *                      ctx,
         // decoder, so the decoder flag is a throwaway.
         bool enc_use_flash = true, dec_use_flash = false;
         transcribe::flash::apply_env_overrides(enc_use_flash, dec_use_flash);
-        bparams.use_flash         = enc_use_flash;
-        bparams.policy            = policy;
-        bparams.att_context_left  = hp.enc_att_context_left;
-        bparams.att_context_right = hp.enc_att_context_right;
-        bparams.att_context_style = is_chunked
-            ? conf::BlockParams::AttContextStyle::ChunkedLimited
-            : conf::BlockParams::AttContextStyle::Regular;
-        bparams.attn_chunked_mask = chunked_mask_in;
+        bparams.use_flash          = enc_use_flash;
+        bparams.policy             = policy;
+        bparams.att_context_left   = hp.enc_att_context_left;
+        bparams.att_context_right  = hp.enc_att_context_right;
+        bparams.att_context_style  = is_chunked ? conf::BlockParams::AttContextStyle::ChunkedLimited :
+                                                  conf::BlockParams::AttContextStyle::Regular;
+        bparams.attn_chunked_mask  = chunked_mask_in;
         bparams.attn_pad_mask      = attn_pad_mask_in;
         bparams.conv_context_left  = hp.enc_conv_context_left;
         bparams.conv_context_right = hp.enc_conv_context_right;
         bparams.conv_pad_mask      = conv_pad_mask_in;
-        bparams.conv_norm_type = (hp.enc_conv_norm_type
-                                  == ParakeetHParams::ConvNormType::LayerNorm)
-            ? conf::BlockParams::ConvNormType::LayerNorm
-            : conf::BlockParams::ConvNormType::BatchNorm;
+        bparams.conv_norm_type     = (hp.enc_conv_norm_type == ParakeetHParams::ConvNormType::LayerNorm) ?
+                                         conf::BlockParams::ConvNormType::LayerNorm :
+                                         conf::BlockParams::ConvNormType::BatchNorm;
 
         // Block 0: shared helper + the dump observer.
         {
-            Block0DumpSink sink { &eb.dumps };
-            conf::BlockObserver obs {};
+            Block0DumpSink      sink{ &eb.dumps };
+            conf::BlockObserver obs{};
             obs.on_point = parakeet_block0_observer_cb;
             obs.user     = &sink;
-            x = conf::build_conformer_block(ctx, x, eb.pos_emb_in,
-                                            to_view(w.blocks[0]),
-                                            bparams, &obs);
+            x            = conf::build_conformer_block(ctx, x, eb.pos_emb_in, to_view(w.blocks[0]), bparams, &obs);
         }
 
         // Blocks 1..N-1. Mark the mid (n/2) and last (n-1) outputs for
         // dump (0/12/23 on 24-layer v2/v3); the file name is synthesized
         // in model.cpp from the saved index because conf::named's trailing
         // "enc.final" rename would otherwise clobber the last-block name.
-        const int n_layers   = static_cast<int>(w.blocks.size());
-        const int mid_layer  = n_layers / 2;
-        const int last_layer = n_layers - 1;
+        const int n_layers      = static_cast<int>(w.blocks.size());
+        const int mid_layer     = n_layers / 2;
+        const int last_layer    = n_layers - 1;
         eb.dumps.mid_block_idx  = mid_layer;
         eb.dumps.last_block_idx = last_layer;
         eb.dumps.all_block_outs.assign(n_layers, nullptr);
         eb.dumps.all_block_outs[0] = eb.dumps.block0_out;
         // Per-block dump opt-in for the divergence bisect
         // (TRANSCRIBE_DUMP_ALL_BLOCKS).
-        const bool dump_all_blocks =
-            transcribe::debug::dump_all_blocks_requested();
+        const bool dump_all_blocks = transcribe::debug::dump_all_blocks_requested();
         if (dump_all_blocks && eb.dumps.block0_out != nullptr) {
             transcribe::debug::mark_tensor_for_dump(eb.dumps.block0_out);
         }
         // Sub-block observation gate (TRANSCRIBE_DUMP_SUB_BLOCKS). Sinks
         // are kept alive for the build (the observer captures their addr).
-        const std::vector<int> sub_blocks = parse_sub_block_env(n_layers);
+        const std::vector<int>    sub_blocks = parse_sub_block_env(n_layers);
         std::vector<SubBlockSink> sub_sinks;
         sub_sinks.reserve(sub_blocks.size());
-        for (int idx : sub_blocks) sub_sinks.push_back(SubBlockSink{idx, &eb.dumps});
+        for (int idx : sub_blocks) {
+            sub_sinks.push_back(SubBlockSink{ idx, &eb.dumps });
+        }
         for (int i = 1; i < n_layers; ++i) {
-            const auto it = std::lower_bound(sub_blocks.begin(),
-                                             sub_blocks.end(), i);
-            const bool with_obs =
-                (it != sub_blocks.end() && *it == i);
+            const auto it       = std::lower_bound(sub_blocks.begin(), sub_blocks.end(), i);
+            const bool with_obs = (it != sub_blocks.end() && *it == i);
             if (with_obs) {
-                const size_t sink_idx =
-                    static_cast<size_t>(it - sub_blocks.begin());
-                conf::BlockObserver obs {};
+                const size_t        sink_idx = static_cast<size_t>(it - sub_blocks.begin());
+                conf::BlockObserver obs{};
                 obs.on_point = parakeet_subblock_observer_cb;
                 obs.user     = &sub_sinks[sink_idx];
-                x = conf::build_conformer_block(ctx, x, eb.pos_emb_in,
-                                                to_view(w.blocks[i]),
-                                                bparams, &obs);
+                x            = conf::build_conformer_block(ctx, x, eb.pos_emb_in, to_view(w.blocks[i]), bparams, &obs);
             } else {
-                x = conf::build_conformer_block(ctx, x, eb.pos_emb_in,
-                                                to_view(w.blocks[i]), bparams);
+                x = conf::build_conformer_block(ctx, x, eb.pos_emb_in, to_view(w.blocks[i]), bparams);
             }
             eb.dumps.all_block_outs[i] = x;
             if (dump_all_blocks) {
@@ -523,7 +508,7 @@ EncoderBuild build_encoder_graph(ggml_context *                      ctx,
 
     // Final encoder output (= last block's norm_out).
     eb.dumps.final_out = x;
-    x = conf::named(x, "enc.final");
+    x                  = conf::named(x, "enc.final");
     transcribe::debug::mark_tensor_for_dump(x);
     // Keep final_out as an output so the host can read it back separately
     // from the prompted output (else the scheduler may free it once eb.out
@@ -546,12 +531,11 @@ EncoderBuild build_encoder_graph(ggml_context *                      ctx,
 
         // Per-utterance one-hot, ne = [num_prompts, T_enc, n_batch, 1]
         // (batch on ne[2] to match the block output layout).
-        ggml_tensor * one_hot = ggml_new_tensor_4d(
-            ctx, GGML_TYPE_F32, P, T_enc_val, B, 1);
+        ggml_tensor * one_hot = ggml_new_tensor_4d(ctx, GGML_TYPE_F32, P, T_enc_val, B, 1);
         if (one_hot == nullptr) {
             log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "parakeet encoder: failed to allocate "
-                         "prompt.one_hot.in tensor");
+                    "parakeet encoder: failed to allocate "
+                    "prompt.one_hot.in tensor");
             return eb;
         }
         ggml_set_name(one_hot, "prompt.one_hot.in");
@@ -559,14 +543,14 @@ EncoderBuild build_encoder_graph(ggml_context *                      ctx,
         eb.prompt_one_hot_in = one_hot;
 
         ggml_tensor * cat = ggml_concat(ctx, x, one_hot, /*dim=*/0);
-        ggml_tensor * h = ggml_mul_mat(ctx, w.prompt.mlp0_w, cat);
-        h = ggml_add(ctx, h, w.prompt.mlp0_b);
-        h = ggml_relu(ctx, h);
-        ggml_tensor * y = ggml_mul_mat(ctx, w.prompt.mlp2_w, h);
-        y = ggml_add(ctx, y, w.prompt.mlp2_b);
+        ggml_tensor * h   = ggml_mul_mat(ctx, w.prompt.mlp0_w, cat);
+        h                 = ggml_add(ctx, h, w.prompt.mlp0_b);
+        h                 = ggml_relu(ctx, h);
+        ggml_tensor * y   = ggml_mul_mat(ctx, w.prompt.mlp2_w, h);
+        y                 = ggml_add(ctx, y, w.prompt.mlp2_b);
 
         eb.dumps.prompted_out = y;
-        y = conf::named(y, "enc.prompted");
+        y                     = conf::named(y, "enc.prompted");
         transcribe::debug::mark_tensor_for_dump(y);
 
         x = y;
@@ -579,8 +563,7 @@ EncoderBuild build_encoder_graph(ggml_context *                      ctx,
     // block contributes ~90 ops, 24 blocks > 2200).
     eb.graph = ggml_new_graph_custom(ctx, /*size=*/8192, /*grads=*/false);
     if (eb.graph == nullptr) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "parakeet encoder: ggml_new_graph_custom failed");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "parakeet encoder: ggml_new_graph_custom failed");
         return eb;
     }
     ggml_build_forward_expand(eb.graph, eb.out);
@@ -614,80 +597,72 @@ EncoderBuild build_encoder_graph(ggml_context *                      ctx,
 //
 // cache_io.channel_in / time_in must come from the persistent cache
 // buffer with the shapes above (the scheduler treats them as inputs).
-EncoderBuild build_encoder_graph_streaming(
-    ggml_context *          ctx,
-    const ParakeetWeights & w,
-    const ParakeetHParams & hp,
-    int                     n_mel_chunk_frames,
-    int                     drop_extra_pre_encoded,
-    StreamingEncoderCacheIO & cache_io,
-    ggml_type               kv_type,
-    const char *            backend_name)
-{
-    conf::ConvPolicy policy {};
+EncoderBuild build_encoder_graph_streaming(ggml_context *            ctx,
+                                           const ParakeetWeights &   w,
+                                           const ParakeetHParams &   hp,
+                                           int                       n_mel_chunk_frames,
+                                           int                       drop_extra_pre_encoded,
+                                           StreamingEncoderCacheIO & cache_io,
+                                           ggml_type                 kv_type,
+                                           const char *              backend_name) {
+    conf::ConvPolicy policy{};
     policy.direct_pw               = conf::detect_direct_pw(backend_name);
     policy.direct_dw_in_block      = detect_direct_dw_in_block(backend_name);
     policy.direct_dw_in_pre_encode = detect_direct_dw_in_pre_encode(backend_name);
     // Causal pre-encode is the cache-aware streaming convention only.
-    policy.causal_pre_encode =
-        (hp.enc_att_context_style ==
-             ParakeetHParams::AttContextStyle::ChunkedLimited);
+    policy.causal_pre_encode       = (hp.enc_att_context_style == ParakeetHParams::AttContextStyle::ChunkedLimited);
 
-    EncoderBuild eb {};
+    EncoderBuild eb{};
 
     if (ctx == nullptr || n_mel_chunk_frames <= 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "parakeet streaming encoder: invalid arg "
-                     "(ctx=%p, n_mel_chunk_frames=%d)",
-                     static_cast<void *>(ctx), n_mel_chunk_frames);
+                "parakeet streaming encoder: invalid arg "
+                "(ctx=%p, n_mel_chunk_frames=%d)",
+                static_cast<void *>(ctx), n_mel_chunk_frames);
         return eb;
     }
 
     if (hp.enc_subsampling_factor != 8) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "parakeet streaming encoder: unsupported "
-                     "subsampling_factor=%d (only 8 implemented)",
-                     hp.enc_subsampling_factor);
+                "parakeet streaming encoder: unsupported "
+                "subsampling_factor=%d (only 8 implemented)",
+                hp.enc_subsampling_factor);
         return eb;
     }
-    if (hp.enc_att_context_style !=
-            ParakeetHParams::AttContextStyle::ChunkedLimited)
-    {
+    if (hp.enc_att_context_style != ParakeetHParams::AttContextStyle::ChunkedLimited) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "parakeet streaming encoder: requires "
-                     "att_context_style=ChunkedLimited");
+                "parakeet streaming encoder: requires "
+                "att_context_style=ChunkedLimited");
         return eb;
     }
 
     const int n_layers = static_cast<int>(w.blocks.size());
     if (static_cast<int>(cache_io.channel_in.size()) != n_layers ||
-        static_cast<int>(cache_io.time_in.size())    != n_layers)
-    {
+        static_cast<int>(cache_io.time_in.size()) != n_layers) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "parakeet streaming encoder: cache_io.in vectors "
-                     "must be sized to n_layers=%d (got channel=%zu, "
-                     "time=%zu)",
-                     n_layers, cache_io.channel_in.size(),
-                     cache_io.time_in.size());
+                "parakeet streaming encoder: cache_io.in vectors "
+                "must be sized to n_layers=%d (got channel=%zu, "
+                "time=%zu)",
+                n_layers, cache_io.channel_in.size(), cache_io.time_in.size());
         return eb;
     }
 
     // ----- Mel chunk input -----
-    eb.mel_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32,
-                                   n_mel_chunk_frames, hp.fe_num_mels);
+    eb.mel_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, n_mel_chunk_frames, hp.fe_num_mels);
     ggml_set_name(eb.mel_in, "stream.mel.in");
     ggml_set_input(eb.mel_in);
 
     // ----- Pre-encode + (optional) xscaling -----
-    ggml_tensor * x = conf::build_pre_encode(ctx, to_view(w.pre_encode),
-                                             eb.mel_in, policy,
+    ggml_tensor * x = conf::build_pre_encode(ctx, to_view(w.pre_encode), eb.mel_in, policy,
                                              /*name_prefix=*/"stream.enc.pre_encode",
                                              /*error_tag=*/"parakeet stream");
-    if (x == nullptr) return eb;
+    if (x == nullptr) {
+        return eb;
+    }
 
     if (hp.enc_xscaling) {
         const float scale = std::sqrt(static_cast<float>(hp.enc_d_model));
-        x = ggml_scale(ctx, x, scale);
+        x                 = ggml_scale(ctx, x, scale);
     }
 
     // x ne = [d_model, T_pre_enc]. Slice off the first
@@ -697,21 +672,18 @@ EncoderBuild build_encoder_graph_streaming(
         const int64_t T_pre = x->ne[1];
         if (drop_extra_pre_encoded >= T_pre) {
             log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "parakeet streaming encoder: drop_extra=%d >= "
-                         "T_pre_enc=%lld",
-                         drop_extra_pre_encoded, (long long)T_pre);
+                    "parakeet streaming encoder: drop_extra=%d >= "
+                    "T_pre_enc=%lld",
+                    drop_extra_pre_encoded, (long long) T_pre);
             return eb;
         }
-        x = ggml_view_2d(ctx, x,
-                         x->ne[0], T_pre - drop_extra_pre_encoded,
-                         x->nb[1],
-                         drop_extra_pre_encoded * x->nb[1]);
+        x = ggml_view_2d(ctx, x, x->ne[0], T_pre - drop_extra_pre_encoded, x->nb[1], drop_extra_pre_encoded * x->nb[1]);
         x = ggml_cont(ctx, x);
     }
 
-    const int64_t T_q_new  = x->ne[1];
-    const int64_t T_cache  = cache_io.channel_in[0]->ne[1];
-    const int64_t T_virt   = T_cache + T_q_new;
+    const int64_t T_q_new = x->ne[1];
+    const int64_t T_cache = cache_io.channel_in[0]->ne[1];
+    const int64_t T_virt  = T_cache + T_q_new;
 
     // Query slicing: attention queries cover only the T_q_new new frames
     // while K/V span the full virtual window, so pos_emb and the mask are
@@ -721,62 +693,57 @@ EncoderBuild build_encoder_graph_streaming(
     // recomputing from the channel cache. Disabled under the dump harness
     // (which compares last_channel against NeMo); the channel-recompute
     // path is bit-identical and produces the last_channel the gate needs.
-    const bool kv_cache_mode =
-        !transcribe::debug::enabled() &&
-        static_cast<int>(cache_io.k_in.size()) == n_layers &&
-        static_cast<int>(cache_io.v_in.size()) == n_layers;
+    const bool kv_cache_mode = !transcribe::debug::enabled() && static_cast<int>(cache_io.k_in.size()) == n_layers &&
+                               static_cast<int>(cache_io.v_in.size()) == n_layers;
 
     // ----- Pos_emb (rectangular: pos_len = T_q + T_kv - 1) -----
     const int64_t pos_len = T_virt + T_q_new - 1;
     // Rel-pos projection memoization: when the driver's cache matches
     // this chunk's pos_len, every block consumes its precomputed
     // projection and the graph needs no pos_emb input at all.
-    const bool pos_proj_hit =
-        cache_io.pos_proj_len == pos_len &&
-        static_cast<int>(cache_io.pos_proj.size()) == n_layers;
+    const bool    pos_proj_hit =
+        cache_io.pos_proj_len == pos_len && static_cast<int>(cache_io.pos_proj.size()) == n_layers;
     if (!pos_proj_hit) {
-        eb.pos_emb_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32,
-                                           hp.enc_d_model, pos_len);
+        eb.pos_emb_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, hp.enc_d_model, pos_len);
         ggml_set_name(eb.pos_emb_in, "stream.pos_emb.in");
         ggml_set_input(eb.pos_emb_in);
     }
 
     // Chunked mask: [T_virtual, T_q_new] (keys x queries). Built host-side.
-    eb.chunked_mask_in = ggml_new_tensor_4d(ctx, GGML_TYPE_F32,
-                                            T_virt, T_q_new,
-                                            1, 1);
+    eb.chunked_mask_in = ggml_new_tensor_4d(ctx, GGML_TYPE_F32, T_virt, T_q_new, 1, 1);
     ggml_set_name(eb.chunked_mask_in, "stream.attn.chunked_mask.in");
     ggml_set_input(eb.chunked_mask_in);
 
     // Create the graph BEFORE the cache_out tensors so the helpers can
     // forward-expand their cpy nodes onto it.
     eb.graph = ggml_new_graph_custom(ctx, /*size=*/8192, /*grads=*/false);
-    if (eb.graph == nullptr) return eb;
+    if (eb.graph == nullptr) {
+        return eb;
+    }
 
-    conf::BlockParams bparams {};
-    bparams.d_model           = hp.enc_d_model;
-    bparams.n_head            = hp.enc_n_heads;
-    bparams.conv_kernel       = hp.enc_conv_kernel;
-    bparams.kv_type           = kv_type;
+    conf::BlockParams bparams{};
+    bparams.d_model     = hp.enc_d_model;
+    bparams.n_head      = hp.enc_n_heads;
+    bparams.conv_kernel = hp.enc_conv_kernel;
+    bparams.kv_type     = kv_type;
     // Flash-attention opt-out (TRANSCRIBE_NO_FLASH / TRANSCRIBE_FORCE_FLASH).
     // On CPU at streaming geometry the flash kernel is dramatically slower
     // (~33 ms/layer vs ~1 ms on a Cortex-A55). Parakeet has no attention
     // decoder, so the decoder flag is a throwaway.
     bool enc_use_flash = true, dec_use_flash = false;
     transcribe::flash::apply_env_overrides(enc_use_flash, dec_use_flash);
-    bparams.use_flash         = enc_use_flash;
-    bparams.policy            = policy;
+    bparams.use_flash          = enc_use_flash;
+    bparams.policy             = policy;
     // No att_context_left/right: ChunkedLimited derives the band entirely
     // from attn_chunked_mask (build_conformer_block reads them only on the
     // Regular path, never taken here).
-    bparams.att_context_style = conf::BlockParams::AttContextStyle::ChunkedLimited;
-    bparams.attn_chunked_mask = eb.chunked_mask_in;
+    bparams.att_context_style  = conf::BlockParams::AttContextStyle::ChunkedLimited;
+    bparams.attn_chunked_mask  = eb.chunked_mask_in;
     bparams.conv_context_left  = hp.enc_conv_context_left;
     bparams.conv_context_right = hp.enc_conv_context_right;
-    bparams.conv_norm_type = (hp.enc_conv_norm_type
-                              == ParakeetHParams::ConvNormType::LayerNorm)
-        ? conf::BlockParams::ConvNormType::LayerNorm
-        : conf::BlockParams::ConvNormType::BatchNorm;
+    bparams.conv_norm_type     = (hp.enc_conv_norm_type == ParakeetHParams::ConvNormType::LayerNorm) ?
+                                     conf::BlockParams::ConvNormType::LayerNorm :
+                                     conf::BlockParams::ConvNormType::BatchNorm;
     bparams.streaming_graph    = eb.graph;
     bparams.streaming_T_q_new  = static_cast<int>(T_q_new);
 
@@ -792,9 +759,10 @@ EncoderBuild build_encoder_graph_streaming(
         // Per-layer cache I/O: "in" from the persistent buffer, "out"
         // fresh in compute_ctx (filled via ggml_cpy, read after compute).
         // KV mode leaves channel_out null.
-        ggml_tensor * cache_tm_out = ggml_new_tensor_2d(
-            ctx, GGML_TYPE_F32, k_minus_1, hp.enc_d_model);
-        if (cache_tm_out == nullptr) return eb;
+        ggml_tensor * cache_tm_out = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, k_minus_1, hp.enc_d_model);
+        if (cache_tm_out == nullptr) {
+            return eb;
+        }
         char nm[64];
         std::snprintf(nm, sizeof(nm), "stream.cache_tm_out.%d", i);
         ggml_set_name(cache_tm_out, nm);
@@ -804,11 +772,11 @@ EncoderBuild build_encoder_graph_streaming(
         ggml_tensor * cache_k_out  = nullptr;
         ggml_tensor * cache_v_out  = nullptr;
         if (kv_cache_mode) {
-            cache_k_out = ggml_new_tensor_2d(
-                ctx, GGML_TYPE_F32, hp.enc_d_model, T_cache);
-            cache_v_out = ggml_new_tensor_2d(
-                ctx, GGML_TYPE_F32, hp.enc_d_model, T_cache);
-            if (cache_k_out == nullptr || cache_v_out == nullptr) return eb;
+            cache_k_out = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, hp.enc_d_model, T_cache);
+            cache_v_out = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, hp.enc_d_model, T_cache);
+            if (cache_k_out == nullptr || cache_v_out == nullptr) {
+                return eb;
+            }
             std::snprintf(nm, sizeof(nm), "stream.cache_k_out.%d", i);
             ggml_set_name(cache_k_out, nm);
             std::snprintf(nm, sizeof(nm), "stream.cache_v_out.%d", i);
@@ -816,9 +784,10 @@ EncoderBuild build_encoder_graph_streaming(
             ggml_set_output(cache_k_out);
             ggml_set_output(cache_v_out);
         } else {
-            cache_ch_out = ggml_new_tensor_2d(
-                ctx, GGML_TYPE_F32, hp.enc_d_model, T_cache);
-            if (cache_ch_out == nullptr) return eb;
+            cache_ch_out = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, hp.enc_d_model, T_cache);
+            if (cache_ch_out == nullptr) {
+                return eb;
+            }
             std::snprintf(nm, sizeof(nm), "stream.cache_ch_out.%d", i);
             ggml_set_name(cache_ch_out, nm);
             ggml_set_output(cache_ch_out);
@@ -828,16 +797,13 @@ EncoderBuild build_encoder_graph_streaming(
         bparams.streaming_channel_out = cache_ch_out;
         bparams.streaming_time_in     = cache_io.time_in[i];
         bparams.streaming_time_out    = cache_tm_out;
-        bparams.streaming_pos_proj_in =
-            pos_proj_hit ? cache_io.pos_proj[i] : nullptr;
-        bparams.streaming_kv_k_in  = kv_cache_mode ? cache_io.k_in[i] : nullptr;
-        bparams.streaming_kv_v_in  = kv_cache_mode ? cache_io.v_in[i] : nullptr;
-        bparams.streaming_kv_k_out = cache_k_out;
-        bparams.streaming_kv_v_out = cache_v_out;
-
-        x = conf::build_conformer_block(ctx, x, eb.pos_emb_in,
-                                        to_view(w.blocks[i]),
-                                        bparams,
+        bparams.streaming_pos_proj_in = pos_proj_hit ? cache_io.pos_proj[i] : nullptr;
+        bparams.streaming_kv_k_in     = kv_cache_mode ? cache_io.k_in[i] : nullptr;
+        bparams.streaming_kv_v_in     = kv_cache_mode ? cache_io.v_in[i] : nullptr;
+        bparams.streaming_kv_k_out    = cache_k_out;
+        bparams.streaming_kv_v_out    = cache_v_out;
+
+        x = conf::build_conformer_block(ctx, x, eb.pos_emb_in, to_view(w.blocks[i]), bparams,
                                         /*obs=*/nullptr);
 
         cache_io.channel_out[i] = cache_ch_out;
@@ -851,7 +817,7 @@ EncoderBuild build_encoder_graph_streaming(
     // Tag the streaming per-chunk encoder output so the host-side dump
     // sees the same name as the offline path.
     eb.dumps.final_out = x;
-    x = conf::named(x, "enc.final");
+    x                  = conf::named(x, "enc.final");
     transcribe::debug::mark_tensor_for_dump(x);
     if (hp.has_prompt) {
         ggml_set_output(x);
@@ -861,15 +827,14 @@ EncoderBuild build_encoder_graph_streaming(
     // variants). Same forward as the offline path; only the T axis
     // size differs (T_q_new instead of full T_enc).
     if (hp.has_prompt) {
-        const int T_q   = static_cast<int>(x->ne[1]);
-        const int P     = hp.prompt_num_prompts;
+        const int T_q = static_cast<int>(x->ne[1]);
+        const int P   = hp.prompt_num_prompts;
 
-        ggml_tensor * one_hot = ggml_new_tensor_4d(
-            ctx, GGML_TYPE_F32, P, T_q, 1, 1);
+        ggml_tensor * one_hot = ggml_new_tensor_4d(ctx, GGML_TYPE_F32, P, T_q, 1, 1);
         if (one_hot == nullptr) {
             log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "parakeet streaming encoder: failed to allocate "
-                         "prompt.one_hot.in tensor");
+                    "parakeet streaming encoder: failed to allocate "
+                    "prompt.one_hot.in tensor");
             return eb;
         }
         ggml_set_name(one_hot, "prompt.one_hot.in");
@@ -878,13 +843,13 @@ EncoderBuild build_encoder_graph_streaming(
 
         ggml_tensor * cat = ggml_concat(ctx, x, one_hot, /*dim=*/0);
         ggml_tensor * h   = ggml_mul_mat(ctx, w.prompt.mlp0_w, cat);
-        h = ggml_add(ctx, h, w.prompt.mlp0_b);
-        h = ggml_relu(ctx, h);
-        ggml_tensor * y = ggml_mul_mat(ctx, w.prompt.mlp2_w, h);
-        y = ggml_add(ctx, y, w.prompt.mlp2_b);
+        h                 = ggml_add(ctx, h, w.prompt.mlp0_b);
+        h                 = ggml_relu(ctx, h);
+        ggml_tensor * y   = ggml_mul_mat(ctx, w.prompt.mlp2_w, h);
+        y                 = ggml_add(ctx, y, w.prompt.mlp2_b);
 
         eb.dumps.prompted_out = y;
-        y = conf::named(y, "enc.prompted");
+        y                     = conf::named(y, "enc.prompted");
         transcribe::debug::mark_tensor_for_dump(y);
         x = y;
     }
@@ -898,4 +863,4 @@ EncoderBuild build_encoder_graph_streaming(
     return eb;
 }
 
-} // namespace transcribe::parakeet
+}  // namespace transcribe::parakeet
diff --git a/src/arch/parakeet/encoder.h b/src/arch/parakeet/encoder.h
index 2a061f6c..23f94270 100644
--- a/src/arch/parakeet/encoder.h
+++ b/src/arch/parakeet/encoder.h
@@ -7,7 +7,7 @@
 
 #pragma once
 
-#include "ggml.h" // ggml_type
+#include "ggml.h"  // ggml_type
 
 #include <string>
 #include <utility>
@@ -43,7 +43,7 @@ struct ParakeetWeights;
 // building, or the scheduler may reuse its buffer before the dump pass.
 struct EncoderDumps {
     // Pre-encode. ne=[d_model, T_enc, 1, 1].
-    ggml_tensor * pre_encode_out = nullptr;
+    ggml_tensor * pre_encode_out    = nullptr;
     // Block 0 sub-step outputs. Each ne=[d_model, T_enc, 1, 1].
     ggml_tensor * block0_after_ff1  = nullptr;
     ggml_tensor * block0_after_attn = nullptr;
@@ -54,12 +54,12 @@ struct EncoderDumps {
     // final_out. Layer indices synthesize file names like
     // "enc.block.21.out" because conf::named renames in place and the
     // trailing "enc.final" rename overwrites the spot-check name.
-    ggml_tensor * mid_block_out  = nullptr;
-    ggml_tensor * last_block_out = nullptr;
-    int           mid_block_idx  = -1;
-    int           last_block_idx = -1;
+    ggml_tensor * mid_block_out     = nullptr;
+    ggml_tensor * last_block_out    = nullptr;
+    int           mid_block_idx     = -1;
+    int           last_block_idx    = -1;
     // Final encoder output. Aliases last_block_out (same pointer).
-    ggml_tensor * final_out = nullptr;
+    ggml_tensor * final_out         = nullptr;
 
     // All-block output handles for the layer-by-layer divergence bisect.
     // Populated unconditionally; mark_tensor_for_dump is only called on
@@ -143,7 +143,7 @@ struct EncoderBuild {
     // Named intermediate handles for the dump harness. Any field
     // that's nullptr is "not yet wired in this sub-stage" and the
     // driver simply skips it.
-    EncoderDumps dumps {};
+    EncoderDumps dumps{};
 
     // The forward graph. ggml_build_forward_expand has been called
     // with `out`.
@@ -185,20 +185,20 @@ struct BufferedStreamMaskOverride {
 // handle becomes ne=[n_mel_frames, n_mels, 1, n_batch] and `out` becomes
 // ne=[d_model, T_enc, n_batch]. Variable-length batching pads to a common
 // n_mel_frames and masks the overhang — that masking is the caller's job.
-EncoderBuild build_encoder_graph(ggml_context *          compute_ctx,
-                                 const ParakeetWeights & weights,
-                                 const ParakeetHParams & hp,
-                                 int                     n_mel_frames,
-                                 ggml_type               kv_type = GGML_TYPE_COUNT,
-                                 const char *            backend_name = "",
-                                 const BufferedStreamMaskOverride * buf_mask = nullptr,
-                                 int                     n_batch = 1,
+EncoderBuild build_encoder_graph(ggml_context *                     compute_ctx,
+                                 const ParakeetWeights &            weights,
+                                 const ParakeetHParams &            hp,
+                                 int                                n_mel_frames,
+                                 ggml_type                          kv_type       = GGML_TYPE_COUNT,
+                                 const char *                       backend_name  = "",
+                                 const BufferedStreamMaskOverride * buf_mask      = nullptr,
+                                 int                                n_batch       = 1,
                                  // When true and n_batch > 1, allocate the
                                  // variable-length batch masks (attn_pad_mask_in
                                  // + conv_pad_mask_in sized for the batch) and
                                  // wire them into every conformer block. The
                                  // driver fills them from per-utterance lengths.
-                                 bool                    batch_var_len = false);
+                                 bool                               batch_var_len = false);
 
 // Per-layer streaming cache I/O for the streaming encoder graph.
 // The inputs are persistent backend tensors (allocated outside the
@@ -263,14 +263,13 @@ struct StreamingEncoderCacheIO {
 // with per-layer tensor handles from the persistent cache buffer.
 // `cache_io.channel_out` and `cache_io.time_out` are populated by
 // this function.
-EncoderBuild build_encoder_graph_streaming(
-    ggml_context *          compute_ctx,
-    const ParakeetWeights & weights,
-    const ParakeetHParams & hp,
-    int                     n_mel_chunk_frames,
-    int                     drop_extra_pre_encoded,
-    StreamingEncoderCacheIO & cache_io,
-    ggml_type               kv_type = GGML_TYPE_COUNT,
-    const char *            backend_name = "");
+EncoderBuild build_encoder_graph_streaming(ggml_context *            compute_ctx,
+                                           const ParakeetWeights &   weights,
+                                           const ParakeetHParams &   hp,
+                                           int                       n_mel_chunk_frames,
+                                           int                       drop_extra_pre_encoded,
+                                           StreamingEncoderCacheIO & cache_io,
+                                           ggml_type                 kv_type      = GGML_TYPE_COUNT,
+                                           const char *              backend_name = "");
 
-} // namespace transcribe::parakeet
+}  // namespace transcribe::parakeet
diff --git a/src/arch/parakeet/model.cpp b/src/arch/parakeet/model.cpp
index 02d14914..4da16b79 100644
--- a/src/arch/parakeet/model.cpp
+++ b/src/arch/parakeet/model.cpp
@@ -9,27 +9,23 @@
 // run() computes the mel front-end, runs the encoder graph, then
 // host-decodes (predictor + joint + TDT).
 
-#include "parakeet.h"
-
 #include "decoder.h"
 #include "encoder.h"
-#include "weights.h"
-
-#include "transcribe/parakeet.h"
-
+#include "ggml-alloc.h"
+#include "ggml-backend.h"
+#include "ggml.h"
+#include "gguf.h"
+#include "parakeet.h"
 #include "transcribe-arch.h"
 #include "transcribe-batch-util.h"
 #include "transcribe-debug.h"
 #include "transcribe-load-common.h"
 #include "transcribe-loader.h"
+#include "transcribe-log.h"
 #include "transcribe-mel.h"
 #include "transcribe-meta.h"
-#include "transcribe-log.h"
-
-#include "ggml.h"
-#include "ggml-alloc.h"
-#include "ggml-backend.h"
-#include "gguf.h"
+#include "transcribe/parakeet.h"
+#include "weights.h"
 
 // No backend-specific #includes: ggml's device registry discovers
 // Metal/Vulkan/CUDA/BLAS at runtime.
@@ -40,11 +36,11 @@
 #include <cstdint>
 #include <cstdio>
 #include <cstring>
-#include <set>
 #include <fstream>
 #include <ios>
 #include <limits>
 #include <memory>
+#include <set>
 #include <string>
 #include <thread>
 #include <type_traits>
@@ -56,7 +52,7 @@ namespace transcribe::parakeet {
 // Forward declaration; full definition at the bottom of the file.
 extern const Arch arch;
 
-static_assert(std::is_base_of_v<transcribe_model,   ParakeetModel>);
+static_assert(std::is_base_of_v<transcribe_model, ParakeetModel>);
 static_assert(std::is_base_of_v<transcribe_session, ParakeetSession>);
 
 ParakeetSession::~ParakeetSession() {
@@ -130,9 +126,7 @@ ParakeetModel::~ParakeetModel() {
         ggml_backend_buffer_free(backend_buffer);
         backend_buffer = nullptr;
     }
-    for (auto it = plan.scheduler_list.rbegin();
-         it != plan.scheduler_list.rend(); ++it)
-    {
+    for (auto it = plan.scheduler_list.rbegin(); it != plan.scheduler_list.rend(); ++it) {
         ggml_backend_free(*it);
     }
     plan.scheduler_list.clear();
@@ -149,16 +143,17 @@ constexpr float kBnEps = 1e-5f;
 // BCP-47 codes ("en-US") and short aliases ("en"); exact-string lookup.
 // Empty/null hint maps to the dictionary's auto slot (prompt.auto_id);
 // unknown hints return -1 (caller surfaces UNSUPPORTED_LANGUAGE).
-int32_t resolve_prompt_id(const ParakeetHParams & hp,
-                          const char *            language_hint)
-{
-    if (!hp.has_prompt) return -1;
-    const bool empty_hint =
-        (language_hint == nullptr) || (*language_hint == '\0');
+int32_t resolve_prompt_id(const ParakeetHParams & hp, const char * language_hint) {
+    if (!hp.has_prompt) {
+        return -1;
+    }
+    const bool empty_hint = (language_hint == nullptr) || (*language_hint == '\0');
     if (empty_hint) {
         // Auto-language slot; fall back to the dictionary's first entry
         // when there is no explicit auto_id.
-        if (hp.prompt_auto_id >= 0) return hp.prompt_auto_id;
+        if (hp.prompt_auto_id >= 0) {
+            return hp.prompt_auto_id;
+        }
         if (!hp.prompt_dictionary_indices.empty()) {
             return hp.prompt_dictionary_indices.front();
         }
@@ -176,28 +171,23 @@ int32_t resolve_prompt_id(const ParakeetHParams & hp,
 // column prompt_id of each utterance, replicated across T_enc (one id
 // per utterance in prompt_ids). Host-side replication keeps the in-graph
 // step a single concat + two matmuls. Returns false if any id is OOR.
-bool fill_prompt_one_hot(std::vector<float> &        out,
-                         int                         num_prompts,
-                         int                         T_enc,
-                         int                         n_batch,
-                         const std::vector<int32_t> & prompt_ids)
-{
-    const size_t total = static_cast<size_t>(num_prompts) *
-                         static_cast<size_t>(T_enc) *
-                         static_cast<size_t>(n_batch);
+bool fill_prompt_one_hot(std::vector<float> &         out,
+                         int                          num_prompts,
+                         int                          T_enc,
+                         int                          n_batch,
+                         const std::vector<int32_t> & prompt_ids) {
+    const size_t total = static_cast<size_t>(num_prompts) * static_cast<size_t>(T_enc) * static_cast<size_t>(n_batch);
     out.assign(total, 0.0f);
     for (int b = 0; b < n_batch; ++b) {
-        const int32_t pid =
-            (b < static_cast<int>(prompt_ids.size()))
-                ? prompt_ids[static_cast<size_t>(b)]
-                : (prompt_ids.empty() ? -1 : prompt_ids.front());
-        if (pid < 0 || pid >= num_prompts) return false;
-        const size_t per_utt = static_cast<size_t>(num_prompts) *
-                               static_cast<size_t>(T_enc);
+        const int32_t pid = (b < static_cast<int>(prompt_ids.size())) ? prompt_ids[static_cast<size_t>(b)] :
+                                                                        (prompt_ids.empty() ? -1 : prompt_ids.front());
+        if (pid < 0 || pid >= num_prompts) {
+            return false;
+        }
+        const size_t per_utt = static_cast<size_t>(num_prompts) * static_cast<size_t>(T_enc);
         const size_t utt_off = static_cast<size_t>(b) * per_utt;
         for (int t = 0; t < T_enc; ++t) {
-            const size_t row_off = utt_off +
-                static_cast<size_t>(t) * static_cast<size_t>(num_prompts);
+            const size_t row_off = utt_off + static_cast<size_t>(t) * static_cast<size_t>(num_prompts);
             out[row_off + static_cast<size_t>(pid)] = 1.0f;
         }
     }
@@ -212,27 +202,32 @@ bool fill_prompt_one_hot(std::vector<float> &        out,
 // at load and referenced by the encoder graph in place of the raw BN.
 transcribe_status fuse_batch_norm(ParakeetModel & m) {
     const size_t n_blocks = m.weights.blocks.size();
-    if (n_blocks == 0) return TRANSCRIBE_OK;
+    if (n_blocks == 0) {
+        return TRANSCRIBE_OK;
+    }
 
-    const int64_t d = m.hparams.enc_d_model;
-    const size_t tensor_bytes = static_cast<size_t>(d) * sizeof(float);
+    const int64_t d            = m.hparams.enc_d_model;
+    const size_t  tensor_bytes = static_cast<size_t>(d) * sizeof(float);
 
-    const size_t ctx_size = n_blocks * 2 * ggml_tensor_overhead() + 256;
-    ggml_init_params params = {ctx_size, nullptr, /*no_alloc=*/true};
-    m.bn_fused_ctx = ggml_init(params);
-    if (m.bn_fused_ctx == nullptr) return TRANSCRIBE_ERR_BACKEND;
+    const size_t     ctx_size = n_blocks * 2 * ggml_tensor_overhead() + 256;
+    ggml_init_params params   = { ctx_size, nullptr, /*no_alloc=*/true };
+    m.bn_fused_ctx            = ggml_init(params);
+    if (m.bn_fused_ctx == nullptr) {
+        return TRANSCRIBE_ERR_BACKEND;
+    }
 
     // Create all tensors first, then allocate a buffer.
     for (size_t i = 0; i < n_blocks; ++i) {
-        auto & b = m.weights.blocks[i];
+        auto & b              = m.weights.blocks[i];
         b.conv_bn_fused_scale = ggml_new_tensor_1d(m.bn_fused_ctx, GGML_TYPE_F32, d);
         b.conv_bn_fused_bias  = ggml_new_tensor_1d(m.bn_fused_ctx, GGML_TYPE_F32, d);
     }
 
     // Allocate on the CPU backend (always last in the scheduler list).
-    m.bn_fused_buffer = ggml_backend_alloc_ctx_tensors(
-        m.bn_fused_ctx, m.plan.scheduler_list.back());
-    if (m.bn_fused_buffer == nullptr) return TRANSCRIBE_ERR_BACKEND;
+    m.bn_fused_buffer = ggml_backend_alloc_ctx_tensors(m.bn_fused_ctx, m.plan.scheduler_list.back());
+    if (m.bn_fused_buffer == nullptr) {
+        return TRANSCRIBE_ERR_BACKEND;
+    }
 
     // Compute fused values from the raw BN tensors.
     std::vector<float> bn_w(d), bn_b(d), rm(d), rv(d);
@@ -240,19 +235,19 @@ transcribe_status fuse_batch_norm(ParakeetModel & m) {
 
     for (size_t i = 0; i < n_blocks; ++i) {
         auto & b = m.weights.blocks[i];
-        ggml_backend_tensor_get(b.conv_bn_w,  bn_w.data(), 0, tensor_bytes);
-        ggml_backend_tensor_get(b.conv_bn_b,  bn_b.data(), 0, tensor_bytes);
-        ggml_backend_tensor_get(b.conv_bn_rm, rm.data(),   0, tensor_bytes);
-        ggml_backend_tensor_get(b.conv_bn_rv, rv.data(),   0, tensor_bytes);
+        ggml_backend_tensor_get(b.conv_bn_w, bn_w.data(), 0, tensor_bytes);
+        ggml_backend_tensor_get(b.conv_bn_b, bn_b.data(), 0, tensor_bytes);
+        ggml_backend_tensor_get(b.conv_bn_rm, rm.data(), 0, tensor_bytes);
+        ggml_backend_tensor_get(b.conv_bn_rv, rv.data(), 0, tensor_bytes);
 
         for (int64_t c = 0; c < d; ++c) {
             const float s = bn_w[c] / std::sqrt(rv[c] + kBnEps);
-            fused_s[c] = s;
-            fused_b[c] = bn_b[c] - rm[c] * s;
+            fused_s[c]    = s;
+            fused_b[c]    = bn_b[c] - rm[c] * s;
         }
 
         ggml_backend_tensor_set(b.conv_bn_fused_scale, fused_s.data(), 0, tensor_bytes);
-        ggml_backend_tensor_set(b.conv_bn_fused_bias,  fused_b.data(), 0, tensor_bytes);
+        ggml_backend_tensor_set(b.conv_bn_fused_bias, fused_b.data(), 0, tensor_bytes);
     }
 
     return TRANSCRIBE_OK;
@@ -268,15 +263,14 @@ transcribe_status promote_conv_pw_to_f32_on_cpu(ParakeetModel & m) {
     slots.reserve(m.weights.blocks.size() * 2);
     for (auto & b : m.weights.blocks) {
         if (b.conv_pw1_w != nullptr && b.conv_pw1_w->type == GGML_TYPE_F16) {
-            slots.push_back({&b.conv_pw1_w, b.conv_pw1_w});
+            slots.push_back({ &b.conv_pw1_w, b.conv_pw1_w });
         }
         if (b.conv_pw2_w != nullptr && b.conv_pw2_w->type == GGML_TYPE_F16) {
-            slots.push_back({&b.conv_pw2_w, b.conv_pw2_w});
+            slots.push_back({ &b.conv_pw2_w, b.conv_pw2_w });
         }
     }
-    return load_common::promote_conv_pw_f16_to_f32_on_cpu(
-        m.plan, slots, "parakeet",
-        &m.conv_pw_f32_ctx, &m.conv_pw_f32_buffer);
+    return load_common::promote_conv_pw_f16_to_f32_on_cpu(m.plan, slots, "parakeet", &m.conv_pw_f32_ctx,
+                                                          &m.conv_pw_f32_buffer);
 }
 
 // Default variant string when the GGUF did not carry stt.variant.
@@ -288,38 +282,34 @@ constexpr const char k_default_variant[] = "tdt-0.6b-v2";
 // ParakeetStreamingCaches in parakeet.h). The tensors live in their own
 // ggml_context + backend buffer on the primary backend (freed in the
 // dtor). Idempotent; zero_streaming_caches clears contents separately.
-transcribe_status init_streaming_caches(ParakeetSession * pc,
-                                        ParakeetModel *   pm)
-{
-    if (pc->stream_caches.initialized) return TRANSCRIBE_OK;
+transcribe_status init_streaming_caches(ParakeetSession * pc, ParakeetModel * pm) {
+    if (pc->stream_caches.initialized) {
+        return TRANSCRIBE_OK;
+    }
 
     const auto & hp        = pm->hparams;
     const int    n_layer   = static_cast<int>(pm->weights.blocks.size());
     const int    d_model   = hp.enc_d_model;
     const int    T_cache   = hp.enc_att_context_left;
-    const int    k_minus_1 = hp.enc_conv_context_left >= 0
-                             ? hp.enc_conv_context_left
-                             : (hp.enc_conv_kernel - 1);
+    const int    k_minus_1 = hp.enc_conv_context_left >= 0 ? hp.enc_conv_context_left : (hp.enc_conv_kernel - 1);
 
     if (n_layer <= 0 || d_model <= 0 || T_cache <= 0 || k_minus_1 <= 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "parakeet stream init_caches: degenerate sizes "
-                     "(n_layer=%d, d_model=%d, T_cache=%d, k-1=%d)",
-                     n_layer, d_model, T_cache, k_minus_1);
+                "parakeet stream init_caches: degenerate sizes "
+                "(n_layer=%d, d_model=%d, T_cache=%d, k-1=%d)",
+                n_layer, d_model, T_cache, k_minus_1);
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
 
     // 4 tensors per layer (last_channel/time/k/v) plus graph-build headroom.
-    const size_t ctx_size =
-        static_cast<size_t>(4 * n_layer + 8) * ggml_tensor_overhead();
-    ggml_init_params ip {};
-    ip.mem_size   = ctx_size;
-    ip.mem_buffer = nullptr;
-    ip.no_alloc   = true;
+    const size_t     ctx_size = static_cast<size_t>(4 * n_layer + 8) * ggml_tensor_overhead();
+    ggml_init_params ip{};
+    ip.mem_size           = ctx_size;
+    ip.mem_buffer         = nullptr;
+    ip.no_alloc           = true;
     pc->stream_caches.ctx = ggml_init(ip);
     if (pc->stream_caches.ctx == nullptr) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "parakeet stream init_caches: ggml_init failed");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "parakeet stream init_caches: ggml_init failed");
         return TRANSCRIBE_ERR_OOM;
     }
 
@@ -328,21 +318,11 @@ transcribe_status init_streaming_caches(ParakeetSession * pc,
     pc->stream_caches.last_k.assign(n_layer, nullptr);
     pc->stream_caches.last_v.assign(n_layer, nullptr);
     for (int i = 0; i < n_layer; ++i) {
-        ggml_tensor * lc = ggml_new_tensor_2d(pc->stream_caches.ctx,
-                                              GGML_TYPE_F32,
-                                              d_model, T_cache);
-        ggml_tensor * lt = ggml_new_tensor_2d(pc->stream_caches.ctx,
-                                              GGML_TYPE_F32,
-                                              k_minus_1, d_model);
-        ggml_tensor * lk = ggml_new_tensor_2d(pc->stream_caches.ctx,
-                                              GGML_TYPE_F32,
-                                              d_model, T_cache);
-        ggml_tensor * lv = ggml_new_tensor_2d(pc->stream_caches.ctx,
-                                              GGML_TYPE_F32,
-                                              d_model, T_cache);
-        if (lc == nullptr || lt == nullptr ||
-            lk == nullptr || lv == nullptr)
-        {
+        ggml_tensor * lc = ggml_new_tensor_2d(pc->stream_caches.ctx, GGML_TYPE_F32, d_model, T_cache);
+        ggml_tensor * lt = ggml_new_tensor_2d(pc->stream_caches.ctx, GGML_TYPE_F32, k_minus_1, d_model);
+        ggml_tensor * lk = ggml_new_tensor_2d(pc->stream_caches.ctx, GGML_TYPE_F32, d_model, T_cache);
+        ggml_tensor * lv = ggml_new_tensor_2d(pc->stream_caches.ctx, GGML_TYPE_F32, d_model, T_cache);
+        if (lc == nullptr || lt == nullptr || lk == nullptr || lv == nullptr) {
             ggml_free(pc->stream_caches.ctx);
             pc->stream_caches.ctx = nullptr;
             return TRANSCRIBE_ERR_OOM;
@@ -362,11 +342,9 @@ transcribe_status init_streaming_caches(ParakeetSession * pc,
         pc->stream_caches.last_v[i]       = lv;
     }
 
-    pc->stream_caches.buffer =
-        ggml_backend_alloc_ctx_tensors(pc->stream_caches.ctx, pm->plan.primary);
+    pc->stream_caches.buffer = ggml_backend_alloc_ctx_tensors(pc->stream_caches.ctx, pm->plan.primary);
     if (pc->stream_caches.buffer == nullptr) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "parakeet stream init_caches: backend buffer alloc failed");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "parakeet stream init_caches: backend buffer alloc failed");
         ggml_free(pc->stream_caches.ctx);
         pc->stream_caches.ctx = nullptr;
         return TRANSCRIBE_ERR_BACKEND;
@@ -393,10 +371,8 @@ void zero_streaming_caches(ParakeetSession * pc) {
 
 // Reset the streaming decoder state (LSTM h/c, prev token, frame offset)
 // to the model's predictor sizing.
-void reset_streaming_decoder_state(ParakeetSession * pc,
-                                   const ParakeetModel * pm)
-{
-    const auto & pred = pm->host_decoder.predictor;
+void reset_streaming_decoder_state(ParakeetSession * pc, const ParakeetModel * pm) {
+    const auto & pred        = pm->host_decoder.predictor;
     const int    n_layers    = static_cast<int>(pred.lstm.size());
     const int    pred_hidden = pred.pred_hidden;
 
@@ -407,24 +383,17 @@ void reset_streaming_decoder_state(ParakeetSession * pc,
 }
 
 // Forward declarations for the Arch trait below.
-extern transcribe_status load        (Loader &, const transcribe_model_load_params *,
-                                      transcribe_model **);
-extern transcribe_status init_context(transcribe_model *, const transcribe_session_params *,
-                                      transcribe_session **);
-extern transcribe_status run         (transcribe_session *, const float *, int,
-                                      const transcribe_run_params *);
-
-transcribe_status load(
-    Loader &                          loader,
-    const transcribe_model_load_params *   params,
-    transcribe_model **               out_model)
-{
+extern transcribe_status load(Loader &, const transcribe_model_load_params *, transcribe_model **);
+extern transcribe_status init_context(transcribe_model *, const transcribe_session_params *, transcribe_session **);
+extern transcribe_status run(transcribe_session *, const float *, int, const transcribe_run_params *);
+
+transcribe_status load(Loader & loader, const transcribe_model_load_params * params, transcribe_model ** out_model) {
     // The dispatcher has verified out_model is non-null and cleared it,
     // and the loader has a valid gguf_context.
 
     const int64_t t_load_start = ggml_time_us();
 
-    auto m = std::make_unique<ParakeetModel>();
+    auto m       = std::make_unique<ParakeetModel>();
     m->arch      = &arch;
     m->t_load_us = 0;
 
@@ -453,17 +422,13 @@ transcribe_status load(
     m->caps.n_languages = 0;
     m->caps.languages   = nullptr;
 
-    if (const transcribe_status st = read_capability_kv(loader.gguf(), m->caps);
-        st != TRANSCRIBE_OK)
-    {
+    if (const transcribe_status st = read_capability_kv(loader.gguf(), m->caps); st != TRANSCRIBE_OK) {
         return st;
     }
 
     // Languages from general.languages (copied into the model, so the
     // loader's gguf_context can be freed afterward).
-    if (const transcribe_status st = read_languages_kv(loader.gguf(), *m);
-        st != TRANSCRIBE_OK)
-    {
+    if (const transcribe_status st = read_languages_kv(loader.gguf(), *m); st != TRANSCRIBE_OK) {
         return st;
     }
 
@@ -476,9 +441,7 @@ transcribe_status load(
     // Architecture KV (encoder / predictor / joint / frontend dims).
     // read_parakeet_hparams enforces cross-field invariants so the shapes
     // we validate against are consistent.
-    if (const transcribe_status st = read_parakeet_hparams(loader.gguf(), m->hparams);
-        st != TRANSCRIBE_OK)
-    {
+    if (const transcribe_status st = read_parakeet_hparams(loader.gguf(), m->hparams); st != TRANSCRIBE_OK) {
         return st;
     }
 
@@ -489,15 +452,11 @@ transcribe_status load(
     //     streaming (parakeet-unified-en-0.6b).
     // Offline variants stay non-streaming.
     const bool cache_aware_streaming =
-        (m->hparams.enc_att_context_style ==
-             ParakeetHParams::AttContextStyle::ChunkedLimited) &&
-        m->hparams.enc_att_context_left  >= 0 &&
-        m->hparams.enc_att_context_right >= 0;
+        (m->hparams.enc_att_context_style == ParakeetHParams::AttContextStyle::ChunkedLimited) &&
+        m->hparams.enc_att_context_left >= 0 && m->hparams.enc_att_context_right >= 0;
     const bool buffered_streaming =
-        (m->hparams.enc_att_context_style ==
-             ParakeetHParams::AttContextStyle::ChunkedLimitedWithRc) &&
-        !m->hparams.enc_att_chunk_left_choices.empty() &&
-        !m->hparams.enc_att_chunk_chunk_choices.empty() &&
+        (m->hparams.enc_att_context_style == ParakeetHParams::AttContextStyle::ChunkedLimitedWithRc) &&
+        !m->hparams.enc_att_chunk_left_choices.empty() && !m->hparams.enc_att_chunk_chunk_choices.empty() &&
         !m->hparams.enc_att_chunk_right_choices.empty();
     // supports_streaming is the generic gate; the configurable geometry
     // is reached via the parakeet stream extensions, not flat caps.
@@ -508,7 +467,7 @@ transcribe_status load(
     // Construct the mel front-end (precomputes Hann window + Slaney mel
     // filterbank); amortized across every run on every context.
     {
-        transcribe::MelConfig cfg {};
+        transcribe::MelConfig cfg{};
         cfg.sample_rate  = m->hparams.fe_sample_rate;
         cfg.num_mels     = m->hparams.fe_num_mels;
         cfg.n_fft        = m->hparams.fe_n_fft;
@@ -530,12 +489,11 @@ transcribe_status load(
     // tensor catalog (metadata only), then we bind a backend, allocate a
     // buffer for every tensor, and stream the data section into it. The
     // second gguf_context (gguf_data) is freed before load() returns.
-    gguf_init_params init_params {};
+    gguf_init_params init_params{};
     init_params.no_alloc = true;
     init_params.ctx      = &m->ctx_meta;
 
-    gguf_context * gguf_data = gguf_init_from_file(loader.path().c_str(),
-                                                   init_params);
+    gguf_context * gguf_data = gguf_init_from_file(loader.path().c_str(), init_params);
     if (gguf_data == nullptr) {
         // The first-stage open succeeded, so this is unexpected (file
         // changed between opens, or a permissions transition).
@@ -544,51 +502,42 @@ transcribe_status load(
 
     // Validate every tensor against the canonical catalog (type + shape
     // only, so it works before the backend buffer is bound).
-    if (const transcribe_status st =
-            build_parakeet_weights(m->ctx_meta, m->hparams, m->weights);
-        st != TRANSCRIBE_OK)
-    {
+    if (const transcribe_status st = build_parakeet_weights(m->ctx_meta, m->hparams, m->weights); st != TRANSCRIBE_OK) {
         gguf_free(gguf_data);
         return st;
     }
 
     // Resolve the backend plan via ggml's device registry (runtime, no
     // compile-time backend guards). See transcribe-load-common.h.
-    const transcribe_backend_request backend_req =
-        (params != nullptr) ? params->backend : TRANSCRIBE_BACKEND_AUTO;
+    const transcribe_backend_request backend_req = (params != nullptr) ? params->backend : TRANSCRIBE_BACKEND_AUTO;
 
     if (const transcribe_status st = transcribe::load_common::init_backends(
             backend_req, (params != nullptr) ? params->gpu_device : 0, "parakeet", m->plan);
-        st != TRANSCRIBE_OK)
-    {
+        st != TRANSCRIBE_OK) {
         gguf_free(gguf_data);
         return st;
     }
 
-    m->backend = ggml_backend_name(m->plan.primary);
+    m->backend         = ggml_backend_name(m->plan.primary);
     m->primary_backend = m->plan.primary;
 
     // Allocate a backend buffer for every tensor in ctx_meta on the
     // primary backend; the weight bytes are streamed in below.
-    ggml_backend_buffer_t weights_buffer =
-        ggml_backend_alloc_ctx_tensors(m->ctx_meta, m->plan.primary);
+    ggml_backend_buffer_t weights_buffer = ggml_backend_alloc_ctx_tensors(m->ctx_meta, m->plan.primary);
     if (weights_buffer == nullptr) {
         gguf_free(gguf_data);
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "parakeet: ggml_backend_alloc_ctx_tensors failed");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "parakeet: ggml_backend_alloc_ctx_tensors failed");
         return TRANSCRIBE_ERR_GGUF;
     }
     m->backend_buffer = weights_buffer;
-    ggml_backend_buffer_set_usage(weights_buffer,
-                                  GGML_BACKEND_BUFFER_USAGE_WEIGHTS);
+    ggml_backend_buffer_set_usage(weights_buffer, GGML_BACKEND_BUFFER_USAGE_WEIGHTS);
 
     // Stream tensor data from the GGUF into the backend buffer slots
     // (shared loop in transcribe-load-common.h; works on host-memory
     // backends and discrete GPUs).
-    if (const transcribe_status st = transcribe::load_common::stream_tensor_data(
-            loader.path(), gguf_data, m->ctx_meta, "parakeet");
-        st != TRANSCRIBE_OK)
-    {
+    if (const transcribe_status st =
+            transcribe::load_common::stream_tensor_data(loader.path(), gguf_data, m->ctx_meta, "parakeet");
+        st != TRANSCRIBE_OK) {
         gguf_free(gguf_data);
         return st;
     }
@@ -598,29 +547,21 @@ transcribe_status load(
     // Fuse BatchNorm into scale + bias (replaces 4 elementwise ops per
     // block with 2). Skipped for LayerNorm conv-module variants (no
     // running stats to fuse against).
-    if (m->hparams.enc_conv_norm_type
-            == ParakeetHParams::ConvNormType::BatchNorm)
-    {
-        if (const transcribe_status st = fuse_batch_norm(*m);
-            st != TRANSCRIBE_OK)
-        {
+    if (m->hparams.enc_conv_norm_type == ParakeetHParams::ConvNormType::BatchNorm) {
+        if (const transcribe_status st = fuse_batch_norm(*m); st != TRANSCRIBE_OK) {
             return st;
         }
     }
 
     // On CPU primary backend, dequantize conv pointwise weights to F32
     // (see promote_conv_pw_to_f32_on_cpu). No-op on GPU backends.
-    if (const transcribe_status st = promote_conv_pw_to_f32_on_cpu(*m);
-        st != TRANSCRIBE_OK)
-    {
+    if (const transcribe_status st = promote_conv_pw_to_f32_on_cpu(*m); st != TRANSCRIBE_OK) {
         return st;
     }
 
     // Build the host mirror of the predictor + joint weights (one-shot
     // backend → host copy; the decoder runs on host, see decoder.h).
-    if (const transcribe_status st = build_host_decoder_weights(*m, m->host_decoder);
-        st != TRANSCRIBE_OK)
-    {
+    if (const transcribe_status st = build_host_decoder_weights(*m, m->host_decoder); st != TRANSCRIBE_OK) {
         return st;
     }
 
@@ -631,18 +572,16 @@ transcribe_status load(
     return TRANSCRIBE_OK;
 }
 
-transcribe_status init_context(
-    transcribe_model *                model,
-    const transcribe_session_params * params,
-    transcribe_session **             out_ctx)
-{
+transcribe_status init_context(transcribe_model *                model,
+                               const transcribe_session_params * params,
+                               transcribe_session **             out_ctx) {
     // The dispatcher has null-checked model/params/out_ctx; verify the
     // model is actually a ParakeetModel (arch is the discriminator).
     if (model->arch != &arch) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
 
-    auto pc = std::make_unique<ParakeetSession>();
+    auto pc       = std::make_unique<ParakeetSession>();
     pc->model     = model;
     pc->n_threads = params->n_threads;
     pc->kv_type   = params->kv_type;
@@ -659,20 +598,32 @@ transcribe_status init_context(
 // control pieces like "<unk>". No-op for the English parakeets.
 static bool is_lang_tag_piece(const std::string & p) {
     const size_t n = p.size();
-    if (n < 7 || p.front() != '<' || p.back() != '>') return false; // min "<aa-AA>"
-    size_t i = 1;
-    const size_t end = n - 1;
+    if (n < 7 || p.front() != '<' || p.back() != '>') {
+        return false;  // min "<aa-AA>"
+    }
+    size_t       i     = 1;
+    const size_t end   = n - 1;
     const size_t lang0 = i;
-    while (i < end && p[i] >= 'a' && p[i] <= 'z') ++i;
+    while (i < end && p[i] >= 'a' && p[i] <= 'z') {
+        ++i;
+    }
     const size_t lang_len = i - lang0;
-    if (lang_len < 2 || lang_len > 3) return false;
-    if (i >= end || p[i] != '-') return false;
+    if (lang_len < 2 || lang_len > 3) {
+        return false;
+    }
+    if (i >= end || p[i] != '-') {
+        return false;
+    }
     ++i;
     const size_t reg0 = i;
-    while (i < end && std::isalpha(static_cast<unsigned char>(p[i]))) ++i;
+    while (i < end && std::isalpha(static_cast<unsigned char>(p[i]))) {
+        ++i;
+    }
     const size_t reg_len = i - reg0;
-    if (reg_len < 2 || reg_len > 4) return false;
-    return i == end; // interior consumed exactly up to '>'
+    if (reg_len < 2 || reg_len > 4) {
+        return false;
+    }
+    return i == end;  // interior consumed exactly up to '>'
 }
 
 // Drop this piece from the public result when keep_special_tags is off:
@@ -690,12 +641,18 @@ static void normalize_transcript_whitespace(std::string & s) {
     bool prev_space = false;
     for (char ch : s) {
         const bool is_space = (ch == ' ');
-        if (is_space && prev_space) continue;
+        if (is_space && prev_space) {
+            continue;
+        }
         norm.push_back(ch);
         prev_space = is_space;
     }
-    while (!norm.empty() && norm.front() == ' ') norm.erase(norm.begin());
-    while (!norm.empty() && norm.back()  == ' ') norm.pop_back();
+    while (!norm.empty() && norm.front() == ' ') {
+        norm.erase(norm.begin());
+    }
+    while (!norm.empty() && norm.back() == ' ') {
+        norm.pop_back();
+    }
     s.swap(norm);
 }
 
@@ -704,10 +661,8 @@ static void normalize_transcript_whitespace(std::string & s) {
 // stride doesn't quantize before the call-site multiply. Shared by both
 // result builders.
 static double parakeet_ms_per_enc_frame(const ParakeetHParams & hp) {
-    return 1000.0 *
-        static_cast<double>(hp.enc_subsampling_factor) *
-        static_cast<double>(hp.fe_hop_length) /
-        static_cast<double>(hp.fe_sample_rate);
+    return 1000.0 * static_cast<double>(hp.enc_subsampling_factor) * static_cast<double>(hp.fe_hop_length) /
+           static_cast<double>(hp.fe_sample_rate);
 }
 
 // Host-side TDT/RNNT/CTC decode + public result-hierarchy build for one
@@ -715,37 +670,31 @@ static double parakeet_ms_per_enc_frame(const ParakeetHParams & hp) {
 // activation for ONE utterance; utt_index >= 0 tags the per-utterance
 // dump (-1 for single-shot). Writes the session result slot (tokens /
 // words / segments / full_text / result_kind / has_result).
-static transcribe_status decode_and_populate(
-    ParakeetSession *             pc,
-    ParakeetModel *               pm,
-    const transcribe_run_params * params,
-    const float *                 enc,
-    int                           T_enc,
-    int                           d_enc,
-    int                           utt_index,
-    const char *                  enc_dump_name_override = nullptr)
-{
+static transcribe_status decode_and_populate(ParakeetSession *             pc,
+                                             ParakeetModel *               pm,
+                                             const transcribe_run_params * params,
+                                             const float *                 enc,
+                                             int                           T_enc,
+                                             int                           d_enc,
+                                             int                           utt_index,
+                                             const char *                  enc_dump_name_override = nullptr) {
     // Default dump name is "dec.enc_out"; the prompt-conditioned path
     // overrides to "dec.enc_out_prompted" so the comparator sees the
     // post-prompt tensor under its expected filename.
-    std::string dump_name = (enc_dump_name_override != nullptr &&
-                             *enc_dump_name_override != '\0')
-        ? std::string(enc_dump_name_override)
-        : std::string("dec.enc_out");
+    std::string dump_name = (enc_dump_name_override != nullptr && *enc_dump_name_override != '\0') ?
+                                std::string(enc_dump_name_override) :
+                                std::string("dec.enc_out");
     if (utt_index >= 0) {
         dump_name += ".b" + std::to_string(utt_index);
     }
     // Optional dump of the encoder output as the decoder sees it.
     if (transcribe::debug::enabled()) {
         const long long shape[2] = { T_enc, d_enc };
-        const char * stage = (enc_dump_name_override != nullptr &&
-                              *enc_dump_name_override != '\0')
-            ? "decoder.enc_out_prompted"
-            : "decoder.enc_out";
+        const char *    stage    = (enc_dump_name_override != nullptr && *enc_dump_name_override != '\0') ?
+                                       "decoder.enc_out_prompted" :
+                                       "decoder.enc_out";
         transcribe::debug::dump_host_f32(
-            dump_name.c_str(), enc,
-            static_cast<long long>(T_enc) * static_cast<long long>(d_enc),
-            shape, 2, stage);
+            dump_name.c_str(), enc, static_cast<long long>(T_enc) * static_cast<long long>(d_enc), shape, 2, stage);
     }
 
     pc->raw_tokens.clear();
@@ -754,19 +703,18 @@ static transcribe_status decode_and_populate(
         transcribe_status st = TRANSCRIBE_OK;
         switch (pm->host_decoder.head_kind) {
             case HostHeadKind::TDT:
-                st = decode_tdt_greedy(pm->host_decoder, enc,
-                                       T_enc, d_enc, pc->n_threads, pc->raw_tokens);
+                st = decode_tdt_greedy(pm->host_decoder, enc, T_enc, d_enc, pc->n_threads, pc->raw_tokens);
                 break;
             case HostHeadKind::RNNT:
-                st = decode_rnnt_greedy(pm->host_decoder, enc,
-                                        T_enc, d_enc, pc->n_threads, pc->raw_tokens);
+                st = decode_rnnt_greedy(pm->host_decoder, enc, T_enc, d_enc, pc->n_threads, pc->raw_tokens);
                 break;
             case HostHeadKind::CTC:
-                st = decode_ctc_greedy(pm->host_decoder, enc,
-                                       T_enc, d_enc, pc->n_threads, pc->raw_tokens);
+                st = decode_ctc_greedy(pm->host_decoder, enc, T_enc, d_enc, pc->n_threads, pc->raw_tokens);
                 break;
         }
-        if (st != TRANSCRIBE_OK) return st;
+        if (st != TRANSCRIBE_OK) {
+            return st;
+        }
     }
     pc->t_decode_us = ggml_time_us() - t_dec_start;
 
@@ -781,7 +729,7 @@ static transcribe_status decode_and_populate(
     // raw piece starting with it opens a new word. We use the raw NeMo
     // piece (its leading 3 bytes are unambiguous), not the post-decode
     // "▁ → space" form.
-    constexpr const char k_sp_marker[] = "\xE2\x96\x81";
+    constexpr const char k_sp_marker[]   = "\xE2\x96\x81";
     constexpr int        k_sp_marker_len = 3;
 
     const transcribe::Tokenizer & tok = pm->tok;
@@ -797,16 +745,13 @@ static transcribe_status decode_and_populate(
             continue;
         }
         transcribe_session::TokenEntry te;
-        te.id    = rt.id;
-        te.p     = rt.p;
-        te.t0_ms = static_cast<int64_t>(
-            std::llround(frame_to_ms * static_cast<double>(rt.step_at_emit)));
+        te.id                  = rt.id;
+        te.p                   = rt.p;
+        te.t0_ms               = static_cast<int64_t>(std::llround(frame_to_ms * static_cast<double>(rt.step_at_emit)));
         // duration_frames=0 yields a zero-width "point in time" token.
-        const double end_frame =
-            static_cast<double>(rt.step_at_emit) +
-            static_cast<double>(rt.duration_frames);
-        te.t1_ms = static_cast<int64_t>(std::llround(frame_to_ms * end_frame));
-        te.text  = tok.decode(&rt.id, 1);
+        const double end_frame = static_cast<double>(rt.step_at_emit) + static_cast<double>(rt.duration_frames);
+        te.t1_ms               = static_cast<int64_t>(std::llround(frame_to_ms * end_frame));
+        te.text                = tok.decode(&rt.id, 1);
         pc->tokens.push_back(std::move(te));
     }
 
@@ -823,12 +768,12 @@ static transcribe_status decode_and_populate(
 
         // First token opens word 0; a raw piece beginning with the
         // marker opens a new word, others extend the current word.
-        transcribe_session::WordEntry  cur_word;
-        bool                        cur_word_open = false;
+        transcribe_session::WordEntry cur_word;
+        bool                          cur_word_open = false;
 
         auto open_new_word = [&](int token_index, const transcribe_session::TokenEntry & tk) {
             if (cur_word_open) {
-                cur_word.t1_ms   = pc->tokens[static_cast<size_t>(token_index - 1)].t1_ms;
+                cur_word.t1_ms    = pc->tokens[static_cast<size_t>(token_index - 1)].t1_ms;
                 cur_word.n_tokens = token_index - cur_word.first_token;
                 pc->words.push_back(std::move(cur_word));
                 cur_word = transcribe_session::WordEntry{};
@@ -840,12 +785,10 @@ static transcribe_status decode_and_populate(
         };
 
         for (size_t i = 0; i < pc->tokens.size(); ++i) {
-            const auto & tk        = pc->tokens[i];
-            const auto & raw_piece = tok.token(tk.id); // empty if id OOR
-            const bool starts_word =
-                (i == 0) ||
-                (raw_piece.size() >= static_cast<size_t>(k_sp_marker_len) &&
-                 std::memcmp(raw_piece.data(), k_sp_marker, k_sp_marker_len) == 0);
+            const auto & tk          = pc->tokens[i];
+            const auto & raw_piece   = tok.token(tk.id);  // empty if id OOR
+            const bool   starts_word = (i == 0) || (raw_piece.size() >= static_cast<size_t>(k_sp_marker_len) &&
+                                                    std::memcmp(raw_piece.data(), k_sp_marker, k_sp_marker_len) == 0);
             if (starts_word) {
                 open_new_word(static_cast<int>(i), tk);
             }
@@ -884,12 +827,13 @@ static transcribe_status decode_and_populate(
         // substitution sees the whole sequence).
         std::vector<int> all_ids;
         all_ids.reserve(pc->tokens.size());
-        for (const auto & tk : pc->tokens) all_ids.push_back(tk.id);
-        std::string full = tok.decode(all_ids.data(),
-                                      static_cast<int>(all_ids.size()));
+        for (const auto & tk : pc->tokens) {
+            all_ids.push_back(tk.id);
+        }
+        std::string full = tok.decode(all_ids.data(), static_cast<int>(all_ids.size()));
         normalize_transcript_whitespace(full);
-        seg.text       = full;
-        pc->full_text  = std::move(full);
+        seg.text      = full;
+        pc->full_text = std::move(full);
         pc->segments.push_back(std::move(seg));
 
         // Clamp to the caller's requested ceiling. AUTO resolves to the
@@ -898,24 +842,24 @@ static transcribe_status decode_and_populate(
         // TOKEN, so eff ends up in {NONE, SEGMENT, WORD, TOKEN}.
         transcribe_timestamp_kind eff = params->timestamps;
         if (eff == TRANSCRIBE_TIMESTAMPS_AUTO) {
-            eff = pm->caps.max_timestamp_kind; // = TOKEN for parakeet
+            eff = pm->caps.max_timestamp_kind;  // = TOKEN for parakeet
         }
         if (eff == TRANSCRIBE_TIMESTAMPS_NONE) {
             // Keep the segment + text, drop all alignment data.
             pc->tokens.clear();
             pc->words.clear();
-            auto & s = pc->segments.back();
-            s.t0_ms      = 0;
-            s.t1_ms      = 0;
-            s.first_word = 0;
-            s.n_words    = 0;
+            auto & s      = pc->segments.back();
+            s.t0_ms       = 0;
+            s.t1_ms       = 0;
+            s.first_word  = 0;
+            s.n_words     = 0;
             s.first_token = 0;
             s.n_tokens    = 0;
         } else if (eff == TRANSCRIBE_TIMESTAMPS_SEGMENT) {
             // Keep segment timings, drop token + word tables.
             pc->tokens.clear();
             pc->words.clear();
-            auto & s = pc->segments.back();
+            auto & s      = pc->segments.back();
             s.first_word  = 0;
             s.n_words     = 0;
             s.first_token = 0;
@@ -929,7 +873,7 @@ static transcribe_status decode_and_populate(
                 w.first_token = 0;
                 w.n_tokens    = 0;
             }
-            auto & s = pc->segments.back();
+            auto & s      = pc->segments.back();
             s.first_token = 0;
             s.n_tokens    = 0;
         }
@@ -942,13 +886,11 @@ static transcribe_status decode_and_populate(
     return TRANSCRIBE_OK;
 }
 
-static transcribe_status run_one_shot_inner(
-    ParakeetSession *         pc,
-    ParakeetModel *           pm,
-    const float *             pcm,
-    int                       n_samples,
-    const transcribe_run_params * params)
-{
+static transcribe_status run_one_shot_inner(ParakeetSession *             pc,
+                                            ParakeetModel *               pm,
+                                            const float *                 pcm,
+                                            int                           n_samples,
+                                            const transcribe_run_params * params) {
     // Pre-run abort check (the single observation point on this path).
     if (pc->poll_abort()) {
         return TRANSCRIBE_ERR_ABORTED;
@@ -958,21 +900,17 @@ static transcribe_status run_one_shot_inner(
 
     // ----- Mel front-end -----
     if (!pm->mel.has_value()) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "parakeet run: model has no MelFrontend (load skipped?)");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "parakeet run: model has no MelFrontend (load skipped?)");
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
-    const int64_t t_mel_start = ggml_time_us();
-    int mel_n_mels   = 0;
-    int mel_n_frames = 0;
-    if (const transcribe_status mst = pm->mel->compute(
-            pcm, static_cast<size_t>(n_samples),
-            pc->mel_buf, mel_n_mels, mel_n_frames);
-        mst != TRANSCRIBE_OK)
-    {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "parakeet run: MelFrontend::compute failed (%s)",
-                     transcribe_status_string(mst));
+    const int64_t t_mel_start  = ggml_time_us();
+    int           mel_n_mels   = 0;
+    int           mel_n_frames = 0;
+    if (const transcribe_status mst =
+            pm->mel->compute(pcm, static_cast<size_t>(n_samples), pc->mel_buf, mel_n_mels, mel_n_frames);
+        mst != TRANSCRIBE_OK) {
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "parakeet run: MelFrontend::compute failed (%s)",
+                transcribe_status_string(mst));
         return mst;
     }
     pc->t_mel_us = ggml_time_us() - t_mel_start;
@@ -991,87 +929,79 @@ static transcribe_status run_one_shot_inner(
     // by the scheduler below). The 24-block encoder graph uses ~1.23 MB
     // of metadata arena; 4 MB gives ~3x headroom.
     {
-        ggml_init_params init_params {};
+        ggml_init_params init_params{};
         init_params.mem_size   = 4 * 1024 * 1024;
         init_params.mem_buffer = nullptr;
         init_params.no_alloc   = true;
-        pc->compute_ctx = ggml_init(init_params);
+        pc->compute_ctx        = ggml_init(init_params);
         if (pc->compute_ctx == nullptr) {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "parakeet run: ggml_init for compute_ctx failed");
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "parakeet run: ggml_init for compute_ctx failed");
             return TRANSCRIBE_ERR_GGUF;
         }
     }
 
     // GGML_TYPE_COUNT is the encoder's "auto" sentinel.
     ggml_type resolved_kv = GGML_TYPE_COUNT;
-    if (pc->kv_type == TRANSCRIBE_KV_TYPE_F32) resolved_kv = GGML_TYPE_F32;
-    if (pc->kv_type == TRANSCRIBE_KV_TYPE_F16) resolved_kv = GGML_TYPE_F16;
+    if (pc->kv_type == TRANSCRIBE_KV_TYPE_F32) {
+        resolved_kv = GGML_TYPE_F32;
+    }
+    if (pc->kv_type == TRANSCRIBE_KV_TYPE_F16) {
+        resolved_kv = GGML_TYPE_F16;
+    }
 
-    EncoderBuild eb = build_encoder_graph(
-        pc->compute_ctx, pm->weights, pm->hparams, mel_n_frames,
-        resolved_kv, pm->backend.c_str());
+    EncoderBuild eb =
+        build_encoder_graph(pc->compute_ctx, pm->weights, pm->hparams, mel_n_frames, resolved_kv, pm->backend.c_str());
     if (eb.mel_in == nullptr || eb.out == nullptr || eb.graph == nullptr) {
-        return TRANSCRIBE_ERR_GGUF; // build_encoder_graph logged
+        return TRANSCRIBE_ERR_GGUF;  // build_encoder_graph logged
     }
 
     // ----- Allocate compute tensors via the multi-backend scheduler.
     // Created lazily, persists across calls. -----
     if (pc->sched == nullptr) {
-        pc->sched = ggml_backend_sched_new(
-            pm->plan.scheduler_list.data(), nullptr,
-            static_cast<int>(pm->plan.scheduler_list.size()),
-            /*graph_size=*/8192, /*parallel=*/false, /*op_offload=*/true);
+        pc->sched = ggml_backend_sched_new(pm->plan.scheduler_list.data(), nullptr,
+                                           static_cast<int>(pm->plan.scheduler_list.size()),
+                                           /*graph_size=*/8192, /*parallel=*/false, /*op_offload=*/true);
         if (pc->sched == nullptr) {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "parakeet run: ggml_backend_sched_new failed");
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "parakeet run: ggml_backend_sched_new failed");
             return TRANSCRIBE_ERR_GGUF;
         }
     }
     ggml_backend_sched_reset(pc->sched);
     if (!ggml_backend_sched_alloc_graph(pc->sched, eb.graph)) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "parakeet run: ggml_backend_sched_alloc_graph failed");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "parakeet run: ggml_backend_sched_alloc_graph failed");
         return TRANSCRIBE_ERR_GGUF;
     }
 
     // Upload the mel; the row-major [num_mels, n_frames] buffer is
     // byte-identical to the ggml ne=[n_frames, num_mels, 1, 1] input.
-    ggml_backend_tensor_set(eb.mel_in, pc->mel_buf.data(),
-                            0, pc->mel_buf.size() * sizeof(float));
+    ggml_backend_tensor_set(eb.mel_in, pc->mel_buf.data(), 0, pc->mel_buf.size() * sizeof(float));
 
-    transcribe::debug::dump_tensor(
-        "enc.mel.in", eb.mel_in, "encoder.mel");
+    transcribe::debug::dump_tensor("enc.mel.in", eb.mel_in, "encoder.mel");
 
     // Prompt one-hot input (multilingual variants only): fill
     // prompt_one_hot_in with the resolved language's one-hot replicated
     // across T_enc frames (see resolve_prompt_id).
     if (eb.prompt_one_hot_in != nullptr) {
-        const int P     = static_cast<int>(eb.prompt_one_hot_in->ne[0]);
-        const int T_oh  = static_cast<int>(eb.prompt_one_hot_in->ne[1]);
-        const char * lang_hint =
-            (params != nullptr) ? params->language : nullptr;
-        const int32_t pid = resolve_prompt_id(pm->hparams, lang_hint);
+        const int     P         = static_cast<int>(eb.prompt_one_hot_in->ne[0]);
+        const int     T_oh      = static_cast<int>(eb.prompt_one_hot_in->ne[1]);
+        const char *  lang_hint = (params != nullptr) ? params->language : nullptr;
+        const int32_t pid       = resolve_prompt_id(pm->hparams, lang_hint);
         if (pid < 0) {
             log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "parakeet run: language %s%s%s not in prompt "
-                         "dictionary",
-                         lang_hint ? "\"" : "",
-                         lang_hint ? lang_hint : "<null>",
-                         lang_hint ? "\"" : "");
+                    "parakeet run: language %s%s%s not in prompt "
+                    "dictionary",
+                    lang_hint ? "\"" : "", lang_hint ? lang_hint : "<null>", lang_hint ? "\"" : "");
             return TRANSCRIBE_ERR_UNSUPPORTED_LANGUAGE;
         }
         std::vector<float> one_hot_buf;
-        if (!fill_prompt_one_hot(one_hot_buf, P, T_oh, /*n_batch=*/1,
-                                 {pid}))
-        {
+        if (!fill_prompt_one_hot(one_hot_buf, P, T_oh, /*n_batch=*/1, { pid })) {
             log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "parakeet run: prompt_id %d out of range "
-                         "[0, %d)", pid, P);
+                    "parakeet run: prompt_id %d out of range "
+                    "[0, %d)",
+                    pid, P);
             return TRANSCRIBE_ERR_GGUF;
         }
-        ggml_backend_tensor_set(eb.prompt_one_hot_in, one_hot_buf.data(),
-                                0, one_hot_buf.size() * sizeof(float));
+        ggml_backend_tensor_set(eb.prompt_one_hot_in, one_hot_buf.data(), 0, one_hot_buf.size() * sizeof(float));
     }
 
     // ----- Host-side sinusoidal positional embedding -----
@@ -1089,16 +1019,10 @@ static transcribe_status run_one_shot_inner(
 
         // Position of "relative offset 0" in the buffer: (pos_len-1)/2 for
         // full / chunked_limited; W_left for Regular local attention.
-        const bool is_chunked =
-            (pm->hparams.enc_att_context_style ==
-                 ParakeetHParams::AttContextStyle::ChunkedLimited);
+        const bool is_chunked = (pm->hparams.enc_att_context_style == ParakeetHParams::AttContextStyle::ChunkedLimited);
         const bool is_local_pe =
-            (!is_chunked) &&
-            (pm->hparams.enc_att_context_left >= 0 &&
-             pm->hparams.enc_att_context_right >= 0);
-        const int zero_index = is_local_pe
-            ? pm->hparams.enc_att_context_left
-            : (pos_len - 1) / 2;
+            (!is_chunked) && (pm->hparams.enc_att_context_left >= 0 && pm->hparams.enc_att_context_right >= 0);
+        const int zero_index = is_local_pe ? pm->hparams.enc_att_context_left : (pos_len - 1) / 2;
 
         pc->pos_buf.assign(static_cast<size_t>(pos_len) * d_model, 0.0f);
 
@@ -1106,25 +1030,22 @@ static transcribe_status run_one_shot_inner(
         const float ln_10000 = std::log(10000.0f);
         for (int k = 0; k < d_model / 2; ++k) {
             pc->pos_div_term[static_cast<size_t>(k)] =
-                std::exp(static_cast<float>(2 * k) *
-                         (-ln_10000 / static_cast<float>(d_model)));
+                std::exp(static_cast<float>(2 * k) * (-ln_10000 / static_cast<float>(d_model)));
         }
 
         for (int i = 0; i < pos_len; ++i) {
             const float pos = static_cast<float>(zero_index - i);
-            float * row = pc->pos_buf.data() + static_cast<size_t>(i) * d_model;
+            float *     row = pc->pos_buf.data() + static_cast<size_t>(i) * d_model;
             for (int k = 0; k < d_model / 2; ++k) {
                 const float div = pc->pos_div_term[static_cast<size_t>(k)];
-                row[2 * k]     = std::sin(pos * div);
-                row[2 * k + 1] = std::cos(pos * div);
+                row[2 * k]      = std::sin(pos * div);
+                row[2 * k + 1]  = std::cos(pos * div);
             }
         }
 
-        ggml_backend_tensor_set(eb.pos_emb_in, pc->pos_buf.data(),
-                                0, pc->pos_buf.size() * sizeof(float));
+        ggml_backend_tensor_set(eb.pos_emb_in, pc->pos_buf.data(), 0, pc->pos_buf.size() * sizeof(float));
 
-        transcribe::debug::dump_tensor(
-            "enc.pos_emb", eb.pos_emb_in, "encoder.pos_emb");
+        transcribe::debug::dump_tensor("enc.pos_emb", eb.pos_emb_in, "encoder.pos_emb");
     }
 
     // ChunkedLimited attention mask (streaming variants): 0 on (q, k)
@@ -1134,35 +1055,25 @@ static transcribe_status run_one_shot_inner(
     if (eb.chunked_mask_in != nullptr) {
         const int T_enc       = static_cast<int>(eb.chunked_mask_in->ne[0]);
         const int chunk_size  = pm->hparams.enc_att_context_right + 1;
-        const int left_chunks = (chunk_size > 0)
-            ? (pm->hparams.enc_att_context_left / chunk_size)
-            : 0;
+        const int left_chunks = (chunk_size > 0) ? (pm->hparams.enc_att_context_left / chunk_size) : 0;
 
-        std::vector<float> mask_buf(
-            static_cast<size_t>(T_enc) * static_cast<size_t>(T_enc));
+        std::vector<float> mask_buf(static_cast<size_t>(T_enc) * static_cast<size_t>(T_enc));
         // ggml ne = [T_k, T_q, 1, 1], row-major in the host buffer is
         // contiguous along T_k (ne[0]). Indexing: mask[q, k] lives at
         // offset (q * T_enc + k).
         for (int q = 0; q < T_enc; ++q) {
-            const int q_chunk = (chunk_size > 0) ? (q / chunk_size) : 0;
-            const int k_min_chunk =
-                (q_chunk - left_chunks > 0) ? (q_chunk - left_chunks) : 0;
-            const int k_min = k_min_chunk * chunk_size;
-            const int k_max = (q_chunk + 1) * chunk_size; // exclusive
-            float * row = mask_buf.data() + static_cast<size_t>(q) * T_enc;
+            const int q_chunk     = (chunk_size > 0) ? (q / chunk_size) : 0;
+            const int k_min_chunk = (q_chunk - left_chunks > 0) ? (q_chunk - left_chunks) : 0;
+            const int k_min       = k_min_chunk * chunk_size;
+            const int k_max       = (q_chunk + 1) * chunk_size;  // exclusive
+            float *   row         = mask_buf.data() + static_cast<size_t>(q) * T_enc;
             for (int k = 0; k < T_enc; ++k) {
-                row[k] = (k >= k_min && k < k_max)
-                    ? 0.0f
-                    : -std::numeric_limits<float>::infinity();
+                row[k] = (k >= k_min && k < k_max) ? 0.0f : -std::numeric_limits<float>::infinity();
             }
         }
 
-        ggml_backend_tensor_set(eb.chunked_mask_in, mask_buf.data(),
-                                0, mask_buf.size() * sizeof(float));
-        transcribe::debug::dump_tensor(
-            "enc.attn.chunked_mask",
-            eb.chunked_mask_in,
-            "encoder.attn.chunked_mask");
+        ggml_backend_tensor_set(eb.chunked_mask_in, mask_buf.data(), 0, mask_buf.size() * sizeof(float));
+        transcribe::debug::dump_tensor("enc.attn.chunked_mask", eb.chunked_mask_in, "encoder.attn.chunked_mask");
     }
 
     // Set n_threads on the CPU/BLAS backends (GPU backends ignore it).
@@ -1170,68 +1081,62 @@ static transcribe_status run_one_shot_inner(
 
     // ----- Compute -----
     const int64_t t_enc_start = ggml_time_us();
-    if (const ggml_status gs =
-            ggml_backend_sched_graph_compute(pc->sched, eb.graph);
-        gs != GGML_STATUS_SUCCESS)
-    {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "parakeet run: ggml_backend_sched_graph_compute failed (%d)",
-                     static_cast<int>(gs));
+    if (const ggml_status gs = ggml_backend_sched_graph_compute(pc->sched, eb.graph); gs != GGML_STATUS_SUCCESS) {
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "parakeet run: ggml_backend_sched_graph_compute failed (%d)",
+                static_cast<int>(gs));
         return TRANSCRIBE_ERR_GGUF;
     }
     pc->t_encode_us = ggml_time_us() - t_enc_start;
     pc->t_decode_us = 0;
 
     // ----- Dump intermediates (debug only; nullptr fields skipped) -----
-    auto try_dump = [](const char * name, ggml_tensor * t,
-                       const char * stage)
-    {
+    auto try_dump = [](const char * name, ggml_tensor * t, const char * stage) {
         if (t != nullptr) {
             transcribe::debug::dump_tensor(name, t, stage);
         }
     };
-    try_dump("enc.pre_encode.out",   eb.dumps.pre_encode_out,   "encoder.pre_encode");
-    try_dump("enc.block.0.ff1",      eb.dumps.block0_after_ff1, "encoder.block0.ff1");
-    try_dump("enc.block.0.attn",     eb.dumps.block0_after_attn,"encoder.block0.attn");
-    try_dump("enc.block.0.conv",     eb.dumps.block0_after_conv,"encoder.block0.conv");
-    try_dump("enc.block.0.ff2",      eb.dumps.block0_after_ff2, "encoder.block0.ff2");
-    try_dump("enc.block.0.out",      eb.dumps.block0_out,       "encoder.block0.out");
+    try_dump("enc.pre_encode.out", eb.dumps.pre_encode_out, "encoder.pre_encode");
+    try_dump("enc.block.0.ff1", eb.dumps.block0_after_ff1, "encoder.block0.ff1");
+    try_dump("enc.block.0.attn", eb.dumps.block0_after_attn, "encoder.block0.attn");
+    try_dump("enc.block.0.conv", eb.dumps.block0_after_conv, "encoder.block0.conv");
+    try_dump("enc.block.0.ff2", eb.dumps.block0_after_ff2, "encoder.block0.ff2");
+    try_dump("enc.block.0.out", eb.dumps.block0_out, "encoder.block0.out");
     // Mid- and last-block spot-check dumps. File name encodes the actual
     // block index (scales with n_layers). last_block_out aliases
     // final_out; dumped under both its block name and "enc.final".
     if (eb.dumps.mid_block_out != nullptr && eb.dumps.mid_block_idx >= 0) {
         char name[64];
         std::snprintf(name, sizeof(name), "enc.block.%d.out", eb.dumps.mid_block_idx);
-        transcribe::debug::dump_tensor(name, eb.dumps.mid_block_out,
-                                       "encoder.block.mid.out");
+        transcribe::debug::dump_tensor(name, eb.dumps.mid_block_out, "encoder.block.mid.out");
     }
     if (eb.dumps.last_block_out != nullptr && eb.dumps.last_block_idx >= 0) {
         char name[64];
         std::snprintf(name, sizeof(name), "enc.block.%d.out", eb.dumps.last_block_idx);
-        transcribe::debug::dump_tensor(name, eb.dumps.last_block_out,
-                                       "encoder.block.last.out");
+        transcribe::debug::dump_tensor(name, eb.dumps.last_block_out, "encoder.block.last.out");
     }
     // Per-block dump for the layer-by-layer divergence bisect (gated by
     // TRANSCRIBE_DUMP_ALL_BLOCKS).
     if (transcribe::debug::dump_all_blocks_requested()) {
         for (size_t i = 0; i < eb.dumps.all_block_outs.size(); ++i) {
             ggml_tensor * t = eb.dumps.all_block_outs[i];
-            if (t == nullptr) continue;
+            if (t == nullptr) {
+                continue;
+            }
             char name[64];
             std::snprintf(name, sizeof(name), "enc.block.%zu.out", i);
-            transcribe::debug::dump_tensor(name, t,
-                                           "encoder.block.bisect");
+            transcribe::debug::dump_tensor(name, t, "encoder.block.bisect");
         }
     }
     // Sub-block intermediates for TRANSCRIBE_DUMP_SUB_BLOCKS (populated
     // by the sub-block observer in encoder.cpp).
     for (const auto & p : eb.dumps.sub_block_dumps) {
-        if (p.second == nullptr) continue;
-        transcribe::debug::dump_tensor(p.first.c_str(), p.second,
-                                       "encoder.block.subblock");
+        if (p.second == nullptr) {
+            continue;
+        }
+        transcribe::debug::dump_tensor(p.first.c_str(), p.second, "encoder.block.subblock");
     }
-    try_dump("enc.final",            eb.dumps.final_out,        "encoder.final");
-    try_dump("enc.prompted",         eb.dumps.prompted_out,     "encoder.prompted");
+    try_dump("enc.final", eb.dumps.final_out, "encoder.final");
+    try_dump("enc.prompted", eb.dumps.prompted_out, "encoder.prompted");
 
     pc->encoder_out = eb.out;
 
@@ -1246,47 +1151,37 @@ static transcribe_status run_one_shot_inner(
     const int T_enc = static_cast<int>(eb.out->ne[1]);
     if (d_enc <= 0 || T_enc <= 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "parakeet run: encoder output has degenerate shape "
-                     "[%d, %d]", d_enc, T_enc);
+                "parakeet run: encoder output has degenerate shape "
+                "[%d, %d]",
+                d_enc, T_enc);
         return TRANSCRIBE_ERR_GGUF;
     }
-    pc->enc_host.resize(static_cast<size_t>(d_enc) *
-                        static_cast<size_t>(T_enc));
-    ggml_backend_tensor_get(eb.out, pc->enc_host.data(), 0,
-                            pc->enc_host.size() * sizeof(float));
+    pc->enc_host.resize(static_cast<size_t>(d_enc) * static_cast<size_t>(T_enc));
+    ggml_backend_tensor_get(eb.out, pc->enc_host.data(), 0, pc->enc_host.size() * sizeof(float));
 
     // Prompt-conditioned models: eb.out is the post-prompt tensor
     // ("dec.enc_out_prompted"); also read back the pre-prompt final_out
     // as "dec.enc_out" so both reference dump names match.
-    if (pm->hparams.has_prompt && eb.dumps.final_out != nullptr &&
-        transcribe::debug::enabled())
-    {
+    if (pm->hparams.has_prompt && eb.dumps.final_out != nullptr && transcribe::debug::enabled()) {
         std::vector<float> unprompted(pc->enc_host.size());
-        ggml_backend_tensor_get(eb.dumps.final_out, unprompted.data(), 0,
-                                unprompted.size() * sizeof(float));
+        ggml_backend_tensor_get(eb.dumps.final_out, unprompted.data(), 0, unprompted.size() * sizeof(float));
         const long long shape[2] = { T_enc, d_enc };
-        transcribe::debug::dump_host_f32(
-            "dec.enc_out", unprompted.data(),
-            static_cast<long long>(T_enc) * static_cast<long long>(d_enc),
-            shape, 2, "decoder.enc_out");
+        transcribe::debug::dump_host_f32("dec.enc_out", unprompted.data(),
+                                         static_cast<long long>(T_enc) * static_cast<long long>(d_enc), shape, 2,
+                                         "decoder.enc_out");
     }
 
-    const char * enc_dump_name =
-        pm->hparams.has_prompt ? "dec.enc_out_prompted" : nullptr;
-    return decode_and_populate(pc, pm, params, pc->enc_host.data(),
-                               T_enc, d_enc, /*utt_index=*/-1,
-                               enc_dump_name);
+    const char * enc_dump_name = pm->hparams.has_prompt ? "dec.enc_out_prompted" : nullptr;
+    return decode_and_populate(pc, pm, params, pc->enc_host.data(), T_enc, d_enc, /*utt_index=*/-1, enc_dump_name);
 }
 
 // One-shot entry point. Validates session/pm, clears the previous result
 // snapshot, then forwards to the shared inference helper (also reused by
 // the streaming hooks).
-transcribe_status run(
-    transcribe_session *      session,
-    const float *             pcm,
-    int                       n_samples,
-    const transcribe_run_params * params)
-{
+transcribe_status run(transcribe_session *          session,
+                      const float *                 pcm,
+                      int                           n_samples,
+                      const transcribe_run_params * params) {
     // The dispatcher has already enum-validated params and rejected
     // TRANSLATE / sub-TOKEN timestamps; we only resolve AUTO and downcast
     // when the result is built.
@@ -1320,20 +1215,21 @@ static int pre_encode_t_out(int in) {
     return (in - 1) / 2 + 1;
 }
 
-static transcribe_status run_batch_encode(
-    ParakeetSession *                       pc,
-    ParakeetModel *                         pm,
-    const std::vector<std::vector<float>> & mels,
-    const std::vector<int> &                nf,
-    int                                     n_mels,
-    int                                     T_max,
-    int64_t                                 total_mel_us,
-    const transcribe_run_params *           params)
-{
-    const int n = static_cast<int>(mels.size());
-    bool var_len = false;
+static transcribe_status run_batch_encode(ParakeetSession *                       pc,
+                                          ParakeetModel *                         pm,
+                                          const std::vector<std::vector<float>> & mels,
+                                          const std::vector<int> &                nf,
+                                          int                                     n_mels,
+                                          int                                     T_max,
+                                          int64_t                                 total_mel_us,
+                                          const transcribe_run_params *           params) {
+    const int n       = static_cast<int>(mels.size());
+    bool      var_len = false;
     for (int b = 0; b < n; ++b) {
-        if (nf[b] != T_max) { var_len = true; break; }
+        if (nf[b] != T_max) {
+            var_len = true;
+            break;
+        }
     }
 
     // Pack mels into [T_max, n_mels, 1, n], zero-padding each along time
@@ -1346,54 +1242,61 @@ static transcribe_status run_batch_encode(
     }
     pc->encoder_out = nullptr;
     {
-        ggml_init_params init_params {};
+        ggml_init_params init_params{};
         init_params.mem_size   = 4 * 1024 * 1024;
         init_params.mem_buffer = nullptr;
         init_params.no_alloc   = true;
-        pc->compute_ctx = ggml_init(init_params);
-        if (pc->compute_ctx == nullptr) return TRANSCRIBE_ERR_GGUF;
+        pc->compute_ctx        = ggml_init(init_params);
+        if (pc->compute_ctx == nullptr) {
+            return TRANSCRIBE_ERR_GGUF;
+        }
     }
 
     ggml_type resolved_kv = GGML_TYPE_COUNT;
-    if (pc->kv_type == TRANSCRIBE_KV_TYPE_F32) resolved_kv = GGML_TYPE_F32;
-    if (pc->kv_type == TRANSCRIBE_KV_TYPE_F16) resolved_kv = GGML_TYPE_F16;
+    if (pc->kv_type == TRANSCRIBE_KV_TYPE_F32) {
+        resolved_kv = GGML_TYPE_F32;
+    }
+    if (pc->kv_type == TRANSCRIBE_KV_TYPE_F16) {
+        resolved_kv = GGML_TYPE_F16;
+    }
 
-    EncoderBuild eb = build_encoder_graph(
-        pc->compute_ctx, pm->weights, pm->hparams, T_max,
-        resolved_kv, pm->backend.c_str(), /*buf_mask=*/nullptr,
-        /*n_batch=*/n, /*batch_var_len=*/var_len);
+    EncoderBuild eb = build_encoder_graph(pc->compute_ctx, pm->weights, pm->hparams, T_max, resolved_kv,
+                                          pm->backend.c_str(), /*buf_mask=*/nullptr,
+                                          /*n_batch=*/n, /*batch_var_len=*/var_len);
     if (eb.mel_in == nullptr || eb.out == nullptr || eb.graph == nullptr) {
         return TRANSCRIBE_ERR_GGUF;
     }
 
     if (pc->sched == nullptr) {
-        pc->sched = ggml_backend_sched_new(
-            pm->plan.scheduler_list.data(), nullptr,
-            static_cast<int>(pm->plan.scheduler_list.size()),
-            /*graph_size=*/8192, /*parallel=*/false, /*op_offload=*/true);
-        if (pc->sched == nullptr) return TRANSCRIBE_ERR_GGUF;
+        pc->sched = ggml_backend_sched_new(pm->plan.scheduler_list.data(), nullptr,
+                                           static_cast<int>(pm->plan.scheduler_list.size()),
+                                           /*graph_size=*/8192, /*parallel=*/false, /*op_offload=*/true);
+        if (pc->sched == nullptr) {
+            return TRANSCRIBE_ERR_GGUF;
+        }
     }
     ggml_backend_sched_reset(pc->sched);
     if (!ggml_backend_sched_alloc_graph(pc->sched, eb.graph)) {
         return TRANSCRIBE_ERR_GGUF;
     }
 
-    ggml_backend_tensor_set(eb.mel_in, pc->mel_buf.data(),
-                            0, pc->mel_buf.size() * sizeof(float));
+    ggml_backend_tensor_set(eb.mel_in, pc->mel_buf.data(), 0, pc->mel_buf.size() * sizeof(float));
 
     const int d_enc = static_cast<int>(eb.out->ne[0]);
     const int T_enc = static_cast<int>(eb.out->ne[1]);
-    if (d_enc <= 0 || T_enc <= 0) return TRANSCRIBE_ERR_GGUF;
+    if (d_enc <= 0 || T_enc <= 0) {
+        return TRANSCRIBE_ERR_GGUF;
+    }
 
     // Per-utterance valid encoder-frame count (the same subsample the conv
     // stack applies: 3 stride-2 convs on the time axis).
     std::vector<int> real_tenc(static_cast<size_t>(n), T_enc);
     if (var_len) {
         for (int b = 0; b < n; ++b) {
-            int t = nf[b];
-            t = pre_encode_t_out(t);
-            t = pre_encode_t_out(t);
-            t = pre_encode_t_out(t);
+            int t        = nf[b];
+            t            = pre_encode_t_out(t);
+            t            = pre_encode_t_out(t);
+            t            = pre_encode_t_out(t);
             real_tenc[b] = std::min(t, T_enc);
         }
         // Attention key-padding mask [T_enc, 1, 1, n] (0 real / -INF padded)
@@ -1406,13 +1309,19 @@ static transcribe_status run_batch_encode(
         // length downsampled k times by the (in-1)/2+1 conv formula. Each
         // mask is ne=[1, H_stage, 1, n] -> host index b*H_stage + h.
         auto fill_pe_mask = [&](ggml_tensor * mask, int n_down) {
-            if (mask == nullptr) return;
-            const int H = static_cast<int>(mask->ne[1]);
+            if (mask == nullptr) {
+                return;
+            }
+            const int          H = static_cast<int>(mask->ne[1]);
             std::vector<float> mb(static_cast<size_t>(H) * n, 0.0f);
             for (int b = 0; b < n; ++b) {
                 int v = nf[b];
-                for (int d = 0; d < n_down; ++d) v = pre_encode_t_out(v);
-                if (v > H) v = H;
+                for (int d = 0; d < n_down; ++d) {
+                    v = pre_encode_t_out(v);
+                }
+                if (v > H) {
+                    v = H;
+                }
                 for (int h = 0; h < v; ++h) {
                     mb[static_cast<size_t>(b) * H + h] = 1.0f;
                 }
@@ -1426,103 +1335,84 @@ static transcribe_status run_batch_encode(
 
     // Positional embedding (batch-independent; depends only on T_enc).
     if (eb.pos_emb_in != nullptr) {
-        const int d_model = pm->hparams.enc_d_model;
-        const int pos_len = static_cast<int>(eb.pos_emb_in->ne[1]);
-        const bool is_chunked =
-            (pm->hparams.enc_att_context_style ==
-                 ParakeetHParams::AttContextStyle::ChunkedLimited);
+        const int  d_model    = pm->hparams.enc_d_model;
+        const int  pos_len    = static_cast<int>(eb.pos_emb_in->ne[1]);
+        const bool is_chunked = (pm->hparams.enc_att_context_style == ParakeetHParams::AttContextStyle::ChunkedLimited);
         const bool is_local_pe =
-            (!is_chunked) &&
-            (pm->hparams.enc_att_context_left >= 0 &&
-             pm->hparams.enc_att_context_right >= 0);
-        const int zero_index = is_local_pe
-            ? pm->hparams.enc_att_context_left
-            : (pos_len - 1) / 2;
+            (!is_chunked) && (pm->hparams.enc_att_context_left >= 0 && pm->hparams.enc_att_context_right >= 0);
+        const int zero_index = is_local_pe ? pm->hparams.enc_att_context_left : (pos_len - 1) / 2;
         pc->pos_buf.assign(static_cast<size_t>(pos_len) * d_model, 0.0f);
         pc->pos_div_term.resize(static_cast<size_t>(d_model / 2));
         const float ln_10000 = std::log(10000.0f);
         for (int k = 0; k < d_model / 2; ++k) {
             pc->pos_div_term[static_cast<size_t>(k)] =
-                std::exp(static_cast<float>(2 * k) *
-                         (-ln_10000 / static_cast<float>(d_model)));
+                std::exp(static_cast<float>(2 * k) * (-ln_10000 / static_cast<float>(d_model)));
         }
         for (int i = 0; i < pos_len; ++i) {
             const float pos = static_cast<float>(zero_index - i);
-            float * row = pc->pos_buf.data() + static_cast<size_t>(i) * d_model;
+            float *     row = pc->pos_buf.data() + static_cast<size_t>(i) * d_model;
             for (int k = 0; k < d_model / 2; ++k) {
                 const float div = pc->pos_div_term[static_cast<size_t>(k)];
-                row[2 * k]     = std::sin(pos * div);
-                row[2 * k + 1] = std::cos(pos * div);
+                row[2 * k]      = std::sin(pos * div);
+                row[2 * k + 1]  = std::cos(pos * div);
             }
         }
-        ggml_backend_tensor_set(eb.pos_emb_in, pc->pos_buf.data(),
-                                0, pc->pos_buf.size() * sizeof(float));
+        ggml_backend_tensor_set(eb.pos_emb_in, pc->pos_buf.data(), 0, pc->pos_buf.size() * sizeof(float));
     }
 
     // Prompt one-hot upload (multilingual variants). Resolves
     // params->language once for the whole batch (no per-utterance language
     // array in the ABI) and replicates across all (T_enc, B) slots.
     if (eb.prompt_one_hot_in != nullptr) {
-        const int P    = static_cast<int>(eb.prompt_one_hot_in->ne[0]);
-        const int T_oh = static_cast<int>(eb.prompt_one_hot_in->ne[1]);
-        const char * lang_hint =
-            (params != nullptr) ? params->language : nullptr;
-        const int32_t pid = resolve_prompt_id(pm->hparams, lang_hint);
+        const int     P         = static_cast<int>(eb.prompt_one_hot_in->ne[0]);
+        const int     T_oh      = static_cast<int>(eb.prompt_one_hot_in->ne[1]);
+        const char *  lang_hint = (params != nullptr) ? params->language : nullptr;
+        const int32_t pid       = resolve_prompt_id(pm->hparams, lang_hint);
         if (pid < 0) {
             log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "parakeet run_batch: language %s%s%s not in prompt "
-                         "dictionary",
-                         lang_hint ? "\"" : "",
-                         lang_hint ? lang_hint : "<null>",
-                         lang_hint ? "\"" : "");
+                    "parakeet run_batch: language %s%s%s not in prompt "
+                    "dictionary",
+                    lang_hint ? "\"" : "", lang_hint ? lang_hint : "<null>", lang_hint ? "\"" : "");
             return TRANSCRIBE_ERR_UNSUPPORTED_LANGUAGE;
         }
         std::vector<int32_t> pids(static_cast<size_t>(n), pid);
-        std::vector<float> one_hot_buf;
+        std::vector<float>   one_hot_buf;
         if (!fill_prompt_one_hot(one_hot_buf, P, T_oh, /*n_batch=*/n, pids)) {
             log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "parakeet run_batch: prompt_id %d out of range "
-                         "[0, %d)", pid, P);
+                    "parakeet run_batch: prompt_id %d out of range "
+                    "[0, %d)",
+                    pid, P);
             return TRANSCRIBE_ERR_GGUF;
         }
-        ggml_backend_tensor_set(eb.prompt_one_hot_in, one_hot_buf.data(),
-                                0, one_hot_buf.size() * sizeof(float));
+        ggml_backend_tensor_set(eb.prompt_one_hot_in, one_hot_buf.data(), 0, one_hot_buf.size() * sizeof(float));
     }
 
     // ChunkedLimited attention mask (cache-aware variants), same as
     // run_one_shot_inner. The pattern depends only on T_enc, shared
     // across the batch, so one mask broadcasts.
     if (eb.chunked_mask_in != nullptr) {
-        const int Tk          = static_cast<int>(eb.chunked_mask_in->ne[0]);
-        const int chunk_size  = pm->hparams.enc_att_context_right + 1;
-        const int left_chunks = (chunk_size > 0)
-            ? (pm->hparams.enc_att_context_left / chunk_size) : 0;
+        const int          Tk          = static_cast<int>(eb.chunked_mask_in->ne[0]);
+        const int          chunk_size  = pm->hparams.enc_att_context_right + 1;
+        const int          left_chunks = (chunk_size > 0) ? (pm->hparams.enc_att_context_left / chunk_size) : 0;
         std::vector<float> mask_buf(static_cast<size_t>(Tk) * Tk);
         for (int q = 0; q < Tk; ++q) {
-            const int q_chunk = (chunk_size > 0) ? (q / chunk_size) : 0;
-            const int k_min_chunk =
-                (q_chunk - left_chunks > 0) ? (q_chunk - left_chunks) : 0;
-            const int k_min = k_min_chunk * chunk_size;
-            const int k_max = (q_chunk + 1) * chunk_size;
-            float * row = mask_buf.data() + static_cast<size_t>(q) * Tk;
+            const int q_chunk     = (chunk_size > 0) ? (q / chunk_size) : 0;
+            const int k_min_chunk = (q_chunk - left_chunks > 0) ? (q_chunk - left_chunks) : 0;
+            const int k_min       = k_min_chunk * chunk_size;
+            const int k_max       = (q_chunk + 1) * chunk_size;
+            float *   row         = mask_buf.data() + static_cast<size_t>(q) * Tk;
             for (int k = 0; k < Tk; ++k) {
-                row[k] = (k >= k_min && k < k_max)
-                    ? 0.0f : -std::numeric_limits<float>::infinity();
+                row[k] = (k >= k_min && k < k_max) ? 0.0f : -std::numeric_limits<float>::infinity();
             }
         }
-        ggml_backend_tensor_set(eb.chunked_mask_in, mask_buf.data(),
-                                0, mask_buf.size() * sizeof(float));
+        ggml_backend_tensor_set(eb.chunked_mask_in, mask_buf.data(), 0, mask_buf.size() * sizeof(float));
     }
 
     transcribe::configure_sched_n_threads(pc->sched, pc->n_threads);
 
     const int64_t t_enc_start = ggml_time_us();
-    if (const ggml_status gs =
-            ggml_backend_sched_graph_compute(pc->sched, eb.graph);
-        gs != GGML_STATUS_SUCCESS)
-    {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "parakeet run_batch: graph_compute failed (%d)",
-                     static_cast<int>(gs));
+    if (const ggml_status gs = ggml_backend_sched_graph_compute(pc->sched, eb.graph); gs != GGML_STATUS_SUCCESS) {
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "parakeet run_batch: graph_compute failed (%d)", static_cast<int>(gs));
         return TRANSCRIBE_ERR_GGUF;
     }
     pc->t_encode_us = ggml_time_us() - t_enc_start;
@@ -1530,17 +1420,15 @@ static transcribe_status run_batch_encode(
     // Bisect dump (debug only): the batched encoder intermediates as full
     // [d_model, T_max, n] tensors, so a batched-vs-single divergence can be
     // located per stage. Gated on TRANSCRIBE_DUMP_ALL_BLOCKS.
-    if (transcribe::debug::enabled() &&
-        transcribe::debug::dump_all_blocks_requested())
-    {
+    if (transcribe::debug::enabled() && transcribe::debug::dump_all_blocks_requested()) {
         if (eb.dumps.pre_encode_out != nullptr) {
-            transcribe::debug::dump_tensor("enc.pre_encode.out",
-                                           eb.dumps.pre_encode_out,
-                                           "encoder.pre_encode");
+            transcribe::debug::dump_tensor("enc.pre_encode.out", eb.dumps.pre_encode_out, "encoder.pre_encode");
         }
         for (size_t i = 0; i < eb.dumps.all_block_outs.size(); ++i) {
             ggml_tensor * t = eb.dumps.all_block_outs[i];
-            if (t == nullptr) continue;
+            if (t == nullptr) {
+                continue;
+            }
             char name[64];
             std::snprintf(name, sizeof(name), "enc.block.%zu.out", i);
             transcribe::debug::dump_tensor(name, t, "encoder.block.bisect");
@@ -1549,53 +1437,41 @@ static transcribe_status run_batch_encode(
 
     const size_t utt_elems = static_cast<size_t>(d_enc) * static_cast<size_t>(T_enc);
     pc->enc_host.resize(utt_elems * static_cast<size_t>(n));
-    ggml_backend_tensor_get(eb.out, pc->enc_host.data(), 0,
-                            pc->enc_host.size() * sizeof(float));
+    ggml_backend_tensor_get(eb.out, pc->enc_host.data(), 0, pc->enc_host.size() * sizeof(float));
 
     // Prompt-conditioned variants: dump the PRE-prompt final_out per
     // utterance as "dec.enc_out.b{i}" (the post-prompt eb.out is dumped
     // via decode_and_populate's override). Mirrors single-shot.
-    const bool has_prompt = pm->hparams.has_prompt &&
-                            eb.dumps.final_out != nullptr;
+    const bool         has_prompt = pm->hparams.has_prompt && eb.dumps.final_out != nullptr;
     std::vector<float> unprompted_host;
     if (has_prompt && transcribe::debug::enabled()) {
         unprompted_host.resize(pc->enc_host.size());
-        ggml_backend_tensor_get(eb.dumps.final_out, unprompted_host.data(), 0,
-                                unprompted_host.size() * sizeof(float));
+        ggml_backend_tensor_get(eb.dumps.final_out, unprompted_host.data(), 0, unprompted_host.size() * sizeof(float));
         for (int b = 0; b < n; ++b) {
             const long long shape[2] = { real_tenc[b], d_enc };
-            char namebuf[64];
+            char            namebuf[64];
             std::snprintf(namebuf, sizeof(namebuf), "dec.enc_out.b%d", b);
-            transcribe::debug::dump_host_f32(
-                namebuf,
-                unprompted_host.data() + static_cast<size_t>(b) * utt_elems,
-                static_cast<long long>(real_tenc[b]) *
-                    static_cast<long long>(d_enc),
-                shape, 2, "decoder.enc_out");
+            transcribe::debug::dump_host_f32(namebuf, unprompted_host.data() + static_cast<size_t>(b) * utt_elems,
+                                             static_cast<long long>(real_tenc[b]) * static_cast<long long>(d_enc),
+                                             shape, 2, "decoder.enc_out");
         }
     }
-    const char * enc_dump_name =
-        has_prompt ? "dec.enc_out_prompted" : nullptr;
+    const char * enc_dump_name = has_prompt ? "dec.enc_out_prompted" : nullptr;
 
     // Host-slice the shared encoder output and decode each utterance.
     // decode_batch_slices amortizes the one shared encoder + total mel
     // cost across the batch; decode is genuinely per-utterance.
     return transcribe::decode_batch_slices(
-        pc, n, pc->enc_host.data(), utt_elems, pc->t_encode_us, total_mel_us,
-        [&](int b, const float * enc_b) {
-            return decode_and_populate(pc, pm, params, enc_b, real_tenc[b],
-                                       d_enc, /*utt_index=*/b,
-                                       enc_dump_name);
+        pc, n, pc->enc_host.data(), utt_elems, pc->t_encode_us, total_mel_us, [&](int b, const float * enc_b) {
+            return decode_and_populate(pc, pm, params, enc_b, real_tenc[b], d_enc, /*utt_index=*/b, enc_dump_name);
         });
 }
 
-transcribe_status run_batch(
-    transcribe_session *          session,
-    const float * const *         pcm,
-    const int *                   n_samples,
-    int                           n,
-    const transcribe_run_params * params)
-{
+transcribe_status run_batch(transcribe_session *          session,
+                            const float * const *         pcm,
+                            const int *                   n_samples,
+                            int                           n,
+                            const transcribe_run_params * params) {
     if (session == nullptr || pcm == nullptr || n_samples == nullptr || n <= 0) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
@@ -1613,20 +1489,22 @@ transcribe_status run_batch(
     std::vector<std::vector<float>> mels(static_cast<size_t>(n));
     std::vector<int>                nf(static_cast<size_t>(n), 0);
     std::vector<int>                n_mels_per(static_cast<size_t>(n), 0);
-    const int64_t t_mel_start = ggml_time_us();
-    const bool all_ok = transcribe::parallel_for_all(
-        n, pc->n_threads, [&](int i) -> bool {
-            if (pcm[i] == nullptr || n_samples[i] <= 0) return false;
-            int this_mels = 0, this_frames = 0;
-            const transcribe_status st = pm->mel->compute(
-                pcm[i], static_cast<size_t>(n_samples[i]),
-                mels[i], this_mels, this_frames);
-            if (st != TRANSCRIBE_OK || this_frames <= 0) return false;
-            nf[i]         = this_frames;
-            n_mels_per[i] = this_mels;
-            return true;
-        });
-    const int64_t total_mel_us = ggml_time_us() - t_mel_start;
+    const int64_t                   t_mel_start  = ggml_time_us();
+    const bool                      all_ok       = transcribe::parallel_for_all(n, pc->n_threads, [&](int i) -> bool {
+        if (pcm[i] == nullptr || n_samples[i] <= 0) {
+            return false;
+        }
+        int                     this_mels = 0, this_frames = 0;
+        const transcribe_status st =
+            pm->mel->compute(pcm[i], static_cast<size_t>(n_samples[i]), mels[i], this_mels, this_frames);
+        if (st != TRANSCRIBE_OK || this_frames <= 0) {
+            return false;
+        }
+        nf[i]         = this_frames;
+        n_mels_per[i] = this_mels;
+        return true;
+    });
+    const int64_t                   total_mel_us = ggml_time_us() - t_mel_start;
 
     if (all_ok) {
         int T_max = 0, n_mels = 0;
@@ -1634,13 +1512,14 @@ transcribe_status run_batch(
             T_max  = std::max(T_max, nf[i]);
             n_mels = std::max(n_mels, n_mels_per[i]);
         }
-        return run_batch_encode(pc, pm, mels, nf, n_mels, T_max,
-                                total_mel_us, params);
+        return run_batch_encode(pc, pm, mels, nf, n_mels, T_max, total_mel_us, params);
     }
 
     // Per-utterance fallback (also the malformed-input path).
     for (int i = 0; i < n; ++i) {
-        if (pc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
+        if (pc->poll_abort()) {
+            return TRANSCRIBE_ERR_ABORTED;
+        }
         if (pcm[i] == nullptr || n_samples[i] <= 0) {
             transcribe_session::ResultSet rs;
             rs.status = TRANSCRIBE_ERR_INVALID_ARG;
@@ -1648,8 +1527,7 @@ transcribe_status run_batch(
             continue;
         }
         pc->clear_result();
-        const transcribe_status st =
-            run_one_shot_inner(pc, pm, pcm[i], n_samples[i], params);
+        const transcribe_status st = run_one_shot_inner(pc, pm, pcm[i], n_samples[i], params);
         pc->batch_results.push_back(pc->capture_result(st));
     }
     return TRANSCRIBE_OK;
@@ -1687,11 +1565,7 @@ static int64_t us_to_ms(int64_t us) {
 // positions[i] = (T_virtual - 1) - i, div_term[k] = exp(2k * -ln(10000)
 // / d_model). pos_emb_in is ne=[d_model, pos_len, 1, 1] f32. Resizes
 // pc->pos_buf / pc->pos_div_term in place.
-void fill_streaming_pos_emb(ParakeetSession * pc,
-                            ggml_tensor *     pos_emb_in,
-                            int               d_model,
-                            int               zero_index)
-{
+void fill_streaming_pos_emb(ParakeetSession * pc, ggml_tensor * pos_emb_in, int d_model, int zero_index) {
     const int pos_len = static_cast<int>(pos_emb_in->ne[1]);
 
     pc->pos_buf.assign(static_cast<size_t>(pos_len) * d_model, 0.0f);
@@ -1699,21 +1573,18 @@ void fill_streaming_pos_emb(ParakeetSession * pc,
     const float ln_10000 = std::log(10000.0f);
     for (int k = 0; k < d_model / 2; ++k) {
         pc->pos_div_term[static_cast<size_t>(k)] =
-            std::exp(static_cast<float>(2 * k) *
-                     (-ln_10000 / static_cast<float>(d_model)));
+            std::exp(static_cast<float>(2 * k) * (-ln_10000 / static_cast<float>(d_model)));
     }
     for (int i = 0; i < pos_len; ++i) {
         const float pos = static_cast<float>(zero_index - i);
-        float * row = pc->pos_buf.data() +
-            static_cast<size_t>(i) * d_model;
+        float *     row = pc->pos_buf.data() + static_cast<size_t>(i) * d_model;
         for (int k = 0; k < d_model / 2; ++k) {
             const float div = pc->pos_div_term[static_cast<size_t>(k)];
-            row[2 * k]     = std::sin(pos * div);
-            row[2 * k + 1] = std::cos(pos * div);
+            row[2 * k]      = std::sin(pos * div);
+            row[2 * k + 1]  = std::cos(pos * div);
         }
     }
-    ggml_backend_tensor_set(pos_emb_in, pc->pos_buf.data(),
-                            0, pc->pos_buf.size() * sizeof(float));
+    ggml_backend_tensor_set(pos_emb_in, pc->pos_buf.data(), 0, pc->pos_buf.size() * sizeof(float));
 }
 
 // Fill the streaming attention mask. Square shape [T_virtual,T_virtual]
@@ -1729,36 +1600,27 @@ void fill_streaming_chunked_mask(ggml_tensor * mask_in,
                                  int           T_cache,
                                  int           channel_len,
                                  int           att_context_left,
-                                 int           att_context_right)
-{
-    const int n_q_rows = static_cast<int>(mask_in->ne[1]);
-    const int q_first  = T_virtual - n_q_rows;
-    const int chunk_size  = att_context_right + 1;
-    const int left_chunks = (chunk_size > 0)
-        ? (att_context_left / chunk_size)
-        : 0;
+                                 int           att_context_right) {
+    const int n_q_rows                = static_cast<int>(mask_in->ne[1]);
+    const int q_first                 = T_virtual - n_q_rows;
+    const int chunk_size              = att_context_right + 1;
+    const int left_chunks             = (chunk_size > 0) ? (att_context_left / chunk_size) : 0;
     const int invalid_cache_threshold = T_cache - channel_len;
 
-    std::vector<float> mask_buf(
-        static_cast<size_t>(n_q_rows) * static_cast<size_t>(T_virtual));
+    std::vector<float> mask_buf(static_cast<size_t>(n_q_rows) * static_cast<size_t>(T_virtual));
     for (int q = q_first; q < T_virtual; ++q) {
         const int q_chunk     = (chunk_size > 0) ? (q / chunk_size) : 0;
-        const int k_min_chunk = (q_chunk - left_chunks > 0)
-            ? (q_chunk - left_chunks) : 0;
-        const int k_min = k_min_chunk * chunk_size;
-        const int k_max = (q_chunk + 1) * chunk_size; // exclusive
-        float * row = mask_buf.data() +
-            static_cast<size_t>(q - q_first) * T_virtual;
+        const int k_min_chunk = (q_chunk - left_chunks > 0) ? (q_chunk - left_chunks) : 0;
+        const int k_min       = k_min_chunk * chunk_size;
+        const int k_max       = (q_chunk + 1) * chunk_size;  // exclusive
+        float *   row         = mask_buf.data() + static_cast<size_t>(q - q_first) * T_virtual;
         for (int k = 0; k < T_virtual; ++k) {
-            const bool in_band      = (k >= k_min && k < k_max);
+            const bool in_band        = (k >= k_min && k < k_max);
             const bool cache_unfilled = (k < invalid_cache_threshold);
-            row[k] = (in_band && !cache_unfilled)
-                ? 0.0f
-                : -std::numeric_limits<float>::infinity();
+            row[k]                    = (in_band && !cache_unfilled) ? 0.0f : -std::numeric_limits<float>::infinity();
         }
     }
-    ggml_backend_tensor_set(mask_in, mask_buf.data(),
-                            0, mask_buf.size() * sizeof(float));
+    ggml_backend_tensor_set(mask_in, mask_buf.data(), 0, mask_buf.size() * sizeof(float));
 }
 
 // Rebuild the per-layer rel-pos projection cache for `pos_len` (see
@@ -1766,22 +1628,18 @@ void fill_streaming_chunked_mask(ggml_tensor * mask_in,
 // mul_mats + layout massaging) through the session scheduler, reading
 // pos_emb from pc->pos_buf. Called only on a geometry change — twice per
 // stream in practice (first-chunk, then steady state).
-transcribe_status ensure_pos_proj_cache(ParakeetSession * pc,
-                                        ParakeetModel *   pm,
-                                        int               pos_len)
-{
+transcribe_status ensure_pos_proj_cache(ParakeetSession * pc, ParakeetModel * pm, int pos_len) {
     const auto & hp       = pm->hparams;
     const int    n_layers = static_cast<int>(pm->weights.blocks.size());
     const int    d_model  = hp.enc_d_model;
     const int    n_head   = hp.enc_n_heads;
     const int    head_dim = d_model / n_head;
 
-    if (pc->pos_buf.size() <
-        static_cast<size_t>(pos_len) * static_cast<size_t>(d_model))
-    {
+    if (pc->pos_buf.size() < static_cast<size_t>(pos_len) * static_cast<size_t>(d_model)) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "parakeet stream: pos_proj cache fill without pos_buf "
-            "(%zu < %d*%d)", pc->pos_buf.size(), pos_len, d_model);
+                "parakeet stream: pos_proj cache fill without pos_buf "
+                "(%zu < %d*%d)",
+                pc->pos_buf.size(), pos_len, d_model);
         return TRANSCRIBE_ERR_BACKEND;
     }
 
@@ -1797,48 +1655,49 @@ transcribe_status ensure_pos_proj_cache(ParakeetSession * pc,
     sc.pos_proj.assign(static_cast<size_t>(n_layers), nullptr);
     sc.pos_proj_len = -1;
 
-    ggml_init_params pip {};
-    pip.mem_size   = (static_cast<size_t>(n_layers) + 2) *
-                     ggml_tensor_overhead();
-    pip.mem_buffer = nullptr;
-    pip.no_alloc   = true;
+    ggml_init_params pip{};
+    pip.mem_size    = (static_cast<size_t>(n_layers) + 2) * ggml_tensor_overhead();
+    pip.mem_buffer  = nullptr;
+    pip.no_alloc    = true;
     sc.pos_proj_ctx = ggml_init(pip);
-    if (sc.pos_proj_ctx == nullptr) return TRANSCRIBE_ERR_OOM;
+    if (sc.pos_proj_ctx == nullptr) {
+        return TRANSCRIBE_ERR_OOM;
+    }
 
     for (int i = 0; i < n_layers; ++i) {
-        ggml_tensor * t = ggml_new_tensor_3d(
-            sc.pos_proj_ctx, GGML_TYPE_F32, head_dim, pos_len, n_head);
-        if (t == nullptr) return TRANSCRIBE_ERR_OOM;
+        ggml_tensor * t = ggml_new_tensor_3d(sc.pos_proj_ctx, GGML_TYPE_F32, head_dim, pos_len, n_head);
+        if (t == nullptr) {
+            return TRANSCRIBE_ERR_OOM;
+        }
         char nm[64];
         std::snprintf(nm, sizeof(nm), "stream.pos_proj.%d", i);
         ggml_set_name(t, nm);
         sc.pos_proj[static_cast<size_t>(i)] = t;
     }
-    sc.pos_proj_buf = ggml_backend_alloc_ctx_tensors(
-        sc.pos_proj_ctx, pm->plan.primary);
-    if (sc.pos_proj_buf == nullptr) return TRANSCRIBE_ERR_OOM;
+    sc.pos_proj_buf = ggml_backend_alloc_ctx_tensors(sc.pos_proj_ctx, pm->plan.primary);
+    if (sc.pos_proj_buf == nullptr) {
+        return TRANSCRIBE_ERR_OOM;
+    }
 
     // One-off projection graph.
-    ggml_init_params gip {};
-    gip.mem_size   = 4 * 1024 * 1024;
-    gip.mem_buffer = nullptr;
-    gip.no_alloc   = true;
+    ggml_init_params gip{};
+    gip.mem_size        = 4 * 1024 * 1024;
+    gip.mem_buffer      = nullptr;
+    gip.no_alloc        = true;
     ggml_context * gctx = ggml_init(gip);
-    if (gctx == nullptr) return TRANSCRIBE_ERR_OOM;
+    if (gctx == nullptr) {
+        return TRANSCRIBE_ERR_OOM;
+    }
 
-    ggml_cgraph * graph = ggml_new_graph_custom(gctx, 512, false);
-    ggml_tensor * pos_in = ggml_new_tensor_2d(
-        gctx, GGML_TYPE_F32, d_model, pos_len);
+    ggml_cgraph * graph  = ggml_new_graph_custom(gctx, 512, false);
+    ggml_tensor * pos_in = ggml_new_tensor_2d(gctx, GGML_TYPE_F32, d_model, pos_len);
     ggml_set_name(pos_in, "pos_proj.pos_emb.in");
     ggml_set_input(pos_in);
     for (int i = 0; i < n_layers; ++i) {
-        ggml_tensor * p = ggml_mul_mat(
-            gctx, pm->weights.blocks[static_cast<size_t>(i)].attn_pos_w,
-            pos_in);
-        p = ggml_reshape_4d(gctx, p, head_dim, n_head, pos_len, 1);
-        p = ggml_cont(gctx, ggml_permute(gctx, p, 0, 2, 1, 3));
-        ggml_tensor * cpy = ggml_cpy(
-            gctx, p, sc.pos_proj[static_cast<size_t>(i)]);
+        ggml_tensor * p   = ggml_mul_mat(gctx, pm->weights.blocks[static_cast<size_t>(i)].attn_pos_w, pos_in);
+        p                 = ggml_reshape_4d(gctx, p, head_dim, n_head, pos_len, 1);
+        p                 = ggml_cont(gctx, ggml_permute(gctx, p, 0, 2, 1, 3));
+        ggml_tensor * cpy = ggml_cpy(gctx, p, sc.pos_proj[static_cast<size_t>(i)]);
         ggml_build_forward_expand(graph, cpy);
     }
 
@@ -1847,12 +1706,8 @@ transcribe_status ensure_pos_proj_cache(ParakeetSession * pc,
     if (!ggml_backend_sched_alloc_graph(pc->sched, graph)) {
         st = TRANSCRIBE_ERR_BACKEND;
     } else {
-        ggml_backend_tensor_set(
-            pos_in, pc->pos_buf.data(), 0,
-            static_cast<size_t>(pos_len) * d_model * sizeof(float));
-        if (ggml_backend_sched_graph_compute(pc->sched, graph) !=
-            GGML_STATUS_SUCCESS)
-        {
+        ggml_backend_tensor_set(pos_in, pc->pos_buf.data(), 0, static_cast<size_t>(pos_len) * d_model * sizeof(float));
+        if (ggml_backend_sched_graph_compute(pc->sched, graph) != GGML_STATUS_SUCCESS) {
             st = TRANSCRIBE_ERR_BACKEND;
         }
     }
@@ -1863,18 +1718,16 @@ transcribe_status ensure_pos_proj_cache(ParakeetSession * pc,
     return st;
 }
 
-} // namespace
+}  // namespace
 
 // Declared in parakeet.h (non-anonymous) so unit tests and the buffered
 // driver can link against it.
-void compute_chunked_limited_with_rc_mask(
-    float * out_buf,
-    int     T,
-    int     left_context_frames,
-    int     chunk_size_frames,
-    int     right_context_frames,
-    int     pad_length)
-{
+void compute_chunked_limited_with_rc_mask(float * out_buf,
+                                          int     T,
+                                          int     left_context_frames,
+                                          int     chunk_size_frames,
+                                          int     right_context_frames,
+                                          int     pad_length) {
     assert(out_buf != nullptr);
     assert(T >= 1);
     assert(chunk_size_frames >= 1);
@@ -1890,21 +1743,18 @@ void compute_chunked_limited_with_rc_mask(
     const int P = pad_length > T ? T : pad_length;
 
     for (int q = 0; q < T; ++q) {
-        const int c_q                    = q / C;
-        const int window_start_unclamped = c_q * C - L;
-        const int window_end_unclamped   = c_q * C + C - 1 + R;
-        const int window_start = window_start_unclamped > 0 ? window_start_unclamped : 0;
-        const int window_end   = window_end_unclamped < (T - 1) ? window_end_unclamped : (T - 1);
-        const bool q_padded    = q >= P;
+        const int  c_q                    = q / C;
+        const int  window_start_unclamped = c_q * C - L;
+        const int  window_end_unclamped   = c_q * C + C - 1 + R;
+        const int  window_start           = window_start_unclamped > 0 ? window_start_unclamped : 0;
+        const int  window_end             = window_end_unclamped < (T - 1) ? window_end_unclamped : (T - 1);
+        const bool q_padded               = q >= P;
 
         float * row = out_buf + static_cast<size_t>(q) * static_cast<size_t>(T);
         for (int k = 0; k < T; ++k) {
             const bool k_padded = k >= P;
-            const bool allowed  = (k >= window_start && k <= window_end)
-                                  && !q_padded && !k_padded;
-            row[k] = allowed
-                ? 0.0f
-                : -std::numeric_limits<float>::infinity();
+            const bool allowed  = (k >= window_start && k <= window_end) && !q_padded && !k_padded;
+            row[k]              = allowed ? 0.0f : -std::numeric_limits<float>::infinity();
         }
     }
 }
@@ -1922,47 +1772,55 @@ namespace {
 //                          is in play).
 // On success, appends TdtTokens to pc->raw_tokens and advances the cache
 // + decoder state.
-transcribe_status emit_streaming_chunk(
-    ParakeetSession * pc,
-    ParakeetModel *   pm,
-    const float *     mel_chunk_data,
-    int               n_mel_chunk_frames,
-    int               drop_extra_pre_encoded,
-    int               mel_frames_advance)
-{
-    const auto & hp = pm->hparams;
-    const int n_layers = static_cast<int>(pm->weights.blocks.size());
+transcribe_status emit_streaming_chunk(ParakeetSession * pc,
+                                       ParakeetModel *   pm,
+                                       const float *     mel_chunk_data,
+                                       int               n_mel_chunk_frames,
+                                       int               drop_extra_pre_encoded,
+                                       int               mel_frames_advance) {
+    const auto & hp       = pm->hparams;
+    const int    n_layers = static_cast<int>(pm->weights.blocks.size());
 
     ggml_type resolved_kv = GGML_TYPE_COUNT;
-    if (pc->kv_type == TRANSCRIBE_KV_TYPE_F32) resolved_kv = GGML_TYPE_F32;
-    if (pc->kv_type == TRANSCRIBE_KV_TYPE_F16) resolved_kv = GGML_TYPE_F16;
+    if (pc->kv_type == TRANSCRIBE_KV_TYPE_F32) {
+        resolved_kv = GGML_TYPE_F32;
+    }
+    if (pc->kv_type == TRANSCRIBE_KV_TYPE_F16) {
+        resolved_kv = GGML_TYPE_F16;
+    }
 
     // One compute_ctx per chunk (matches the offline run() lifecycle).
     if (pc->compute_ctx != nullptr) {
         ggml_free(pc->compute_ctx);
         pc->compute_ctx = nullptr;
     }
-    ggml_init_params ip {};
-    ip.mem_size   = 16 * 1024 * 1024;
-    ip.mem_buffer = nullptr;
-    ip.no_alloc   = true;
+    ggml_init_params ip{};
+    ip.mem_size     = 16 * 1024 * 1024;
+    ip.mem_buffer   = nullptr;
+    ip.no_alloc     = true;
     pc->compute_ctx = ggml_init(ip);
     if (pc->compute_ctx == nullptr) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "parakeet stream: ggml_init compute_ctx failed");
         return TRANSCRIBE_ERR_OOM;
     }
 
-    const int step_num = pc->stream_caches.chunk_step;
-    const bool dump_on = transcribe::debug::enabled();
+    const int  step_num = pc->stream_caches.chunk_step;
+    const bool dump_on  = transcribe::debug::enabled();
 
     // Per-step dump layer selection: match the Python dumper's default
     // ({0, n/2, n-1}). The selected layers are read AFTER graph_compute
     // for cache_out and BEFORE for cache_in.
     auto sel_layers = [&]() {
         std::vector<int> v;
-        if (n_layers <= 0) return v;
-        std::set<int> s = {0, n_layers / 2, n_layers - 1};
-        for (int i : s) if (i >= 0 && i < n_layers) v.push_back(i);
+        if (n_layers <= 0) {
+            return v;
+        }
+        std::set<int> s = { 0, n_layers / 2, n_layers - 1 };
+        for (int i : s) {
+            if (i >= 0 && i < n_layers) {
+                v.push_back(i);
+            }
+        }
         std::sort(v.begin(), v.end());
         return v;
     }();
@@ -1970,24 +1828,16 @@ transcribe_status emit_streaming_chunk(
     // Dump mel_in + cache_in (snapshot of inputs to this chunk).
     if (dump_on) {
         char namebuf[128];
-        std::snprintf(namebuf, sizeof(namebuf),
-                      "stream.chunk.%d.mel_in", step_num);
-        const long long mel_shape[2] = {hp.fe_num_mels, n_mel_chunk_frames};
-        transcribe::debug::dump_host_f32(
-            namebuf, mel_chunk_data,
-            static_cast<long long>(hp.fe_num_mels) * n_mel_chunk_frames,
-            mel_shape, 2, "streaming.mel_in");
+        std::snprintf(namebuf, sizeof(namebuf), "stream.chunk.%d.mel_in", step_num);
+        const long long mel_shape[2] = { hp.fe_num_mels, n_mel_chunk_frames };
+        transcribe::debug::dump_host_f32(namebuf, mel_chunk_data,
+                                         static_cast<long long>(hp.fe_num_mels) * n_mel_chunk_frames, mel_shape, 2,
+                                         "streaming.mel_in");
         for (int L : sel_layers) {
-            std::snprintf(namebuf, sizeof(namebuf),
-                          "stream.chunk.%d.cache_lc_in_%d", step_num, L);
-            transcribe::debug::dump_tensor(
-                namebuf, pc->stream_caches.last_channel[L],
-                "streaming.cache_in");
-            std::snprintf(namebuf, sizeof(namebuf),
-                          "stream.chunk.%d.cache_lt_in_%d", step_num, L);
-            transcribe::debug::dump_tensor(
-                namebuf, pc->stream_caches.last_time[L],
-                "streaming.cache_in");
+            std::snprintf(namebuf, sizeof(namebuf), "stream.chunk.%d.cache_lc_in_%d", step_num, L);
+            transcribe::debug::dump_tensor(namebuf, pc->stream_caches.last_channel[L], "streaming.cache_in");
+            std::snprintf(namebuf, sizeof(namebuf), "stream.chunk.%d.cache_lt_in_%d", step_num, L);
+            transcribe::debug::dump_tensor(namebuf, pc->stream_caches.last_time[L], "streaming.cache_in");
         }
     }
 
@@ -1999,19 +1849,16 @@ transcribe_status emit_streaming_chunk(
     cache_io.pos_proj     = pc->stream_caches.pos_proj;
     cache_io.pos_proj_len = pc->stream_caches.pos_proj_len;
 
-    EncoderBuild eb = build_encoder_graph_streaming(
-        pc->compute_ctx, pm->weights, hp,
-        n_mel_chunk_frames, drop_extra_pre_encoded,
-        cache_io, resolved_kv, pm->backend.c_str());
+    EncoderBuild eb = build_encoder_graph_streaming(pc->compute_ctx, pm->weights, hp, n_mel_chunk_frames,
+                                                    drop_extra_pre_encoded, cache_io, resolved_kv, pm->backend.c_str());
     if (eb.out == nullptr || eb.graph == nullptr) {
         return TRANSCRIBE_ERR_GGUF;
     }
 
     if (pc->sched == nullptr) {
-        pc->sched = ggml_backend_sched_new(
-            pm->plan.scheduler_list.data(), nullptr,
-            static_cast<int>(pm->plan.scheduler_list.size()),
-            /*graph_size=*/8192, /*parallel=*/false, /*op_offload=*/true);
+        pc->sched = ggml_backend_sched_new(pm->plan.scheduler_list.data(), nullptr,
+                                           static_cast<int>(pm->plan.scheduler_list.size()),
+                                           /*graph_size=*/8192, /*parallel=*/false, /*op_offload=*/true);
         if (pc->sched == nullptr) {
             log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "parakeet stream: sched_new failed");
             return TRANSCRIBE_ERR_BACKEND;
@@ -2027,8 +1874,7 @@ transcribe_status emit_streaming_chunk(
     // byte-identical to ggml ne=[n_mel_chunk_frames, n_mels, 1, 1].
     ggml_backend_tensor_set(
         eb.mel_in, mel_chunk_data, 0,
-        static_cast<size_t>(n_mel_chunk_frames) *
-            static_cast<size_t>(hp.fe_num_mels) * sizeof(float));
+        static_cast<size_t>(n_mel_chunk_frames) * static_cast<size_t>(hp.fe_num_mels) * sizeof(float));
 
     const int T_virtual = static_cast<int>(eb.chunked_mask_in->ne[0]);
     const int T_cache   = hp.enc_att_context_left;
@@ -2045,92 +1891,67 @@ transcribe_status emit_streaming_chunk(
     // The band uses the (left, right) RESOLVED for this stream, not the
     // model-default hparams (correct by construction even if a future
     // variant's menu breaks today's coincidence).
-    fill_streaming_chunked_mask(
-        eb.chunked_mask_in, T_virtual, T_cache,
-        pc->stream_caches.channel_len,
-        pc->stream_caches.att_context_left,
-        pc->stream_caches.att_context_right);
+    fill_streaming_chunked_mask(eb.chunked_mask_in, T_virtual, T_cache, pc->stream_caches.channel_len,
+                                pc->stream_caches.att_context_left, pc->stream_caches.att_context_right);
 
     // Prompt one-hot upload (multilingual variants only). Same shape as
     // the offline path; the language hint lives in pc->stream_run_params.
     if (eb.prompt_one_hot_in != nullptr) {
-        const int P    = static_cast<int>(eb.prompt_one_hot_in->ne[0]);
-        const int T_oh = static_cast<int>(eb.prompt_one_hot_in->ne[1]);
-        const char * lang_hint = pc->stream_run_params.language;
-        const int32_t pid = resolve_prompt_id(pm->hparams, lang_hint);
+        const int     P         = static_cast<int>(eb.prompt_one_hot_in->ne[0]);
+        const int     T_oh      = static_cast<int>(eb.prompt_one_hot_in->ne[1]);
+        const char *  lang_hint = pc->stream_run_params.language;
+        const int32_t pid       = resolve_prompt_id(pm->hparams, lang_hint);
         if (pid < 0) {
             log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "parakeet stream: language %s%s%s not in prompt "
-                         "dictionary",
-                         lang_hint ? "\"" : "",
-                         lang_hint ? lang_hint : "<null>",
-                         lang_hint ? "\"" : "");
+                    "parakeet stream: language %s%s%s not in prompt "
+                    "dictionary",
+                    lang_hint ? "\"" : "", lang_hint ? lang_hint : "<null>", lang_hint ? "\"" : "");
             return TRANSCRIBE_ERR_UNSUPPORTED_LANGUAGE;
         }
         std::vector<float> one_hot_buf;
-        if (!fill_prompt_one_hot(one_hot_buf, P, T_oh, /*n_batch=*/1,
-                                 {pid}))
-        {
+        if (!fill_prompt_one_hot(one_hot_buf, P, T_oh, /*n_batch=*/1, { pid })) {
             log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "parakeet stream: prompt_id %d out of range "
-                         "[0, %d)", pid, P);
+                    "parakeet stream: prompt_id %d out of range "
+                    "[0, %d)",
+                    pid, P);
             return TRANSCRIBE_ERR_GGUF;
         }
-        ggml_backend_tensor_set(eb.prompt_one_hot_in, one_hot_buf.data(),
-                                0, one_hot_buf.size() * sizeof(float));
+        ggml_backend_tensor_set(eb.prompt_one_hot_in, one_hot_buf.data(), 0, one_hot_buf.size() * sizeof(float));
     }
 
     // Thread count (same recipe as offline run()).
     transcribe::configure_sched_n_threads(pc->sched, pc->n_threads);
 
-    if (const ggml_status gs =
-            ggml_backend_sched_graph_compute(pc->sched, eb.graph);
-        gs != GGML_STATUS_SUCCESS)
-    {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "parakeet stream: graph_compute failed (%d)",
-                     static_cast<int>(gs));
+    if (const ggml_status gs = ggml_backend_sched_graph_compute(pc->sched, eb.graph); gs != GGML_STATUS_SUCCESS) {
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "parakeet stream: graph_compute failed (%d)", static_cast<int>(gs));
         return TRANSCRIBE_ERR_GGUF;
     }
 
     // Read encoder output back to host.
     const int d_enc = static_cast<int>(eb.out->ne[0]);
-    pc->enc_host.resize(
-        static_cast<size_t>(d_enc) * static_cast<size_t>(T_q_new));
-    ggml_backend_tensor_get(eb.out, pc->enc_host.data(), 0,
-                            pc->enc_host.size() * sizeof(float));
+    pc->enc_host.resize(static_cast<size_t>(d_enc) * static_cast<size_t>(T_q_new));
+    ggml_backend_tensor_get(eb.out, pc->enc_host.data(), 0, pc->enc_host.size() * sizeof(float));
 
     // Dump enc_out + cache_out, BEFORE the cache rotation so the
     // cache_out tensors are still the freshly-computed ones.
     if (dump_on) {
         char namebuf[128];
-        std::snprintf(namebuf, sizeof(namebuf),
-                      "stream.chunk.%d.enc_out", step_num);
+        std::snprintf(namebuf, sizeof(namebuf), "stream.chunk.%d.enc_out", step_num);
         // Match the Python dumper's squeeze: T_q_new == 1 (R=0) drops the
         // leading size-1 dim so the on-disk shape is [d_enc] not [1, d_enc].
         if (T_q_new == 1) {
-            const long long enc_shape[1] = {d_enc};
-            transcribe::debug::dump_host_f32(
-                namebuf, pc->enc_host.data(), d_enc,
-                enc_shape, 1, "streaming.enc_out");
+            const long long enc_shape[1] = { d_enc };
+            transcribe::debug::dump_host_f32(namebuf, pc->enc_host.data(), d_enc, enc_shape, 1, "streaming.enc_out");
         } else {
-            const long long enc_shape[2] = {T_q_new, d_enc};
-            transcribe::debug::dump_host_f32(
-                namebuf, pc->enc_host.data(),
-                static_cast<long long>(T_q_new) * d_enc,
-                enc_shape, 2, "streaming.enc_out");
+            const long long enc_shape[2] = { T_q_new, d_enc };
+            transcribe::debug::dump_host_f32(namebuf, pc->enc_host.data(), static_cast<long long>(T_q_new) * d_enc,
+                                             enc_shape, 2, "streaming.enc_out");
         }
         for (int L : sel_layers) {
-            std::snprintf(namebuf, sizeof(namebuf),
-                          "stream.chunk.%d.cache_lc_out_%d", step_num, L);
-            transcribe::debug::dump_tensor(
-                namebuf, cache_io.channel_out[L],
-                "streaming.cache_out");
-            std::snprintf(namebuf, sizeof(namebuf),
-                          "stream.chunk.%d.cache_lt_out_%d", step_num, L);
-            transcribe::debug::dump_tensor(
-                namebuf, cache_io.time_out[L],
-                "streaming.cache_out");
+            std::snprintf(namebuf, sizeof(namebuf), "stream.chunk.%d.cache_lc_out_%d", step_num, L);
+            transcribe::debug::dump_tensor(namebuf, cache_io.channel_out[L], "streaming.cache_out");
+            std::snprintf(namebuf, sizeof(namebuf), "stream.chunk.%d.cache_lt_out_%d", step_num, L);
+            transcribe::debug::dump_tensor(namebuf, cache_io.time_out[L], "streaming.cache_out");
         }
     }
 
@@ -2141,19 +1962,18 @@ transcribe_status emit_streaming_chunk(
     // cache_out here is a builder bug.
     const bool kv_mode = !cache_io.k_out.empty();
     for (int i = 0; i < n_layers; ++i) {
-        ggml_tensor * ch = cache_io.channel_out[i];
-        ggml_tensor * tm = cache_io.time_out[i];
-        ggml_tensor * ko = kv_mode ? cache_io.k_out[i] : nullptr;
-        ggml_tensor * vo = kv_mode ? cache_io.v_out[i] : nullptr;
-        const bool attn_ok = kv_mode
-            ? (ko != nullptr && ko->buffer != nullptr &&
-               vo != nullptr && vo->buffer != nullptr)
-            : (ch != nullptr && ch->buffer != nullptr);
+        ggml_tensor * ch      = cache_io.channel_out[i];
+        ggml_tensor * tm      = cache_io.time_out[i];
+        ggml_tensor * ko      = kv_mode ? cache_io.k_out[i] : nullptr;
+        ggml_tensor * vo      = kv_mode ? cache_io.v_out[i] : nullptr;
+        const bool    attn_ok = kv_mode ?
+                                    (ko != nullptr && ko->buffer != nullptr && vo != nullptr && vo->buffer != nullptr) :
+                                    (ch != nullptr && ch->buffer != nullptr);
         if (!attn_ok || tm == nullptr || tm->buffer == nullptr) {
             log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "parakeet stream: cache_out unallocated at layer %d "
-                "(att_context_right=%d) — builder bug",
-                i, pc->stream_caches.att_context_right);
+                    "parakeet stream: cache_out unallocated at layer %d "
+                    "(att_context_right=%d) — builder bug",
+                    i, pc->stream_caches.att_context_right);
             return TRANSCRIBE_ERR_BACKEND;
         }
         if (kv_mode) {
@@ -2164,8 +1984,7 @@ transcribe_status emit_streaming_chunk(
         }
         ggml_backend_tensor_copy(tm, pc->stream_caches.last_time[i]);
     }
-    pc->stream_caches.channel_len = std::min(
-        T_cache, pc->stream_caches.channel_len + T_q_new);
+    pc->stream_caches.channel_len = std::min(T_cache, pc->stream_caches.channel_len + T_q_new);
 
     // Refill the rel-pos projection memo on geometry change. Must come
     // after the cache rotation: ensure_pos_proj_cache resets the
@@ -2174,40 +1993,30 @@ transcribe_status emit_streaming_chunk(
     if (eb.pos_emb_in != nullptr) {
         const int pos_len_cur = static_cast<int>(eb.pos_emb_in->ne[1]);
         if (pos_len_cur != pc->stream_caches.pos_proj_len) {
-            if (const transcribe_status st =
-                    ensure_pos_proj_cache(pc, pm, pos_len_cur);
-                st != TRANSCRIBE_OK)
-            {
+            if (const transcribe_status st = ensure_pos_proj_cache(pc, pm, pos_len_cur); st != TRANSCRIBE_OK) {
                 log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                    "parakeet stream: pos_proj cache fill failed (%s) — "
-                    "continuing without memoization",
-                    transcribe_status_string(st));
+                        "parakeet stream: pos_proj cache fill failed (%s) — "
+                        "continuing without memoization",
+                        transcribe_status_string(st));
             }
         }
     }
 
     if (dump_on) {
         char namebuf[128];
-        std::snprintf(namebuf, sizeof(namebuf),
-                      "stream.chunk.%d.channel_len", step_num);
-        const float channel_len_f = static_cast<float>(pc->stream_caches.channel_len);
-        const long long len_shape[1] = {1};
-        transcribe::debug::dump_host_f32(
-            namebuf, &channel_len_f, 1, len_shape, 1,
-            "streaming.channel_len");
+        std::snprintf(namebuf, sizeof(namebuf), "stream.chunk.%d.channel_len", step_num);
+        const float     channel_len_f = static_cast<float>(pc->stream_caches.channel_len);
+        const long long len_shape[1]  = { 1 };
+        transcribe::debug::dump_host_f32(namebuf, &channel_len_f, 1, len_shape, 1, "streaming.channel_len");
     }
     pc->stream_caches.chunk_step += 1;
 
     // Run streaming RNN-T decoder on the new encoder frames.
     if (const transcribe_status st = decode_rnnt_greedy_streaming(
-            pm->host_decoder, pc->enc_host.data(),
-            T_q_new, d_enc,
-            pc->stream_dec_state.lstm_state,
-            pc->stream_dec_state.prev_token_id,
-            static_cast<int>(pc->stream_dec_state.frame_offset),
-            pc->n_threads, pc->raw_tokens);
-        st != TRANSCRIBE_OK)
-    {
+            pm->host_decoder, pc->enc_host.data(), T_q_new, d_enc, pc->stream_dec_state.lstm_state,
+            pc->stream_dec_state.prev_token_id, static_cast<int>(pc->stream_dec_state.frame_offset), pc->n_threads,
+            pc->raw_tokens);
+        st != TRANSCRIBE_OK) {
         return st;
     }
 
@@ -2223,9 +2032,7 @@ transcribe_status emit_streaming_chunk(
 // during streaming (deferred to finalize). result_kind is TOKEN whenever
 // tokens are present — each gets real t0/t1 from step_at_emit, the
 // strongest honest answer at this granularity.
-void rebuild_streaming_result_text(ParakeetSession * pc,
-                                   const ParakeetModel * pm)
-{
+void rebuild_streaming_result_text(ParakeetSession * pc, const ParakeetModel * pm) {
     pc->tokens.clear();
     pc->words.clear();
     pc->segments.clear();
@@ -2242,8 +2049,8 @@ void rebuild_streaming_result_text(ParakeetSession * pc,
     // Strip CONTROL / <ll-RR> tag pieces from the public result, mirroring
     // decode_and_populate (gated on keep_special_tags). Only the public
     // projection is filtered; pc->raw_tokens stays whole.
-    const transcribe::Tokenizer & tok = pm->tok;
-    const bool strip_tags = !pc->stream_run_params.keep_special_tags;
+    const transcribe::Tokenizer & tok        = pm->tok;
+    const bool                    strip_tags = !pc->stream_run_params.keep_special_tags;
 
     pc->tokens.reserve(pc->raw_tokens.size());
     std::vector<int32_t> all_ids;
@@ -2253,20 +2060,18 @@ void rebuild_streaming_result_text(ParakeetSession * pc,
             continue;
         }
         transcribe_session::TokenEntry te;
-        te.id           = tk.id;
-        te.p            = tk.p;
-        te.t0_ms        = static_cast<int64_t>(std::llround(
-            frame_to_ms * static_cast<double>(tk.step_at_emit)));
-        te.t1_ms        = static_cast<int64_t>(std::llround(
-            frame_to_ms * static_cast<double>(tk.step_at_emit + tk.duration_frames)));
-        te.seg_index    = 0;
-        te.word_index   = -1;
-        te.text         = tok.decode(&tk.id, 1);
+        te.id    = tk.id;
+        te.p     = tk.p;
+        te.t0_ms = static_cast<int64_t>(std::llround(frame_to_ms * static_cast<double>(tk.step_at_emit)));
+        te.t1_ms =
+            static_cast<int64_t>(std::llround(frame_to_ms * static_cast<double>(tk.step_at_emit + tk.duration_frames)));
+        te.seg_index  = 0;
+        te.word_index = -1;
+        te.text       = tok.decode(&tk.id, 1);
         pc->tokens.push_back(std::move(te));
         all_ids.push_back(tk.id);
     }
-    pc->full_text = tok.decode(all_ids.data(),
-                                 static_cast<int>(all_ids.size()));
+    pc->full_text = tok.decode(all_ids.data(), static_cast<int>(all_ids.size()));
     normalize_transcript_whitespace(pc->full_text);
     pc->has_result  = true;
     pc->result_kind = TRANSCRIBE_TIMESTAMPS_TOKEN;
@@ -2282,98 +2087,87 @@ void rebuild_streaming_result_text(ParakeetSession * pc,
 // builds the graph with a BufferedStreamMaskOverride, then slices off the
 // ctx_left frames and decodes ctx_chunk (or all remaining on last) with a
 // carried RNN-T LstmState.
-static void buf_ctx_add_frames(
-    ParakeetSession * pc, int64_t num_new, bool is_last)
-{
-    pc->buf_ctx_left  += pc->buf_ctx_chunk;
-    pc->buf_ctx_chunk  = 0;
+static void buf_ctx_add_frames(ParakeetSession * pc, int64_t num_new, bool is_last) {
+    pc->buf_ctx_left += pc->buf_ctx_chunk;
+    pc->buf_ctx_chunk = 0;
     pc->buf_ctx_right += num_new;
     if (is_last) {
         pc->buf_ctx_chunk = pc->buf_ctx_right;
         pc->buf_ctx_right = 0;
     } else {
-        pc->buf_ctx_chunk  = pc->buf_samples_chunk;
+        pc->buf_ctx_chunk = pc->buf_samples_chunk;
         pc->buf_ctx_right -= static_cast<int64_t>(pc->buf_samples_chunk);
     }
     const int64_t total_now = pc->buf_ctx_left + pc->buf_ctx_chunk + pc->buf_ctx_right;
-    const int64_t expected  = static_cast<int64_t>(pc->buf_samples_left) +
-                              static_cast<int64_t>(pc->buf_samples_chunk) +
+    const int64_t expected  = static_cast<int64_t>(pc->buf_samples_left) + static_cast<int64_t>(pc->buf_samples_chunk) +
                               static_cast<int64_t>(pc->buf_samples_right);
-    const int64_t extra = std::max<int64_t>(total_now - expected, 0);
+    const int64_t extra     = std::max<int64_t>(total_now - expected, 0);
     pc->buf_ctx_left -= extra;
 }
 
-transcribe_status emit_buffered_chunk(
-    ParakeetSession * pc,
-    ParakeetModel *   pm,
-    int64_t           num_new_samples,
-    bool              is_last_chunk)
-{
-    if (pc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
+transcribe_status emit_buffered_chunk(ParakeetSession * pc,
+                                      ParakeetModel *   pm,
+                                      int64_t           num_new_samples,
+                                      bool              is_last_chunk) {
+    if (pc->poll_abort()) {
+        return TRANSCRIBE_ERR_ABORTED;
+    }
 
     const auto & hp = pm->hparams;
     if (!pm->mel.has_value()) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "parakeet buffered: model has no MelFrontend");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "parakeet buffered: model has no MelFrontend");
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
 
-    const int samples_per_frame =
-        hp.enc_subsampling_factor * hp.fe_hop_length;
-    if (samples_per_frame <= 0) return TRANSCRIBE_ERR_INVALID_ARG;
+    const int samples_per_frame = hp.enc_subsampling_factor * hp.fe_hop_length;
+    if (samples_per_frame <= 0) {
+        return TRANSCRIBE_ERR_INVALID_ARG;
+    }
 
     // ----- Update buffer ContextSize (mirrors NeMo's add_frames_get_removed_) -----
     buf_ctx_add_frames(pc, num_new_samples, is_last_chunk);
 
     // ----- Build the [left | chunk | right] PCM window from absolute coords -----
-    const int64_t end_abs   = pc->buf_next_audio_read + num_new_samples;
-    const int64_t total_now =
-        pc->buf_ctx_left + pc->buf_ctx_chunk + pc->buf_ctx_right;
-    const int effective_T = static_cast<int>(total_now / samples_per_frame);
-    const int64_t start_abs = end_abs - total_now;
-
-    std::vector<float> window_pcm(
-        static_cast<size_t>(total_now), 0.0f);
-    const int64_t buf_size =
-        static_cast<int64_t>(pc->stream_pcm_buffer.size());
+    const int64_t end_abs     = pc->buf_next_audio_read + num_new_samples;
+    const int64_t total_now   = pc->buf_ctx_left + pc->buf_ctx_chunk + pc->buf_ctx_right;
+    const int     effective_T = static_cast<int>(total_now / samples_per_frame);
+    const int64_t start_abs   = end_abs - total_now;
+
+    std::vector<float> window_pcm(static_cast<size_t>(total_now), 0.0f);
+    const int64_t      buf_size = static_cast<int64_t>(pc->stream_pcm_buffer.size());
     for (int64_t i = 0; i < total_now; ++i) {
         const int64_t src = start_abs + i;
         if (src >= 0 && src < buf_size) {
-            window_pcm[static_cast<size_t>(i)] =
-                pc->stream_pcm_buffer[static_cast<size_t>(src)];
+            window_pcm[static_cast<size_t>(i)] = pc->stream_pcm_buffer[static_cast<size_t>(src)];
         }
     }
 
     // Push a `stream.chunk.<N>.` dump prefix so per-chunk block outputs
     // don't overwrite across chunks; popped at function exit.
     const int chunk_step = pc->buf_chunk_step;
-    char chunk_prefix[64];
-    std::snprintf(chunk_prefix, sizeof(chunk_prefix),
-                  "stream.chunk.%d.", chunk_step);
+    char      chunk_prefix[64];
+    std::snprintf(chunk_prefix, sizeof(chunk_prefix), "stream.chunk.%d.", chunk_step);
     transcribe::debug::push_name_prefix(chunk_prefix);
+
     struct PrefixPopGuard {
         ~PrefixPopGuard() { transcribe::debug::pop_name_prefix(); }
     } _prefix_pop_guard;
+
     if (transcribe::debug::enabled()) {
         const long long shape[1] = { static_cast<long long>(window_pcm.size()) };
-        transcribe::debug::dump_host_f32(
-            "audio_in", window_pcm.data(),
-            static_cast<long long>(window_pcm.size()),
-            shape, 1, "buffered_streaming.audio_in");
+        transcribe::debug::dump_host_f32("audio_in", window_pcm.data(), static_cast<long long>(window_pcm.size()),
+                                         shape, 1, "buffered_streaming.audio_in");
     }
 
     // ----- Mel -----
-    const int64_t t_mel_start = ggml_time_us();
-    int mel_n_mels   = 0;
-    int mel_n_frames = 0;
-    if (const transcribe_status mst = pm->mel->compute(
-            window_pcm.data(), window_pcm.size(),
-            pc->mel_buf, mel_n_mels, mel_n_frames);
-        mst != TRANSCRIBE_OK)
-    {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "parakeet buffered: MelFrontend::compute failed (%s)",
-                     transcribe_status_string(mst));
+    const int64_t t_mel_start  = ggml_time_us();
+    int           mel_n_mels   = 0;
+    int           mel_n_frames = 0;
+    if (const transcribe_status mst =
+            pm->mel->compute(window_pcm.data(), window_pcm.size(), pc->mel_buf, mel_n_mels, mel_n_frames);
+        mst != TRANSCRIBE_OK) {
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "parakeet buffered: MelFrontend::compute failed (%s)",
+                transcribe_status_string(mst));
         return mst;
     }
     pc->t_mel_us += ggml_time_us() - t_mel_start;
@@ -2385,96 +2179,89 @@ transcribe_status emit_buffered_chunk(
     }
     pc->encoder_out = nullptr;
     {
-        ggml_init_params init_params {};
+        ggml_init_params init_params{};
         init_params.mem_size   = 4 * 1024 * 1024;
         init_params.mem_buffer = nullptr;
         init_params.no_alloc   = true;
-        pc->compute_ctx = ggml_init(init_params);
+        pc->compute_ctx        = ggml_init(init_params);
         if (pc->compute_ctx == nullptr) {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "parakeet buffered: ggml_init for compute_ctx failed");
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "parakeet buffered: ggml_init for compute_ctx failed");
             return TRANSCRIBE_ERR_GGUF;
         }
     }
 
     ggml_type resolved_kv = GGML_TYPE_COUNT;
-    if (pc->kv_type == TRANSCRIBE_KV_TYPE_F32) resolved_kv = GGML_TYPE_F32;
-    if (pc->kv_type == TRANSCRIBE_KV_TYPE_F16) resolved_kv = GGML_TYPE_F16;
+    if (pc->kv_type == TRANSCRIBE_KV_TYPE_F32) {
+        resolved_kv = GGML_TYPE_F32;
+    }
+    if (pc->kv_type == TRANSCRIBE_KV_TYPE_F16) {
+        resolved_kv = GGML_TYPE_F16;
+    }
 
-    BufferedStreamMaskOverride buf_mask {};
+    BufferedStreamMaskOverride buf_mask{};
     buf_mask.left_frames  = pc->buf_left_frames;
     buf_mask.chunk_frames = pc->buf_chunk_frames;
     buf_mask.right_frames = pc->buf_right_frames;
     buf_mask.valid_frames = effective_T;
 
-    EncoderBuild eb = build_encoder_graph(
-        pc->compute_ctx, pm->weights, pm->hparams, mel_n_frames,
-        resolved_kv, pm->backend.c_str(), &buf_mask);
+    EncoderBuild eb = build_encoder_graph(pc->compute_ctx, pm->weights, pm->hparams, mel_n_frames, resolved_kv,
+                                          pm->backend.c_str(), &buf_mask);
     if (eb.mel_in == nullptr || eb.out == nullptr || eb.graph == nullptr) {
         return TRANSCRIBE_ERR_GGUF;
     }
 
     // ----- Scheduler alloc + mel upload -----
     if (pc->sched == nullptr) {
-        pc->sched = ggml_backend_sched_new(
-            pm->plan.scheduler_list.data(), nullptr,
-            static_cast<int>(pm->plan.scheduler_list.size()),
-            /*graph_size=*/8192, /*parallel=*/false, /*op_offload=*/true);
-        if (pc->sched == nullptr) return TRANSCRIBE_ERR_GGUF;
+        pc->sched = ggml_backend_sched_new(pm->plan.scheduler_list.data(), nullptr,
+                                           static_cast<int>(pm->plan.scheduler_list.size()),
+                                           /*graph_size=*/8192, /*parallel=*/false, /*op_offload=*/true);
+        if (pc->sched == nullptr) {
+            return TRANSCRIBE_ERR_GGUF;
+        }
     }
     ggml_backend_sched_reset(pc->sched);
     if (!ggml_backend_sched_alloc_graph(pc->sched, eb.graph)) {
         return TRANSCRIBE_ERR_GGUF;
     }
-    ggml_backend_tensor_set(eb.mel_in, pc->mel_buf.data(),
-                            0, pc->mel_buf.size() * sizeof(float));
+    ggml_backend_tensor_set(eb.mel_in, pc->mel_buf.data(), 0, pc->mel_buf.size() * sizeof(float));
 
     // ----- Pos_emb fill (full 2T-1 layout; matches offline ChunkedLimited path) -----
     if (eb.pos_emb_in != nullptr) {
-        const int d_model = hp.enc_d_model;
-        const int pos_len = static_cast<int>(eb.pos_emb_in->ne[1]);
+        const int d_model    = hp.enc_d_model;
+        const int pos_len    = static_cast<int>(eb.pos_emb_in->ne[1]);
         const int zero_index = (pos_len - 1) / 2;
 
-        pc->pos_buf.assign(
-            static_cast<size_t>(pos_len) * d_model, 0.0f);
+        pc->pos_buf.assign(static_cast<size_t>(pos_len) * d_model, 0.0f);
         pc->pos_div_term.resize(static_cast<size_t>(d_model / 2));
         const float ln_10000 = std::log(10000.0f);
         for (int k = 0; k < d_model / 2; ++k) {
             pc->pos_div_term[static_cast<size_t>(k)] =
-                std::exp(static_cast<float>(2 * k) *
-                         (-ln_10000 / static_cast<float>(d_model)));
+                std::exp(static_cast<float>(2 * k) * (-ln_10000 / static_cast<float>(d_model)));
         }
         for (int i = 0; i < pos_len; ++i) {
             const float pos = static_cast<float>(zero_index - i);
-            float * row = pc->pos_buf.data() +
-                static_cast<size_t>(i) * d_model;
+            float *     row = pc->pos_buf.data() + static_cast<size_t>(i) * d_model;
             for (int k = 0; k < d_model / 2; ++k) {
                 const float div = pc->pos_div_term[static_cast<size_t>(k)];
-                row[2 * k]     = std::sin(pos * div);
-                row[2 * k + 1] = std::cos(pos * div);
+                row[2 * k]      = std::sin(pos * div);
+                row[2 * k + 1]  = std::cos(pos * div);
             }
         }
-        ggml_backend_tensor_set(eb.pos_emb_in, pc->pos_buf.data(),
-                                0, pc->pos_buf.size() * sizeof(float));
+        ggml_backend_tensor_set(eb.pos_emb_in, pc->pos_buf.data(), 0, pc->pos_buf.size() * sizeof(float));
     }
 
     // Conv pad mask: zeros post-GLU activations on pre_encode overhang
     // frames so they don't leak backward through the depthwise conv's
     // right context (the attention mask already excludes them from MHA).
     if (eb.conv_pad_mask_in != nullptr) {
-        const int T_enc =
-            static_cast<int>(eb.conv_pad_mask_in->ne[0]);
-        const int P = std::max(0, std::min(effective_T, T_enc));
+        const int          T_enc = static_cast<int>(eb.conv_pad_mask_in->ne[0]);
+        const int          P     = std::max(0, std::min(effective_T, T_enc));
         std::vector<float> mask_buf(static_cast<size_t>(T_enc), 1.0f);
         for (int t = P; t < T_enc; ++t) {
             mask_buf[static_cast<size_t>(t)] = 0.0f;
         }
-        ggml_backend_tensor_set(eb.conv_pad_mask_in, mask_buf.data(),
-                                0, mask_buf.size() * sizeof(float));
-        transcribe::debug::dump_tensor(
-            "enc.conv.pad_mask",
-            eb.conv_pad_mask_in,
-            "encoder.conv.pad_mask");
+        ggml_backend_tensor_set(eb.conv_pad_mask_in, mask_buf.data(), 0, mask_buf.size() * sizeof(float));
+        transcribe::debug::dump_tensor("enc.conv.pad_mask", eb.conv_pad_mask_in, "encoder.conv.pad_mask");
     }
 
     // Chunked_limited_with_rc mask. effective_T folds in NeMo's
@@ -2483,18 +2270,11 @@ transcribe_status emit_buffered_chunk(
     // otherwise contaminate every frame's attention scores (critical at
     // low-C/low-R).
     if (eb.chunked_mask_in != nullptr) {
-        const int T_enc =
-            static_cast<int>(eb.chunked_mask_in->ne[0]);
-        std::vector<float> mask_buf(
-            static_cast<size_t>(T_enc) * static_cast<size_t>(T_enc));
-        compute_chunked_limited_with_rc_mask(
-            mask_buf.data(), T_enc,
-            pc->buf_left_frames,
-            pc->buf_chunk_frames,
-            pc->buf_right_frames,
-            effective_T);
-        ggml_backend_tensor_set(eb.chunked_mask_in, mask_buf.data(),
-                                0, mask_buf.size() * sizeof(float));
+        const int          T_enc = static_cast<int>(eb.chunked_mask_in->ne[0]);
+        std::vector<float> mask_buf(static_cast<size_t>(T_enc) * static_cast<size_t>(T_enc));
+        compute_chunked_limited_with_rc_mask(mask_buf.data(), T_enc, pc->buf_left_frames, pc->buf_chunk_frames,
+                                             pc->buf_right_frames, effective_T);
+        ggml_backend_tensor_set(eb.chunked_mask_in, mask_buf.data(), 0, mask_buf.size() * sizeof(float));
     }
 
     // ----- Threading -----
@@ -2502,13 +2282,8 @@ transcribe_status emit_buffered_chunk(
 
     // ----- Compute -----
     const int64_t t_enc_start = ggml_time_us();
-    if (const ggml_status gs =
-            ggml_backend_sched_graph_compute(pc->sched, eb.graph);
-        gs != GGML_STATUS_SUCCESS)
-    {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "parakeet buffered: sched_graph_compute failed (%d)",
-                     static_cast<int>(gs));
+    if (const ggml_status gs = ggml_backend_sched_graph_compute(pc->sched, eb.graph); gs != GGML_STATUS_SUCCESS) {
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "parakeet buffered: sched_graph_compute failed (%d)", static_cast<int>(gs));
         return TRANSCRIBE_ERR_GGUF;
     }
     pc->t_encode_us += ggml_time_us() - t_enc_start;
@@ -2523,38 +2298,36 @@ transcribe_status emit_buffered_chunk(
     // Same set as the offline run() path, scoped by the active per-chunk
     // name prefix.
     if (transcribe::debug::enabled()) {
-        auto try_dump = [](const char * name, ggml_tensor * t,
-                           const char * stage) {
-            if (t != nullptr) transcribe::debug::dump_tensor(name, t, stage);
+        auto try_dump = [](const char * name, ggml_tensor * t, const char * stage) {
+            if (t != nullptr) {
+                transcribe::debug::dump_tensor(name, t, stage);
+            }
         };
-        try_dump("enc.pre_encode.out",   eb.dumps.pre_encode_out,    "encoder.pre_encode");
-        try_dump("enc.block.0.ff1",      eb.dumps.block0_after_ff1,  "encoder.block0.ff1");
-        try_dump("enc.block.0.attn",     eb.dumps.block0_after_attn, "encoder.block0.attn");
-        try_dump("enc.block.0.conv",     eb.dumps.block0_after_conv, "encoder.block0.conv");
-        try_dump("enc.block.0.ff2",      eb.dumps.block0_after_ff2,  "encoder.block0.ff2");
-        try_dump("enc.block.0.out",      eb.dumps.block0_out,        "encoder.block0.out");
+        try_dump("enc.pre_encode.out", eb.dumps.pre_encode_out, "encoder.pre_encode");
+        try_dump("enc.block.0.ff1", eb.dumps.block0_after_ff1, "encoder.block0.ff1");
+        try_dump("enc.block.0.attn", eb.dumps.block0_after_attn, "encoder.block0.attn");
+        try_dump("enc.block.0.conv", eb.dumps.block0_after_conv, "encoder.block0.conv");
+        try_dump("enc.block.0.ff2", eb.dumps.block0_after_ff2, "encoder.block0.ff2");
+        try_dump("enc.block.0.out", eb.dumps.block0_out, "encoder.block0.out");
         if (eb.dumps.mid_block_out != nullptr && eb.dumps.mid_block_idx >= 0) {
             char name[64];
-            std::snprintf(name, sizeof(name), "enc.block.%d.out",
-                          eb.dumps.mid_block_idx);
-            transcribe::debug::dump_tensor(name, eb.dumps.mid_block_out,
-                                           "encoder.block.mid.out");
+            std::snprintf(name, sizeof(name), "enc.block.%d.out", eb.dumps.mid_block_idx);
+            transcribe::debug::dump_tensor(name, eb.dumps.mid_block_out, "encoder.block.mid.out");
         }
         if (eb.dumps.last_block_out != nullptr && eb.dumps.last_block_idx >= 0) {
             char name[64];
-            std::snprintf(name, sizeof(name), "enc.block.%d.out",
-                          eb.dumps.last_block_idx);
-            transcribe::debug::dump_tensor(name, eb.dumps.last_block_out,
-                                           "encoder.block.last.out");
+            std::snprintf(name, sizeof(name), "enc.block.%d.out", eb.dumps.last_block_idx);
+            transcribe::debug::dump_tensor(name, eb.dumps.last_block_out, "encoder.block.last.out");
         }
         if (transcribe::debug::dump_all_blocks_requested()) {
             for (size_t i = 0; i < eb.dumps.all_block_outs.size(); ++i) {
                 ggml_tensor * t = eb.dumps.all_block_outs[i];
-                if (t == nullptr) continue;
+                if (t == nullptr) {
+                    continue;
+                }
                 char name[64];
                 std::snprintf(name, sizeof(name), "enc.block.%zu.out", i);
-                transcribe::debug::dump_tensor(name, t,
-                                               "encoder.block.bisect");
+                transcribe::debug::dump_tensor(name, t, "encoder.block.bisect");
             }
         }
     }
@@ -2563,30 +2336,23 @@ transcribe_status emit_buffered_chunk(
     const int d_enc      = static_cast<int>(eb.out->ne[0]);
     const int T_enc_full = static_cast<int>(eb.out->ne[1]);
     if (T_enc_full <= 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "parakeet buffered: encoder produced %d frames",
-                     T_enc_full);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "parakeet buffered: encoder produced %d frames", T_enc_full);
         return TRANSCRIBE_ERR_GGUF;
     }
-    pc->enc_host.resize(static_cast<size_t>(d_enc) *
-                        static_cast<size_t>(T_enc_full));
-    ggml_backend_tensor_get(eb.out, pc->enc_host.data(), 0,
-                            pc->enc_host.size() * sizeof(float));
+    pc->enc_host.resize(static_cast<size_t>(d_enc) * static_cast<size_t>(T_enc_full));
+    ggml_backend_tensor_get(eb.out, pc->enc_host.data(), 0, pc->enc_host.size() * sizeof(float));
 
-    transcribe::debug::dump_tensor(
-        "enc.final", eb.out, "encoder.final");
+    transcribe::debug::dump_tensor("enc.final", eb.out, "encoder.final");
 
     // Subsample session into encoder frames — mirrors NeMo's
     // buffer.context_size.subsample(factor=encoder_frame2audio_samples).
-    const int ctx_left_frames  = static_cast<int>(
-        pc->buf_ctx_left  / samples_per_frame);
-    const int ctx_chunk_frames = static_cast<int>(
-        pc->buf_ctx_chunk / samples_per_frame);
+    const int ctx_left_frames  = static_cast<int>(pc->buf_ctx_left / samples_per_frame);
+    const int ctx_chunk_frames = static_cast<int>(pc->buf_ctx_chunk / samples_per_frame);
 
     auto advance_cursor = [&]() {
         pc->buf_next_audio_read += num_new_samples;
-        pc->buf_chunk_step      += 1;
-        pc->buf_initialized      = true;
+        pc->buf_chunk_step += 1;
+        pc->buf_initialized = true;
     };
 
     if (T_enc_full <= ctx_left_frames) {
@@ -2599,16 +2365,13 @@ transcribe_status emit_buffered_chunk(
     //   non-final:   encoder_context_batch.chunk
     //   final:       encoder_output_len - encoder_context_batch.left
     const int T_chunk_avail = T_enc_full - ctx_left_frames;
-    const int T_to_decode = is_last_chunk
-        ? T_chunk_avail
-        : std::min(ctx_chunk_frames, T_chunk_avail);
+    const int T_to_decode   = is_last_chunk ? T_chunk_avail : std::min(ctx_chunk_frames, T_chunk_avail);
     if (T_to_decode <= 0) {
         advance_cursor();
         return TRANSCRIBE_OK;
     }
 
-    const float * enc_chunk = pc->enc_host.data() +
-        static_cast<size_t>(ctx_left_frames) * static_cast<size_t>(d_enc);
+    const float * enc_chunk = pc->enc_host.data() + static_cast<size_t>(ctx_left_frames) * static_cast<size_t>(d_enc);
 
     // Per-chunk encoder output dump: the FULL post-slice output (chunk +
     // right context), not just the T_to_decode frames, so the parity
@@ -2618,23 +2381,18 @@ transcribe_status emit_buffered_chunk(
             static_cast<long long>(T_chunk_avail),
             static_cast<long long>(d_enc),
         };
-        transcribe::debug::dump_host_f32(
-            "enc_out", enc_chunk,
-            static_cast<long long>(T_chunk_avail) *
-                static_cast<long long>(d_enc),
-            shape, 2, "buffered_streaming.enc_out");
+        transcribe::debug::dump_host_f32("enc_out", enc_chunk,
+                                         static_cast<long long>(T_chunk_avail) * static_cast<long long>(d_enc), shape,
+                                         2, "buffered_streaming.enc_out");
     }
 
     // ----- Decode with carried RNN-T state -----
     const int64_t t_dec_start = ggml_time_us();
     if (const transcribe_status st = decode_rnnt_greedy_streaming(
-            pm->host_decoder, enc_chunk, T_to_decode, d_enc,
-            pc->stream_dec_state.lstm_state,
-            pc->stream_dec_state.prev_token_id,
-            static_cast<int>(pc->stream_dec_state.frame_offset),
-            pc->n_threads, pc->raw_tokens);
-        st != TRANSCRIBE_OK)
-    {
+            pm->host_decoder, enc_chunk, T_to_decode, d_enc, pc->stream_dec_state.lstm_state,
+            pc->stream_dec_state.prev_token_id, static_cast<int>(pc->stream_dec_state.frame_offset), pc->n_threads,
+            pc->raw_tokens);
+        st != TRANSCRIBE_OK) {
         return st;
     }
     pc->t_decode_us += ggml_time_us() - t_dec_start;
@@ -2647,87 +2405,100 @@ transcribe_status emit_buffered_chunk(
 // Pure validation of the buffered-stream extension: resolves (L, C, R)
 // to encoder frames. Does NOT touch pc->buf_*; out pointers written only
 // on TRANSCRIBE_OK.
-transcribe_status resolve_buffered_stream_geom(
-    const ParakeetModel *             pm,
-    const transcribe_stream_params *  stream_params,
-    int *                             out_L_frames,
-    int *                             out_C_frames,
-    int *                             out_R_frames)
-{
-    const int frame_ms =
-        (pm->hparams.enc_subsampling_factor * pm->hparams.fe_hop_length * 1000) /
-        std::max(pm->hparams.fe_sample_rate, 1);
+transcribe_status resolve_buffered_stream_geom(const ParakeetModel *            pm,
+                                               const transcribe_stream_params * stream_params,
+                                               int *                            out_L_frames,
+                                               int *                            out_C_frames,
+                                               int *                            out_R_frames) {
+    const int frame_ms = (pm->hparams.enc_subsampling_factor * pm->hparams.fe_hop_length * 1000) /
+                         std::max(pm->hparams.fe_sample_rate, 1);
 
     auto max_in = [](const std::vector<int32_t> & v) -> int32_t {
         int32_t best = 0;
-        for (auto x : v) if (x > best) best = x;
+        for (auto x : v) {
+            if (x > best) {
+                best = x;
+            }
+        }
         return best;
     };
     const int default_L = static_cast<int>(max_in(pm->hparams.enc_att_chunk_left_choices));
     const int default_C = static_cast<int>(max_in(pm->hparams.enc_att_chunk_chunk_choices));
     const int default_R = static_cast<int>(max_in(pm->hparams.enc_att_chunk_right_choices));
 
-    int req_L_ms = -1, req_C_ms = -1, req_R_ms = -1;
+    int                    req_L_ms = -1, req_C_ms = -1, req_R_ms = -1;
     const transcribe_ext * family = stream_params != nullptr ? stream_params->family : nullptr;
-    if (const transcribe_status st = transcribe_ext_check(
-            family,
-            TRANSCRIBE_EXT_KIND_PARAKEET_BUFFERED_STREAM,
-            sizeof(struct transcribe_parakeet_buffered_stream_ext));
-        st != TRANSCRIBE_OK)
-    {
+    if (const transcribe_status st = transcribe_ext_check(family, TRANSCRIBE_EXT_KIND_PARAKEET_BUFFERED_STREAM,
+                                                          sizeof(struct transcribe_parakeet_buffered_stream_ext));
+        st != TRANSCRIBE_OK) {
         return st;
     }
     if (family != nullptr) {
         const auto * px = reinterpret_cast<const transcribe_parakeet_buffered_stream_ext *>(family);
-        req_L_ms = px->left_ms;
-        req_C_ms = px->chunk_ms;
-        req_R_ms = px->right_ms;
-    }
-    const int safe_frame_ms = std::max(frame_ms, 1);
-    auto ms_to_exact_frames = [&](int req_ms, int default_frames,
-                                  int * out_frames) -> bool {
-        if (req_ms == -1) { *out_frames = default_frames; return true; }
-        if (req_ms <  -1) return false;
-        if (req_ms % safe_frame_ms != 0) return false;
+        req_L_ms        = px->left_ms;
+        req_C_ms        = px->chunk_ms;
+        req_R_ms        = px->right_ms;
+    }
+    const int safe_frame_ms      = std::max(frame_ms, 1);
+    auto      ms_to_exact_frames = [&](int req_ms, int default_frames, int * out_frames) -> bool {
+        if (req_ms == -1) {
+            *out_frames = default_frames;
+            return true;
+        }
+        if (req_ms < -1) {
+            return false;
+        }
+        if (req_ms % safe_frame_ms != 0) {
+            return false;
+        }
         *out_frames = req_ms / safe_frame_ms;
         return true;
     };
     int L_frames = 0, C_frames = 0, R_frames = 0;
-    if (!ms_to_exact_frames(req_L_ms, default_L, &L_frames) ||
-        !ms_to_exact_frames(req_C_ms, default_C, &C_frames) ||
-        !ms_to_exact_frames(req_R_ms, default_R, &R_frames))
-    {
+    if (!ms_to_exact_frames(req_L_ms, default_L, &L_frames) || !ms_to_exact_frames(req_C_ms, default_C, &C_frames) ||
+        !ms_to_exact_frames(req_R_ms, default_R, &R_frames)) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "parakeet buffered: requested (L, C, R)_ms = "
-                     "(%d, %d, %d) is invalid. Use -1 on any field to "
-                     "select the model default; otherwise the value "
-                     "must be 0 or a positive exact multiple of the "
-                     "%d ms encoder frame.",
-                     req_L_ms, req_C_ms, req_R_ms, safe_frame_ms);
+                "parakeet buffered: requested (L, C, R)_ms = "
+                "(%d, %d, %d) is invalid. Use -1 on any field to "
+                "select the model default; otherwise the value "
+                "must be 0 or a positive exact multiple of the "
+                "%d ms encoder frame.",
+                req_L_ms, req_C_ms, req_R_ms, safe_frame_ms);
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
 
     auto contains = [](const std::vector<int32_t> & v, int x) -> bool {
-        for (auto y : v) if (y == x) return true;
+        for (auto y : v) {
+            if (y == x) {
+                return true;
+            }
+        }
         return false;
     };
     if (!contains(pm->hparams.enc_att_chunk_left_choices, L_frames) ||
         !contains(pm->hparams.enc_att_chunk_chunk_choices, C_frames) ||
-        !contains(pm->hparams.enc_att_chunk_right_choices, R_frames))
-    {
+        !contains(pm->hparams.enc_att_chunk_right_choices, R_frames)) {
         std::string allowed = "L=";
-        for (auto v : pm->hparams.enc_att_chunk_left_choices)  allowed += std::to_string(v) + ",";
+        for (auto v : pm->hparams.enc_att_chunk_left_choices) {
+            allowed += std::to_string(v) + ",";
+        }
         allowed += " C=";
-        for (auto v : pm->hparams.enc_att_chunk_chunk_choices) allowed += std::to_string(v) + ",";
+        for (auto v : pm->hparams.enc_att_chunk_chunk_choices) {
+            allowed += std::to_string(v) + ",";
+        }
         allowed += " R=";
-        for (auto v : pm->hparams.enc_att_chunk_right_choices) allowed += std::to_string(v) + ",";
+        for (auto v : pm->hparams.enc_att_chunk_right_choices) {
+            allowed += std::to_string(v) + ",";
+        }
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
                 "parakeet buffered: requested (L, C, R) = (%d, %d, %d) "
                 "encoder frames not in model menu. Allowed %s",
                 L_frames, C_frames, R_frames, allowed.c_str());
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
-    if (C_frames < 1) return TRANSCRIBE_ERR_INVALID_ARG;
+    if (C_frames < 1) {
+        return TRANSCRIBE_ERR_INVALID_ARG;
+    }
 
     *out_L_frames = L_frames;
     *out_C_frames = C_frames;
@@ -2738,33 +2509,28 @@ transcribe_status resolve_buffered_stream_geom(
 // Pure validation of the cache-aware-stream extension: resolves the
 // active (att_context_left, att_context_right) from the training menu.
 // Does NOT touch pc->*; out pointers written only on TRANSCRIBE_OK.
-transcribe_status resolve_cache_aware_stream_geom(
-    const ParakeetModel *             pm,
-    const transcribe_stream_params *  stream_params,
-    int *                             out_chosen_left,
-    int *                             out_chosen_right)
-{
+transcribe_status resolve_cache_aware_stream_geom(const ParakeetModel *            pm,
+                                                  const transcribe_stream_params * stream_params,
+                                                  int *                            out_chosen_left,
+                                                  int *                            out_chosen_right) {
     int chosen_right = pm->hparams.enc_att_context_right;
     int chosen_left  = pm->hparams.enc_att_context_left;
 
     const transcribe_ext * family = stream_params != nullptr ? stream_params->family : nullptr;
-    if (const transcribe_status st = transcribe_ext_check(
-            family,
-            TRANSCRIBE_EXT_KIND_PARAKEET_STREAM,
-            sizeof(struct transcribe_parakeet_stream_ext));
-        st != TRANSCRIBE_OK)
-    {
+    if (const transcribe_status st = transcribe_ext_check(family, TRANSCRIBE_EXT_KIND_PARAKEET_STREAM,
+                                                          sizeof(struct transcribe_parakeet_stream_ext));
+        st != TRANSCRIBE_OK) {
         return st;
     }
     if (family != nullptr) {
-        const auto * px = reinterpret_cast<const transcribe_parakeet_stream_ext *>(family);
-        const int requested = px->att_context_right;
+        const auto * px        = reinterpret_cast<const transcribe_parakeet_stream_ext *>(family);
+        const int    requested = px->att_context_right;
         if (requested < -1) {
             log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "parakeet: att_context_right=%d is invalid; "
-                         "use -1 for the model default or >=0 to pick "
-                         "an entry from the model's training menu",
-                         requested);
+                    "parakeet: att_context_right=%d is invalid; "
+                    "use -1 for the model default or >=0 to pick "
+                    "an entry from the model's training menu",
+                    requested);
             return TRANSCRIBE_ERR_INVALID_ARG;
         }
         if (requested >= 0) {
@@ -2773,7 +2539,7 @@ transcribe_status resolve_cache_aware_stream_geom(
                 if (p.second == requested) {
                     chosen_right = p.second;
                     chosen_left  = p.first;
-                    matched = true;
+                    matched      = true;
                     break;
                 }
             }
@@ -2799,11 +2565,9 @@ transcribe_status resolve_cache_aware_stream_geom(
 // Pre-flight: validate caller extension fields without mutating state.
 // Called by the dispatcher before clear_result, so a rejection leaves the
 // previous snapshot intact. stream_begin re-runs the same resolvers.
-transcribe_status stream_validate(
-    const transcribe_session *        session,
-    const transcribe_run_params *     /*run_params*/,
-    const transcribe_stream_params *  stream_params)
-{
+transcribe_status stream_validate(const transcribe_session * session,
+                                  const transcribe_run_params * /*run_params*/,
+                                  const transcribe_stream_params * stream_params) {
     const auto * pc = static_cast<const ParakeetSession *>(session);
     const auto * pm = static_cast<const ParakeetModel *>(pc->model);
     if (pm == nullptr || pm->plan.scheduler_list.empty()) {
@@ -2811,11 +2575,9 @@ transcribe_status stream_validate(
     }
 
     const bool is_chunked_limited =
-        (pm->hparams.enc_att_context_style ==
-             ParakeetHParams::AttContextStyle::ChunkedLimited);
+        (pm->hparams.enc_att_context_style == ParakeetHParams::AttContextStyle::ChunkedLimited);
     const bool is_chunked_with_rc =
-        (pm->hparams.enc_att_context_style ==
-             ParakeetHParams::AttContextStyle::ChunkedLimitedWithRc);
+        (pm->hparams.enc_att_context_style == ParakeetHParams::AttContextStyle::ChunkedLimitedWithRc);
     if (!is_chunked_limited && !is_chunked_with_rc) {
         return TRANSCRIBE_ERR_NOT_IMPLEMENTED;
     }
@@ -2829,11 +2591,9 @@ transcribe_status stream_validate(
     return resolve_cache_aware_stream_geom(pm, stream_params, &left, &right);
 }
 
-transcribe_status stream_begin(
-    transcribe_session *              session,
-    const transcribe_run_params *         run_params,
-    const transcribe_stream_params *  stream_params)
-{
+transcribe_status stream_begin(transcribe_session *             session,
+                               const transcribe_run_params *    run_params,
+                               const transcribe_stream_params * stream_params) {
     auto * pc = static_cast<ParakeetSession *>(session);
     auto * pm = static_cast<ParakeetModel *>(pc->model);
     if (pm == nullptr || pm->plan.scheduler_list.empty()) {
@@ -2845,11 +2605,9 @@ transcribe_status stream_begin(
 
     // Defense in depth (the dispatcher already gates on supports_streaming).
     const bool is_chunked_limited =
-        (pm->hparams.enc_att_context_style ==
-             ParakeetHParams::AttContextStyle::ChunkedLimited);
+        (pm->hparams.enc_att_context_style == ParakeetHParams::AttContextStyle::ChunkedLimited);
     const bool is_chunked_with_rc =
-        (pm->hparams.enc_att_context_style ==
-             ParakeetHParams::AttContextStyle::ChunkedLimitedWithRc);
+        (pm->hparams.enc_att_context_style == ParakeetHParams::AttContextStyle::ChunkedLimitedWithRc);
     if (!is_chunked_limited && !is_chunked_with_rc) {
         return TRANSCRIBE_ERR_NOT_IMPLEMENTED;
     }
@@ -2864,10 +2622,9 @@ transcribe_status stream_begin(
         // Resolve (L, C, R) in encoder frames (defense in depth; also
         // produces the parsed values we configure state from).
         int L_frames = 0, C_frames = 0, R_frames = 0;
-        if (const transcribe_status st = resolve_buffered_stream_geom(
-                pm, stream_params, &L_frames, &C_frames, &R_frames);
-            st != TRANSCRIBE_OK)
-        {
+        if (const transcribe_status st =
+                resolve_buffered_stream_geom(pm, stream_params, &L_frames, &C_frames, &R_frames);
+            st != TRANSCRIBE_OK) {
             return st;
         }
 
@@ -2905,10 +2662,8 @@ transcribe_status stream_begin(
     // Resolve the active (att_context_left, att_context_right) (defense in
     // depth; also extracts the values we configure the caches from).
     int chosen_left = 0, chosen_right = 0;
-    if (const transcribe_status st = resolve_cache_aware_stream_geom(
-            pm, stream_params, &chosen_left, &chosen_right);
-        st != TRANSCRIBE_OK)
-    {
+    if (const transcribe_status st = resolve_cache_aware_stream_geom(pm, stream_params, &chosen_left, &chosen_right);
+        st != TRANSCRIBE_OK) {
         return st;
     }
 
@@ -2920,9 +2675,7 @@ transcribe_status stream_begin(
 
     // Allocate streaming caches on first stream_begin (idempotent); zero
     // contents and reset cursors on every begin.
-    if (const transcribe_status st = init_streaming_caches(pc, pm);
-        st != TRANSCRIBE_OK)
-    {
+    if (const transcribe_status st = init_streaming_caches(pc, pm); st != TRANSCRIBE_OK) {
         return st;
     }
     zero_streaming_caches(pc);
@@ -2938,15 +2691,14 @@ transcribe_status stream_begin(
     // Fallbacks below cover legacy GGUFs lacking the streaming.* KVs
     // (sampling_frames_first defaults to subsampling_factor, collapsing
     // chunk_size_first == chunk_size_subsequent — no first-chunk case).
-    const int subsampling_factor = pm->hparams.enc_subsampling_factor;
-    int pre_encode_cache_size = pm->hparams.enc_stream_pre_encode_cache_size;
+    const int subsampling_factor    = pm->hparams.enc_subsampling_factor;
+    int       pre_encode_cache_size = pm->hparams.enc_stream_pre_encode_cache_size;
     if (pre_encode_cache_size <= 0) {
         pre_encode_cache_size = subsampling_factor + 1;
     }
     int drop_extra_subsequent = pm->hparams.enc_stream_drop_extra_pre_encoded;
     if (drop_extra_subsequent <= 0 && pre_encode_cache_size >= 1) {
-        drop_extra_subsequent = 1 + (pre_encode_cache_size - 1) /
-                                    std::max(subsampling_factor, 1);
+        drop_extra_subsequent = 1 + (pre_encode_cache_size - 1) / std::max(subsampling_factor, 1);
     }
     int sampling_frames_first = pm->hparams.enc_stream_sampling_frames_first;
     if (sampling_frames_first <= 0) {
@@ -2954,7 +2706,7 @@ transcribe_status stream_begin(
     }
 
     const int chunk_size_subsequent = subsampling_factor * (1 + chosen_right);
-    const int chunk_size_first = sampling_frames_first + subsampling_factor * chosen_right;
+    const int chunk_size_first      = sampling_frames_first + subsampling_factor * chosen_right;
 
     pc->stream_caches.att_context_right     = chosen_right;
     pc->stream_caches.att_context_left      = chosen_left;
@@ -2970,18 +2722,17 @@ transcribe_status stream_begin(
     return TRANSCRIBE_OK;
 }
 
-transcribe_status stream_feed(
-    transcribe_session *        session,
-    const float *               pcm,
-    int                         n_samples,
-    transcribe_stream_update *  update)
-{
+transcribe_status stream_feed(transcribe_session *       session,
+                              const float *              pcm,
+                              int                        n_samples,
+                              transcribe_stream_update * update) {
     auto * pc = static_cast<ParakeetSession *>(session);
     auto * pm = static_cast<ParakeetModel *>(pc->model);
-    if (pc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
+    if (pc->poll_abort()) {
+        return TRANSCRIBE_ERR_ABORTED;
+    }
 
-    pc->stream_pcm_buffer.insert(
-        pc->stream_pcm_buffer.end(), pcm, pcm + n_samples);
+    pc->stream_pcm_buffer.insert(pc->stream_pcm_buffer.end(), pcm, pcm + n_samples);
     pc->stream_audio_input_us += samples_to_us(n_samples);
 
     const int prev_n_tokens = static_cast<int>(pc->raw_tokens.size());
@@ -3001,41 +2752,37 @@ transcribe_status stream_feed(
     // needs samples_chunk.
     if (pc->buf_active) {
         while (true) {
-            if (pc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
-            const int64_t num_new = pc->buf_initialized
-                ? static_cast<int64_t>(pc->buf_samples_chunk)
-                : static_cast<int64_t>(pc->buf_samples_chunk) +
-                  static_cast<int64_t>(pc->buf_samples_right);
+            if (pc->poll_abort()) {
+                return TRANSCRIBE_ERR_ABORTED;
+            }
+            const int64_t num_new  = pc->buf_initialized ? static_cast<int64_t>(pc->buf_samples_chunk) :
+                                                           static_cast<int64_t>(pc->buf_samples_chunk) +
+                                                               static_cast<int64_t>(pc->buf_samples_right);
             const int64_t need_end = pc->buf_next_audio_read + num_new;
             if (need_end > static_cast<int64_t>(pc->stream_pcm_buffer.size())) {
                 break;
             }
-            if (const transcribe_status st = emit_buffered_chunk(
-                    pc, pm, num_new, /*is_last_chunk=*/false);
-                st != TRANSCRIBE_OK)
-            {
+            if (const transcribe_status st = emit_buffered_chunk(pc, pm, num_new, /*is_last_chunk=*/false);
+                st != TRANSCRIBE_OK) {
                 return st;
             }
         }
-        const bool tokens_changed =
-            static_cast<int>(pc->raw_tokens.size()) != prev_n_tokens;
+        const bool tokens_changed = static_cast<int>(pc->raw_tokens.size()) != prev_n_tokens;
         if (tokens_changed) {
             rebuild_streaming_result_text(pc, pm);
             pc->n_committed_tokens   = static_cast<int>(pc->tokens.size());
             pc->n_committed_words    = 0;
             pc->n_committed_segments = 0;
-            pc->stream_revision     += 1;
+            pc->stream_revision += 1;
             pc->stream_audio_committed_us =
-                pc->buf_next_audio_read * 1000000LL /
-                std::max<int64_t>(pm->hparams.fe_sample_rate, 1);
+                pc->buf_next_audio_read * 1000000LL / std::max<int64_t>(pm->hparams.fe_sample_rate, 1);
         }
         if (update != nullptr) {
             update->result_changed     = tokens_changed;
             update->revision           = pc->stream_revision;
             update->input_received_ms  = us_to_ms(pc->stream_audio_input_us);
             update->audio_committed_ms = us_to_ms(pc->stream_audio_committed_us);
-            update->buffered_ms        = us_to_ms(
-                pc->stream_audio_input_us - pc->stream_audio_committed_us);
+            update->buffered_ms        = us_to_ms(pc->stream_audio_input_us - pc->stream_audio_committed_us);
         }
         return TRANSCRIBE_OK;
     }
@@ -3048,16 +2795,12 @@ transcribe_status stream_feed(
     // mel-frame is pcm_start_sample / hop. The first few buffer-relative
     // frames are reflect-pad garbage but correspond to already-emitted
     // absolute frames and are never read.
-    const int64_t t_mel_start = ggml_time_us();
-    int mel_n_mels   = 0;
-    int mel_n_frames = 0;
-    if (const transcribe_status mst = pm->mel->compute(
-            pc->stream_pcm_buffer.data(),
-            pc->stream_pcm_buffer.size(),
-            pc->mel_buf, mel_n_mels, mel_n_frames,
-            pc->n_threads);
-        mst != TRANSCRIBE_OK)
-    {
+    const int64_t t_mel_start  = ggml_time_us();
+    int           mel_n_mels   = 0;
+    int           mel_n_frames = 0;
+    if (const transcribe_status mst = pm->mel->compute(pc->stream_pcm_buffer.data(), pc->stream_pcm_buffer.size(),
+                                                       pc->mel_buf, mel_n_mels, mel_n_frames, pc->n_threads);
+        mst != TRANSCRIBE_OK) {
         // For very short buffers compute returns INVALID_ARG — "not
         // enough audio yet", a no-op feed, not a fatal error.
         if (mst == TRANSCRIBE_ERR_INVALID_ARG) {
@@ -3066,8 +2809,7 @@ transcribe_status stream_feed(
                 update->revision           = pc->stream_revision;
                 update->input_received_ms  = us_to_ms(pc->stream_audio_input_us);
                 update->audio_committed_ms = us_to_ms(pc->stream_audio_committed_us);
-                update->buffered_ms        = us_to_ms(
-                    pc->stream_audio_input_us - pc->stream_audio_committed_us);
+                update->buffered_ms        = us_to_ms(pc->stream_audio_input_us - pc->stream_audio_committed_us);
             }
             return TRANSCRIBE_OK;
         }
@@ -3079,31 +2821,26 @@ transcribe_status stream_feed(
     // chunk_size_first new frames, no prepend, drop_extra=0. Subsequent:
     // chunk_size_subsequent new + pre_encode_cache_size prepend,
     // drop_extra=drop_extra_subsequent.
-    const int pre_encode_cache_size = pm->hparams.enc_stream_pre_encode_cache_size > 0
-        ? pm->hparams.enc_stream_pre_encode_cache_size
-        : pm->hparams.enc_subsampling_factor + 1;
+    const int     pre_encode_cache_size = pm->hparams.enc_stream_pre_encode_cache_size > 0 ?
+                                              pm->hparams.enc_stream_pre_encode_cache_size :
+                                              pm->hparams.enc_subsampling_factor + 1;
     // pcm_start_frame is the absolute mel-frame index of buffer-relative
     // frame 0. Hop-aligned trim keeps this an integer.
-    const int hop = pm->hparams.fe_hop_length;
-    const int64_t pcm_start_frame =
-        pc->stream_caches.pcm_start_sample / hop;
+    const int     hop                   = pm->hparams.fe_hop_length;
+    const int64_t pcm_start_frame       = pc->stream_caches.pcm_start_sample / hop;
     while (true) {
-        if (pc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
+        if (pc->poll_abort()) {
+            return TRANSCRIBE_ERR_ABORTED;
+        }
 
         const int64_t consumed = pc->stream_caches.mel_frames_consumed;
-        const int64_t avail    = pcm_start_frame +
-                                 static_cast<int64_t>(mel_n_frames);
+        const int64_t avail    = pcm_start_frame + static_cast<int64_t>(mel_n_frames);
         const bool    is_first = pc->stream_caches.is_first_chunk;
 
-        const int chunk_advance = is_first
-            ? pc->stream_caches.chunk_size_first
-            : pc->stream_caches.chunk_size_subsequent;
-        const int mel_fed = is_first
-            ? pc->stream_caches.mel_fed_first
-            : pc->stream_caches.mel_fed_subsequent;
-        const int drop_extra = is_first
-            ? pc->stream_caches.drop_extra_first
-            : pc->stream_caches.drop_extra_subsequent;
+        const int chunk_advance =
+            is_first ? pc->stream_caches.chunk_size_first : pc->stream_caches.chunk_size_subsequent;
+        const int mel_fed    = is_first ? pc->stream_caches.mel_fed_first : pc->stream_caches.mel_fed_subsequent;
+        const int drop_extra = is_first ? pc->stream_caches.drop_extra_first : pc->stream_caches.drop_extra_subsequent;
         const int prepend_frames = mel_fed - chunk_advance;
 
         // Hold back the last ceil(n_fft/2 / hop) mel frames: their STFT
@@ -3111,69 +2848,58 @@ transcribe_status stream_feed(
         // slightly wrong (never matching NeMo's full-audio mel) until more
         // audio arrives. stream_finalize skips this margin since the
         // right-edge pad is then real (end of stream).
-        const int right_edge_margin = (pm->hparams.fe_n_fft / 2 +
-                                       pm->hparams.fe_hop_length - 1) /
-                                      pm->hparams.fe_hop_length;
-        if (avail - consumed < chunk_advance + right_edge_margin) break;
+        const int right_edge_margin =
+            (pm->hparams.fe_n_fft / 2 + pm->hparams.fe_hop_length - 1) / pm->hparams.fe_hop_length;
+        if (avail - consumed < chunk_advance + right_edge_margin) {
+            break;
+        }
 
-        std::vector<float> chunk(
-            static_cast<size_t>(mel_n_mels) *
-            static_cast<size_t>(mel_fed));
+        std::vector<float> chunk(static_cast<size_t>(mel_n_mels) * static_cast<size_t>(mel_fed));
 
         // mel_buf layout: row-major [n_mels, mel_n_frames]; entry
         // for absolute frame `abs_t` at offset
         // (m * mel_n_frames + (abs_t - pcm_start_frame)).
         auto mel_at = [&](int m, int64_t abs_t) -> float {
             const int64_t rel = abs_t - pcm_start_frame;
-            return pc->mel_buf[static_cast<size_t>(m) * mel_n_frames +
-                               static_cast<size_t>(rel)];
+            return pc->mel_buf[static_cast<size_t>(m) * mel_n_frames + static_cast<size_t>(rel)];
         };
 
         for (int m = 0; m < mel_n_mels; ++m) {
             // Pre-encode-cache prepend: [consumed - prepend_frames,
             // consumed). prepend_frames == 0 on the first chunk.
             for (int h = 0; h < prepend_frames; ++h) {
-                const int64_t frame_idx = consumed - prepend_frames + h;
-                const float val = (frame_idx < 0)
-                    ? 0.0f
-                    : mel_at(m, frame_idx);
+                const int64_t frame_idx                     = consumed - prepend_frames + h;
+                const float   val                           = (frame_idx < 0) ? 0.0f : mel_at(m, frame_idx);
                 chunk[static_cast<size_t>(m) * mel_fed + h] = val;
             }
             // New frames: [consumed, consumed + chunk_advance).
             for (int n = 0; n < chunk_advance; ++n) {
-                const float val = mel_at(m, consumed + n);
-                chunk[static_cast<size_t>(m) * mel_fed +
-                      prepend_frames + n] = val;
+                const float val                                              = mel_at(m, consumed + n);
+                chunk[static_cast<size_t>(m) * mel_fed + prepend_frames + n] = val;
             }
         }
 
         // Flip is_first_chunk before the emit (the emit uses the params
         // we already extracted).
         pc->stream_caches.is_first_chunk = false;
-        (void)pre_encode_cache_size;
+        (void) pre_encode_cache_size;
 
         const int64_t t_enc_start = ggml_time_us();
-        if (const transcribe_status st = emit_streaming_chunk(
-                pc, pm, chunk.data(),
-                mel_fed,
-                drop_extra,
-                chunk_advance);
-            st != TRANSCRIBE_OK)
-        {
+        if (const transcribe_status st = emit_streaming_chunk(pc, pm, chunk.data(), mel_fed, drop_extra, chunk_advance);
+            st != TRANSCRIBE_OK) {
             return st;
         }
         pc->t_encode_us += ggml_time_us() - t_enc_start;
     }
 
     // Rebuild the partial transcript from committed tokens.
-    const bool tokens_changed =
-        static_cast<int>(pc->raw_tokens.size()) != prev_n_tokens;
+    const bool tokens_changed = static_cast<int>(pc->raw_tokens.size()) != prev_n_tokens;
     if (tokens_changed) {
         rebuild_streaming_result_text(pc, pm);
         pc->n_committed_tokens   = static_cast<int>(pc->tokens.size());
         pc->n_committed_words    = 0;
         pc->n_committed_segments = 0;
-        pc->stream_revision     += 1;
+        pc->stream_revision += 1;
     }
 
     // Trim already-consumed PCM, keeping the prepend_max history frames
@@ -3183,31 +2909,17 @@ transcribe_status stream_feed(
     // hop-aligned so pcm_start_sample stays at mel-frame 0. First feed
     // (mel_frames_consumed == 0): keep_from is negative, guard rejects.
     {
-        const int pad = pm->hparams.fe_n_fft / 2;
-        const int prepend_max =
-            pc->stream_caches.mel_fed_subsequent -
-            pc->stream_caches.chunk_size_subsequent;
-        const int64_t earliest_frame_needed =
-            pc->stream_caches.mel_frames_consumed -
-            static_cast<int64_t>(prepend_max);
-        const int64_t earliest_sample_needed =
-            earliest_frame_needed * static_cast<int64_t>(hop);
-        const int64_t keep_from =
-            earliest_sample_needed - static_cast<int64_t>(pad);
+        const int     pad         = pm->hparams.fe_n_fft / 2;
+        const int     prepend_max = pc->stream_caches.mel_fed_subsequent - pc->stream_caches.chunk_size_subsequent;
+        const int64_t earliest_frame_needed = pc->stream_caches.mel_frames_consumed - static_cast<int64_t>(prepend_max);
+        const int64_t earliest_sample_needed = earliest_frame_needed * static_cast<int64_t>(hop);
+        const int64_t keep_from              = earliest_sample_needed - static_cast<int64_t>(pad);
         if (keep_from > pc->stream_caches.pcm_start_sample) {
-            const int64_t drop_raw =
-                keep_from - pc->stream_caches.pcm_start_sample;
-            const int64_t drop_aligned =
-                (drop_raw / static_cast<int64_t>(hop)) *
-                static_cast<int64_t>(hop);
-            if (drop_aligned > 0 &&
-                drop_aligned <=
-                static_cast<int64_t>(pc->stream_pcm_buffer.size()))
-            {
-                pc->stream_pcm_buffer.erase(
-                    pc->stream_pcm_buffer.begin(),
-                    pc->stream_pcm_buffer.begin() +
-                        static_cast<ptrdiff_t>(drop_aligned));
+            const int64_t drop_raw     = keep_from - pc->stream_caches.pcm_start_sample;
+            const int64_t drop_aligned = (drop_raw / static_cast<int64_t>(hop)) * static_cast<int64_t>(hop);
+            if (drop_aligned > 0 && drop_aligned <= static_cast<int64_t>(pc->stream_pcm_buffer.size())) {
+                pc->stream_pcm_buffer.erase(pc->stream_pcm_buffer.begin(),
+                                            pc->stream_pcm_buffer.begin() + static_cast<ptrdiff_t>(drop_aligned));
                 pc->stream_caches.pcm_start_sample += drop_aligned;
             }
         }
@@ -3216,27 +2928,21 @@ transcribe_status stream_feed(
     // Audio "committed" cursor. mel_frames_consumed (vs encoder output
     // frames) avoids the right-context overshoot that would make
     // "encoder frames * 80 ms" exceed the real audio time per chunk.
-    pc->stream_audio_committed_us =
-        pc->stream_caches.mel_frames_consumed *
-        static_cast<int64_t>(pm->hparams.fe_hop_length) *
-        1000000 /
-        static_cast<int64_t>(pm->hparams.fe_sample_rate);
+    pc->stream_audio_committed_us = pc->stream_caches.mel_frames_consumed *
+                                    static_cast<int64_t>(pm->hparams.fe_hop_length) * 1000000 /
+                                    static_cast<int64_t>(pm->hparams.fe_sample_rate);
 
     if (update != nullptr) {
         update->result_changed     = tokens_changed;
         update->revision           = pc->stream_revision;
         update->input_received_ms  = us_to_ms(pc->stream_audio_input_us);
         update->audio_committed_ms = us_to_ms(pc->stream_audio_committed_us);
-        update->buffered_ms        =
-            us_to_ms(pc->stream_audio_input_us - pc->stream_audio_committed_us);
+        update->buffered_ms        = us_to_ms(pc->stream_audio_input_us - pc->stream_audio_committed_us);
     }
     return TRANSCRIBE_OK;
 }
 
-transcribe_status stream_finalize(
-    transcribe_session *        session,
-    transcribe_stream_update *  update)
-{
+transcribe_status stream_finalize(transcribe_session * session, transcribe_stream_update * update) {
     auto * pc = static_cast<ParakeetSession *>(session);
     auto * pm = static_cast<ParakeetModel *>(pc->model);
     if (pm == nullptr || pm->plan.scheduler_list.empty()) {
@@ -3254,20 +2960,18 @@ transcribe_status stream_finalize(
     // add_frames_get_removed_ folds the right slot + this num_new into the
     // chunk slot so the decoder gets every frame past ctx_left (no zero-pad).
     if (pc->buf_active) {
-        const int64_t total =
-            static_cast<int64_t>(pc->stream_pcm_buffer.size());
+        const int64_t total = static_cast<int64_t>(pc->stream_pcm_buffer.size());
         if (pc->buf_next_audio_read < total) {
-            if (pc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
+            if (pc->poll_abort()) {
+                return TRANSCRIBE_ERR_ABORTED;
+            }
             const int64_t num_new = total - pc->buf_next_audio_read;
-            if (const transcribe_status st = emit_buffered_chunk(
-                    pc, pm, num_new, /*is_last_chunk=*/true);
-                st != TRANSCRIBE_OK)
-            {
+            if (const transcribe_status st = emit_buffered_chunk(pc, pm, num_new, /*is_last_chunk=*/true);
+                st != TRANSCRIBE_OK) {
                 return st;
             }
         }
-        const bool tokens_changed =
-            static_cast<int>(pc->raw_tokens.size()) != prev_n_tokens;
+        const bool tokens_changed = static_cast<int>(pc->raw_tokens.size()) != prev_n_tokens;
         if (tokens_changed || !pc->has_result) {
             rebuild_streaming_result_text(pc, pm);
         }
@@ -3275,7 +2979,7 @@ transcribe_status stream_finalize(
         pc->n_committed_tokens        = static_cast<int>(pc->tokens.size());
         pc->n_committed_words         = static_cast<int>(pc->words.size());
         pc->n_committed_segments      = static_cast<int>(pc->segments.size());
-        pc->stream_revision          += 1;
+        pc->stream_revision += 1;
         if (update != nullptr) {
             update->result_changed     = pc->has_result;
             update->revision           = pc->stream_revision;
@@ -3292,83 +2996,63 @@ transcribe_status stream_finalize(
     // final partial chunk so the tail audio isn't dropped (the encoder
     // graph handles arbitrary mel chunk sizes).
     if (!pc->stream_pcm_buffer.empty()) {
-        int mel_n_mels   = 0;
-        int mel_n_frames = 0;
-        const transcribe_status mst = pm->mel->compute(
-            pc->stream_pcm_buffer.data(),
-            pc->stream_pcm_buffer.size(),
-            pc->mel_buf, mel_n_mels, mel_n_frames,
-            pc->n_threads);
+        int                     mel_n_mels   = 0;
+        int                     mel_n_frames = 0;
+        const transcribe_status mst = pm->mel->compute(pc->stream_pcm_buffer.data(), pc->stream_pcm_buffer.size(),
+                                                       pc->mel_buf, mel_n_mels, mel_n_frames, pc->n_threads);
         if (mst != TRANSCRIBE_OK && mst != TRANSCRIBE_ERR_INVALID_ARG) {
             return mst;
         }
 
         if (mst == TRANSCRIBE_OK) {
-            const int hop = pm->hparams.fe_hop_length;
-            const int64_t pcm_start_frame =
-                pc->stream_caches.pcm_start_sample / hop;
-            const int64_t consumed = pc->stream_caches.mel_frames_consumed;
-            const int64_t avail    = pcm_start_frame +
-                                     static_cast<int64_t>(mel_n_frames);
-            const int64_t remaining = avail - consumed;
+            const int     hop             = pm->hparams.fe_hop_length;
+            const int64_t pcm_start_frame = pc->stream_caches.pcm_start_sample / hop;
+            const int64_t consumed        = pc->stream_caches.mel_frames_consumed;
+            const int64_t avail           = pcm_start_frame + static_cast<int64_t>(mel_n_frames);
+            const int64_t remaining       = avail - consumed;
             if (remaining > 0) {
                 const bool is_first = pc->stream_caches.is_first_chunk;
-                const int drop_extra = is_first
-                    ? pc->stream_caches.drop_extra_first
-                    : pc->stream_caches.drop_extra_subsequent;
-                const int mel_fed_full = is_first
-                    ? pc->stream_caches.mel_fed_first
-                    : pc->stream_caches.mel_fed_subsequent;
-                const int chunk_advance_full = is_first
-                    ? pc->stream_caches.chunk_size_first
-                    : pc->stream_caches.chunk_size_subsequent;
-                const int prepend_frames = mel_fed_full - chunk_advance_full;
+                const int  drop_extra =
+                    is_first ? pc->stream_caches.drop_extra_first : pc->stream_caches.drop_extra_subsequent;
+                const int mel_fed_full =
+                    is_first ? pc->stream_caches.mel_fed_first : pc->stream_caches.mel_fed_subsequent;
+                const int chunk_advance_full =
+                    is_first ? pc->stream_caches.chunk_size_first : pc->stream_caches.chunk_size_subsequent;
+                const int          prepend_frames = mel_fed_full - chunk_advance_full;
                 // Feed the natural partial-chunk size, no silence pad
                 // (NeMo's last-chunk behavior), so trailing-audio tokens
                 // survive instead of being masked by zero-pad frames.
-                const int new_take = static_cast<int>(remaining);
-                const int mel_fed = prepend_frames + new_take;
-                std::vector<float> chunk(
-                    static_cast<size_t>(mel_n_mels) *
-                    static_cast<size_t>(mel_fed),
-                    0.0f);
+                const int          new_take       = static_cast<int>(remaining);
+                const int          mel_fed        = prepend_frames + new_take;
+                std::vector<float> chunk(static_cast<size_t>(mel_n_mels) * static_cast<size_t>(mel_fed), 0.0f);
                 // mel_buf indexed by ABSOLUTE frame; translate to the
                 // buffer-relative offset via pcm_start_frame.
-                auto mel_at = [&](int m, int64_t abs_t) -> float {
+                auto               mel_at = [&](int m, int64_t abs_t) -> float {
                     const int64_t rel = abs_t - pcm_start_frame;
-                    return pc->mel_buf[static_cast<size_t>(m) * mel_n_frames +
-                                       static_cast<size_t>(rel)];
+                    return pc->mel_buf[static_cast<size_t>(m) * mel_n_frames + static_cast<size_t>(rel)];
                 };
                 for (int m = 0; m < mel_n_mels; ++m) {
                     for (int h = 0; h < prepend_frames; ++h) {
-                        const int64_t frame_idx = consumed - prepend_frames + h;
-                        const float val = (frame_idx < 0)
-                            ? 0.0f
-                            : mel_at(m, frame_idx);
+                        const int64_t frame_idx                     = consumed - prepend_frames + h;
+                        const float   val                           = (frame_idx < 0) ? 0.0f : mel_at(m, frame_idx);
                         chunk[static_cast<size_t>(m) * mel_fed + h] = val;
                     }
                     for (int n = 0; n < new_take; ++n) {
-                        const float val = mel_at(m, consumed + n);
-                        chunk[static_cast<size_t>(m) * mel_fed +
-                              prepend_frames + n] = val;
+                        const float val                                              = mel_at(m, consumed + n);
+                        chunk[static_cast<size_t>(m) * mel_fed + prepend_frames + n] = val;
                     }
                 }
                 pc->stream_caches.is_first_chunk = false;
-                if (const transcribe_status st = emit_streaming_chunk(
-                        pc, pm, chunk.data(),
-                        mel_fed,
-                        drop_extra,
-                        new_take);
-                    st != TRANSCRIBE_OK)
-                {
+                if (const transcribe_status st =
+                        emit_streaming_chunk(pc, pm, chunk.data(), mel_fed, drop_extra, new_take);
+                    st != TRANSCRIBE_OK) {
                     return st;
                 }
             }
         }
     }
 
-    const bool tokens_changed =
-        static_cast<int>(pc->raw_tokens.size()) != prev_n_tokens;
+    const bool tokens_changed = static_cast<int>(pc->raw_tokens.size()) != prev_n_tokens;
     if (tokens_changed || !pc->has_result) {
         rebuild_streaming_result_text(pc, pm);
     }
@@ -3378,7 +3062,7 @@ transcribe_status stream_finalize(
     pc->n_committed_tokens        = static_cast<int>(pc->tokens.size());
     pc->n_committed_words         = static_cast<int>(pc->words.size());
     pc->n_committed_segments      = static_cast<int>(pc->segments.size());
-    pc->stream_revision          += 1;
+    pc->stream_revision += 1;
 
     if (update != nullptr) {
         update->result_changed     = pc->has_result;
@@ -3392,17 +3076,19 @@ transcribe_status stream_finalize(
 
 void stream_reset(transcribe_session * session) {
     auto * pc = static_cast<ParakeetSession *>(session);
-    pc->stream_pcm_buffer.clear(); // keep the allocation
+    pc->stream_pcm_buffer.clear();  // keep the allocation
 }
 
 // Kind+slot probe. No run-slot extensions (always false on _RUN). On
 // _STREAM: ChunkedLimited takes PARAKEET_STREAM, ChunkedLimitedWithRc
 // takes PARAKEET_BUFFERED_STREAM, offline variants neither.
-bool accepts_ext_kind(const transcribe_model * model,
-                      transcribe_ext_slot      slot,
-                      uint32_t                 kind) {
-    if (model == nullptr) return false;
-    if (slot != TRANSCRIBE_EXT_SLOT_STREAM) return false;
+bool accepts_ext_kind(const transcribe_model * model, transcribe_ext_slot slot, uint32_t kind) {
+    if (model == nullptr) {
+        return false;
+    }
+    if (slot != TRANSCRIBE_EXT_SLOT_STREAM) {
+        return false;
+    }
     const auto * pm = static_cast<const ParakeetModel *>(model);
     switch (pm->hparams.enc_att_context_style) {
         case ParakeetHParams::AttContextStyle::ChunkedLimited:
@@ -3415,7 +3101,7 @@ bool accepts_ext_kind(const transcribe_model * model,
     return false;
 }
 
-} // namespace
+}  // namespace
 
 // `extern const` forces external linkage (a namespace-scope const object
 // is internal-linkage in C++ otherwise).
@@ -3433,7 +3119,7 @@ extern const Arch arch = {
     /* .accepts_ext_kind = */ accepts_ext_kind,
 };
 
-} // namespace transcribe::parakeet
+}  // namespace transcribe::parakeet
 
 // ---------------------------------------------------------------------------
 // Public parakeet extension init functions (global scope, C linkage).
@@ -3441,24 +3127,24 @@ extern const Arch arch = {
 // transcribe_ext header (size + kind) and the field defaults.
 // ---------------------------------------------------------------------------
 
-extern "C" void transcribe_parakeet_stream_ext_init(
-    struct transcribe_parakeet_stream_ext * p)
-{
-    if (p == nullptr) { return; }
+extern "C" void transcribe_parakeet_stream_ext_init(struct transcribe_parakeet_stream_ext * p) {
+    if (p == nullptr) {
+        return;
+    }
     std::memset(p, 0, sizeof(*p));
     p->ext.size          = sizeof(*p);
     p->ext.kind          = TRANSCRIBE_EXT_KIND_PARAKEET_STREAM;
     p->att_context_right = -1;  // model default (max accuracy / max latency)
 }
 
-extern "C" void transcribe_parakeet_buffered_stream_ext_init(
-    struct transcribe_parakeet_buffered_stream_ext * p)
-{
-    if (p == nullptr) { return; }
+extern "C" void transcribe_parakeet_buffered_stream_ext_init(struct transcribe_parakeet_buffered_stream_ext * p) {
+    if (p == nullptr) {
+        return;
+    }
     std::memset(p, 0, sizeof(*p));
-    p->ext.size  = sizeof(*p);
-    p->ext.kind  = TRANSCRIBE_EXT_KIND_PARAKEET_BUFFERED_STREAM;
-    p->left_ms   = -1;  // model default
-    p->chunk_ms  = -1;
-    p->right_ms  = -1;
+    p->ext.size = sizeof(*p);
+    p->ext.kind = TRANSCRIBE_EXT_KIND_PARAKEET_BUFFERED_STREAM;
+    p->left_ms  = -1;  // model default
+    p->chunk_ms = -1;
+    p->right_ms = -1;
 }
diff --git a/src/arch/parakeet/parakeet.h b/src/arch/parakeet/parakeet.h
index b8a94afe..9c4b1fff 100644
--- a/src/arch/parakeet/parakeet.h
+++ b/src/arch/parakeet/parakeet.h
@@ -9,9 +9,9 @@
 
 #include "decoder.h"
 #include "transcribe-backend.h"
-#include "transcribe-session.h"
 #include "transcribe-mel.h"
 #include "transcribe-model.h"
+#include "transcribe-session.h"
 #include "transcribe-tokenizer.h"
 #include "weights.h"
 
@@ -50,14 +50,12 @@ namespace transcribe::parakeet {
 // pass effective_T = ctx.total / encoder_frame2audio_samples — the conv
 // frontend may produce T_enc > effective_T, and those trailing frames
 // must be masked or they contaminate valid frames' attention scores.
-void compute_chunked_limited_with_rc_mask(
-    float * out_buf,
-    int     T,
-    int     left_context_frames,
-    int     chunk_size_frames,
-    int     right_context_frames,
-    int     pad_length);
-
+void compute_chunked_limited_with_rc_mask(float * out_buf,
+                                          int     T,
+                                          int     left_context_frames,
+                                          int     chunk_size_frames,
+                                          int     right_context_frames,
+                                          int     pad_length);
 
 // Family defaults — applied before transcribe::read_capability_kv runs
 // (KV present overrides, KV absent leaves the default). Defined in
@@ -84,8 +82,8 @@ struct ParakeetModel final : public transcribe_model {
 
     // Fused BN parameters live in a separate ggml context + buffer,
     // computed at load time from the raw BN tensors. Freed in dtor.
-    ggml_context *          bn_fused_ctx    = nullptr;
-    ggml_backend_buffer_t   bn_fused_buffer = nullptr;
+    ggml_context *        bn_fused_ctx    = nullptr;
+    ggml_backend_buffer_t bn_fused_buffer = nullptr;
 
     // On a CPU primary backend, the conformer 1×1 pointwise conv weights
     // are dequantized from F16 to F32 at load: CPUs without native F16
@@ -94,8 +92,8 @@ struct ParakeetModel final : public transcribe_model {
     // No-op on GPU backends and on non-CPU primary backends. The F16
     // source tensors stay resident (ggml can't free individual slots);
     // the weight slot is repointed at the F32 copy.
-    ggml_context *          conv_pw_f32_ctx    = nullptr;
-    ggml_backend_buffer_t   conv_pw_f32_buffer = nullptr;
+    ggml_context *        conv_pw_f32_ctx    = nullptr;
+    ggml_backend_buffer_t conv_pw_f32_buffer = nullptr;
 
     // Mel front-end, constructed once at load() from the hparams
     // (precomputes Hann window + Slaney mel filterbank).
@@ -178,20 +176,20 @@ struct ParakeetStreamingCaches {
     //   chunk_size_first=105, chunk_size_subsequent=112,
     //   mel_fed_first=105, mel_fed_subsequent=121 (9 cache + 112 new),
     //   drop_extra_first=0, drop_extra_subsequent=2.
-    int att_context_right            = 0;
-    int att_context_left             = 0;
-    int chunk_size_first             = 0;
-    int chunk_size_subsequent        = 0;
-    int mel_fed_first                = 0;
-    int mel_fed_subsequent           = 0;
-    int drop_extra_first             = 0;
-    int drop_extra_subsequent        = 0;
+    int  att_context_right     = 0;
+    int  att_context_left      = 0;
+    int  chunk_size_first      = 0;
+    int  chunk_size_subsequent = 0;
+    int  mel_fed_first         = 0;
+    int  mel_fed_subsequent    = 0;
+    int  drop_extra_first      = 0;
+    int  drop_extra_subsequent = 0;
     // Whether the next emit_streaming_chunk is the FIRST in this stream.
-    bool is_first_chunk              = true;
+    bool is_first_chunk        = true;
 
     // Per-stream chunk counter (NeMo's step_num). Resets at stream_begin,
     // increments per emit; indexes dump filenames.
-    int chunk_step              = 0;
+    int chunk_step = 0;
 
     bool initialized = false;
 };
@@ -219,21 +217,21 @@ struct ParakeetStreamingDecoderState {
 struct ParakeetSession final : public transcribe_session {
     // Compute context: cgraph + intermediate tensor metadata. no_alloc;
     // data lives in sched-managed buffers. Reset each run().
-    ggml_context *        compute_ctx    = nullptr;
+    ggml_context * compute_ctx = nullptr;
 
     // Multi-backend scheduler. Persists across calls; manages compute
     // buffer allocation and reuses buffers when topology is unchanged.
-    ggml_backend_sched_t  sched          = nullptr;
+    ggml_backend_sched_t sched = nullptr;
 
     // Encoder forward output, borrowed into compute_ctx; invalidated when
     // compute_ctx is reset next run().
     ggml_tensor * encoder_out = nullptr;
 
     // Per-context scratch reused across runs.
-    std::vector<float> mel_buf;
-    std::vector<float> pos_buf;
-    std::vector<float> pos_div_term;
-    std::vector<float> enc_host;
+    std::vector<float>    mel_buf;
+    std::vector<float>    pos_buf;
+    std::vector<float>    pos_div_term;
+    std::vector<float>    enc_host;
     std::vector<TdtToken> raw_tokens;
 
     // Per-call timings and the TDT decode result (tokens / words /
@@ -246,16 +244,16 @@ struct ParakeetSession final : public transcribe_session {
     // stream_finalize drains the buffer through the inference helper;
     // stream_reset clears (keeping capacity). NOT touched by
     // clear_result (the family owns its per-utterance audio scratch).
-    std::vector<float>   stream_pcm_buffer;
-    transcribe_run_params    stream_run_params {};
+    std::vector<float>    stream_pcm_buffer;
+    transcribe_run_params stream_run_params{};
 
     // ---- incremental streaming state (cache-aware) ----
     //
     // Allocated on the first stream_begin for ChunkedLimited variants,
     // zeroed at each stream_begin, persists across feed/finalize within
     // an utterance, freed in the dtor.
-    ParakeetStreamingCaches        stream_caches;
-    ParakeetStreamingDecoderState  stream_dec_state;
+    ParakeetStreamingCaches       stream_caches;
+    ParakeetStreamingDecoderState stream_dec_state;
 
     // ---- Buffered streaming state (parakeet-unified-en-0.6b) ----
     //
@@ -268,31 +266,31 @@ struct ParakeetSession final : public transcribe_session {
     // ContextSize, updated per-chunk via buf_ctx_add_frames (NeMo's
     // add_frames_get_removed_). The RNN-T state rides on stream_dec_state
     // (same predictor/joint path, no per-layer encoder cache).
-    int32_t buf_left_frames   = 0;  // L (expected)
-    int32_t buf_chunk_frames  = 0;  // C
-    int32_t buf_right_frames  = 0;  // R
-    int32_t buf_samples_left  = 0;  // L * encoder_frame2audio_samples
-    int32_t buf_samples_chunk = 0;
-    int32_t buf_samples_right = 0;
+    int32_t buf_left_frames     = 0;  // L (expected)
+    int32_t buf_chunk_frames    = 0;  // C
+    int32_t buf_right_frames    = 0;  // R
+    int32_t buf_samples_left    = 0;  // L * encoder_frame2audio_samples
+    int32_t buf_samples_chunk   = 0;
+    int32_t buf_samples_right   = 0;
     // Next sample index in stream_pcm_buffer to feed (= NeMo's
     // `left_sample` at the start of the next step). 0 at stream_begin;
     // advances by num_new_samples after each emit.
     int64_t buf_next_audio_read = 0;
     // Buffer's internal ContextSize. (0,0,0) at stream_begin; ramps up
     // as audio arrives until it saturates at (samples_left, chunk, right).
-    int64_t buf_ctx_left  = 0;
-    int64_t buf_ctx_chunk = 0;
-    int64_t buf_ctx_right = 0;
+    int64_t buf_ctx_left        = 0;
+    int64_t buf_ctx_chunk       = 0;
+    int64_t buf_ctx_right       = 0;
     // Whether step 0 (the initial fill of samples_chunk+samples_right)
     // has run. False at stream_begin; first emit flips it.
-    bool    buf_initialized = false;
+    bool    buf_initialized     = false;
     // Per-stream chunk step counter (== NeMo's `step_num`). Used for
     // per-chunk dump file naming.
-    int32_t buf_chunk_step = 0;
-    bool    buf_active = false;
+    int32_t buf_chunk_step      = 0;
+    bool    buf_active          = false;
 
     ParakeetSession() = default;
     ~ParakeetSession() override;
 };
 
-} // namespace transcribe::parakeet
+}  // namespace transcribe::parakeet
diff --git a/src/arch/parakeet/weights.cpp b/src/arch/parakeet/weights.cpp
index 7035d32b..1126fedf 100644
--- a/src/arch/parakeet/weights.cpp
+++ b/src/arch/parakeet/weights.cpp
@@ -8,12 +8,11 @@
 
 #include "weights.h"
 
-#include "transcribe-meta.h"
-#include "transcribe-weights-util.h"
-#include "transcribe-log.h"
-
 #include "ggml.h"
 #include "gguf.h"
+#include "transcribe-log.h"
+#include "transcribe-meta.h"
+#include "transcribe-weights-util.h"
 
 #include <cstdio>
 #include <cstdlib>
@@ -30,35 +29,74 @@ namespace {
 
 constexpr const char * kFamilyTag = "parakeet";
 
-} // namespace
+}  // namespace
 
-transcribe_status read_parakeet_hparams(const gguf_context * gguf,
-                                        ParakeetHParams &    hp)
-{
+transcribe_status read_parakeet_hparams(const gguf_context * gguf, ParakeetHParams & hp) {
     if (gguf == nullptr) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
 
     // Encoder.
-    if (auto st = read_required_u32_kv(gguf, "stt.parakeet.encoder.n_layers", kFamilyTag,          hp.enc_n_layers);          st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.parakeet.encoder.d_model", kFamilyTag,           hp.enc_d_model);           st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.parakeet.encoder.n_heads", kFamilyTag,           hp.enc_n_heads);           st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.parakeet.encoder.d_ff", kFamilyTag,              hp.enc_d_ff);              st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.parakeet.encoder.conv_kernel", kFamilyTag,       hp.enc_conv_kernel);       st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.parakeet.encoder.subsampling_factor", kFamilyTag,hp.enc_subsampling_factor);st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.parakeet.encoder.subsampling_channels", kFamilyTag, hp.enc_subsampling_channels); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.parakeet.encoder.pos_emb_max_len", kFamilyTag,   hp.enc_pos_emb_max_len);   st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_u32_kv(gguf, "stt.parakeet.encoder.n_layers", kFamilyTag, hp.enc_n_layers);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.parakeet.encoder.d_model", kFamilyTag, hp.enc_d_model);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.parakeet.encoder.n_heads", kFamilyTag, hp.enc_n_heads);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.parakeet.encoder.d_ff", kFamilyTag, hp.enc_d_ff);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.parakeet.encoder.conv_kernel", kFamilyTag, hp.enc_conv_kernel);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.parakeet.encoder.subsampling_factor", kFamilyTag,
+                                       hp.enc_subsampling_factor);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.parakeet.encoder.subsampling_channels", kFamilyTag,
+                                       hp.enc_subsampling_channels);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st =
+            read_required_u32_kv(gguf, "stt.parakeet.encoder.pos_emb_max_len", kFamilyTag, hp.enc_pos_emb_max_len);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // use_bias: false for v2/v3, true for 1.1B and rnnt/ctc (11 biases
     // per block). Default false for legacy GGUFs without the KV.
-    if (auto st = read_optional_bool_kv(gguf, "stt.parakeet.encoder.use_bias", kFamilyTag, false, hp.enc_use_bias); st != TRANSCRIBE_OK) return st;
+    if (auto st = read_optional_bool_kv(gguf, "stt.parakeet.encoder.use_bias", kFamilyTag, false, hp.enc_use_bias);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // xscaling (see weights.h). Default false for legacy GGUFs.
-    if (auto st = read_optional_bool_kv(gguf, "stt.parakeet.encoder.xscaling", kFamilyTag, false, hp.enc_xscaling); st != TRANSCRIBE_OK) return st;
+    if (auto st = read_optional_bool_kv(gguf, "stt.parakeet.encoder.xscaling", kFamilyTag, false, hp.enc_xscaling);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Local attention window. Default -1/-1 = full attention.
-    if (auto st = read_optional_int32_kv(gguf, "stt.parakeet.encoder.att_context_left",  kFamilyTag, -1, hp.enc_att_context_left);  st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_int32_kv(gguf, "stt.parakeet.encoder.att_context_right", kFamilyTag, -1, hp.enc_att_context_right); st != TRANSCRIBE_OK) return st;
+    if (auto st = read_optional_int32_kv(gguf, "stt.parakeet.encoder.att_context_left", kFamilyTag, -1,
+                                         hp.enc_att_context_left);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_int32_kv(gguf, "stt.parakeet.encoder.att_context_right", kFamilyTag, -1,
+                                         hp.enc_att_context_right);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Multi-lookahead training menu (cache-aware streaming). Flat int32
     // [L0,R0,L1,R1,...]; index 0 must equal (att_context_left,
@@ -70,8 +108,9 @@ transcribe_status read_parakeet_hparams(const gguf_context * gguf,
             case KvResult::Ok:
                 if (flat.empty() || (flat.size() % 2) != 0) {
                     log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                                 "parakeet: stt.parakeet.encoder.att_context_size_choices "
-                                 "has odd length %zu (expected pairs)", flat.size());
+                            "parakeet: stt.parakeet.encoder.att_context_size_choices "
+                            "has odd length %zu (expected pairs)",
+                            flat.size());
                     return TRANSCRIBE_ERR_GGUF;
                 }
                 hp.enc_att_context_size_choices.clear();
@@ -79,16 +118,15 @@ transcribe_status read_parakeet_hparams(const gguf_context * gguf,
                 for (size_t i = 0; i + 1 < flat.size(); i += 2) {
                     hp.enc_att_context_size_choices.emplace_back(flat[i], flat[i + 1]);
                 }
-                if (hp.enc_att_context_size_choices.front().first  != hp.enc_att_context_left ||
-                    hp.enc_att_context_size_choices.front().second != hp.enc_att_context_right)
-                {
+                if (hp.enc_att_context_size_choices.front().first != hp.enc_att_context_left ||
+                    hp.enc_att_context_size_choices.front().second != hp.enc_att_context_right) {
                     log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                                 "parakeet: att_context_size_choices[0] = (%d, %d) "
-                                 "but att_context_left/right = (%d, %d); "
-                                 "GGUF is inconsistent",
-                                 hp.enc_att_context_size_choices.front().first,
-                                 hp.enc_att_context_size_choices.front().second,
-                                 hp.enc_att_context_left, hp.enc_att_context_right);
+                            "parakeet: att_context_size_choices[0] = (%d, %d) "
+                            "but att_context_left/right = (%d, %d); "
+                            "GGUF is inconsistent",
+                            hp.enc_att_context_size_choices.front().first,
+                            hp.enc_att_context_size_choices.front().second, hp.enc_att_context_left,
+                            hp.enc_att_context_right);
                     return TRANSCRIBE_ERR_GGUF;
                 }
                 break;
@@ -97,13 +135,12 @@ transcribe_status read_parakeet_hparams(const gguf_context * gguf,
                 // GGUFs (-1, -1) this still produces a one-element list;
                 // streaming code paths gate on att_context_style anyway.
                 hp.enc_att_context_size_choices.clear();
-                hp.enc_att_context_size_choices.emplace_back(
-                    hp.enc_att_context_left, hp.enc_att_context_right);
+                hp.enc_att_context_size_choices.emplace_back(hp.enc_att_context_left, hp.enc_att_context_right);
                 break;
             case KvResult::BadType:
                 log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                             "parakeet: stt.parakeet.encoder.att_context_size_choices "
-                             "has wrong type (expected int32 array)");
+                        "parakeet: stt.parakeet.encoder.att_context_size_choices "
+                        "has wrong type (expected int32 array)");
                 return TRANSCRIBE_ERR_GGUF;
         }
     }
@@ -122,30 +159,33 @@ transcribe_status read_parakeet_hparams(const gguf_context * gguf,
                     return TRANSCRIBE_OK;
                 case KvResult::BadType:
                     log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                                 "parakeet: %s has wrong type "
-                                 "(expected int32 array)", key);
+                            "parakeet: %s has wrong type "
+                            "(expected int32 array)",
+                            key);
                     return TRANSCRIBE_ERR_GGUF;
             }
             return TRANSCRIBE_ERR_GGUF;
         };
-        if (auto st = read_menu("stt.parakeet.encoder.att_chunk_left_choices",
-                                hp.enc_att_chunk_left_choices);
-            st != TRANSCRIBE_OK) return st;
-        if (auto st = read_menu("stt.parakeet.encoder.att_chunk_chunk_choices",
-                                hp.enc_att_chunk_chunk_choices);
-            st != TRANSCRIBE_OK) return st;
-        if (auto st = read_menu("stt.parakeet.encoder.att_chunk_right_choices",
-                                hp.enc_att_chunk_right_choices);
-            st != TRANSCRIBE_OK) return st;
+        if (auto st = read_menu("stt.parakeet.encoder.att_chunk_left_choices", hp.enc_att_chunk_left_choices);
+            st != TRANSCRIBE_OK) {
+            return st;
+        }
+        if (auto st = read_menu("stt.parakeet.encoder.att_chunk_chunk_choices", hp.enc_att_chunk_chunk_choices);
+            st != TRANSCRIBE_OK) {
+            return st;
+        }
+        if (auto st = read_menu("stt.parakeet.encoder.att_chunk_right_choices", hp.enc_att_chunk_right_choices);
+            st != TRANSCRIBE_OK) {
+            return st;
+        }
     }
 
     // Attention context style. Optional, default "regular" for legacy GGUFs.
     {
         std::string style;
-        if (auto st = read_optional_string_kv(gguf, "stt.parakeet.encoder.att_context_style",
-                                              kFamilyTag, "regular", style);
-            st != TRANSCRIBE_OK)
-        {
+        if (auto st =
+                read_optional_string_kv(gguf, "stt.parakeet.encoder.att_context_style", kFamilyTag, "regular", style);
+            st != TRANSCRIBE_OK) {
             return st;
         }
         if (style == "regular") {
@@ -154,24 +194,21 @@ transcribe_status read_parakeet_hparams(const gguf_context * gguf,
             hp.enc_att_context_style = ParakeetHParams::AttContextStyle::ChunkedLimited;
         } else if (style == "chunked_limited_with_rc") {
             hp.enc_att_context_style = ParakeetHParams::AttContextStyle::ChunkedLimitedWithRc;
-            if (hp.enc_att_chunk_left_choices.empty()  ||
-                hp.enc_att_chunk_chunk_choices.empty() ||
-                hp.enc_att_chunk_right_choices.empty())
-            {
+            if (hp.enc_att_chunk_left_choices.empty() || hp.enc_att_chunk_chunk_choices.empty() ||
+                hp.enc_att_chunk_right_choices.empty()) {
                 log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                             "parakeet: att_context_style=chunked_limited_with_rc "
-                             "requires non-empty att_chunk_{left,chunk,right}_choices "
-                             "arrays in the GGUF; got %zu/%zu/%zu entries",
-                             hp.enc_att_chunk_left_choices.size(),
-                             hp.enc_att_chunk_chunk_choices.size(),
-                             hp.enc_att_chunk_right_choices.size());
+                        "parakeet: att_context_style=chunked_limited_with_rc "
+                        "requires non-empty att_chunk_{left,chunk,right}_choices "
+                        "arrays in the GGUF; got %zu/%zu/%zu entries",
+                        hp.enc_att_chunk_left_choices.size(), hp.enc_att_chunk_chunk_choices.size(),
+                        hp.enc_att_chunk_right_choices.size());
                 return TRANSCRIBE_ERR_GGUF;
             }
         } else {
             log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "parakeet: unsupported att_context_style \"%s\" "
-                         "(allowed: regular, chunked_limited, chunked_limited_with_rc)",
-                         style.c_str());
+                    "parakeet: unsupported att_context_style \"%s\" "
+                    "(allowed: regular, chunked_limited, chunked_limited_with_rc)",
+                    style.c_str());
             return TRANSCRIBE_ERR_GGUF;
         }
     }
@@ -179,14 +216,21 @@ transcribe_status read_parakeet_hparams(const gguf_context * gguf,
     // Conv module: per-side depthwise padding and norm type. Optional;
     // defaults -1 (centred (k-1)/2) and "batch_norm" (fused BN with
     // running_mean / running_var).
-    if (auto st = read_optional_int32_kv(gguf, "stt.parakeet.encoder.conv_context_left",  kFamilyTag, -1, hp.enc_conv_context_left);  st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_int32_kv(gguf, "stt.parakeet.encoder.conv_context_right", kFamilyTag, -1, hp.enc_conv_context_right); st != TRANSCRIBE_OK) return st;
+    if (auto st = read_optional_int32_kv(gguf, "stt.parakeet.encoder.conv_context_left", kFamilyTag, -1,
+                                         hp.enc_conv_context_left);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_int32_kv(gguf, "stt.parakeet.encoder.conv_context_right", kFamilyTag, -1,
+                                         hp.enc_conv_context_right);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
     {
         std::string norm_type;
-        if (auto st = read_optional_string_kv(gguf, "stt.parakeet.encoder.conv_norm_type",
-                                              kFamilyTag, "batch_norm", norm_type);
-            st != TRANSCRIBE_OK)
-        {
+        if (auto st = read_optional_string_kv(gguf, "stt.parakeet.encoder.conv_norm_type", kFamilyTag, "batch_norm",
+                                              norm_type);
+            st != TRANSCRIBE_OK) {
             return st;
         }
         if (norm_type == "batch_norm") {
@@ -195,41 +239,36 @@ transcribe_status read_parakeet_hparams(const gguf_context * gguf,
             hp.enc_conv_norm_type = ParakeetHParams::ConvNormType::LayerNorm;
         } else {
             log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "parakeet: unsupported conv_norm_type \"%s\" "
-                         "(allowed: batch_norm, layer_norm)",
-                         norm_type.c_str());
+                    "parakeet: unsupported conv_norm_type \"%s\" "
+                    "(allowed: batch_norm, layer_norm)",
+                    norm_type.c_str());
             return TRANSCRIBE_ERR_GGUF;
         }
     }
 
     // Cache-aware streaming pre-encode constants. Optional, default 0
     // (non-streaming); the streaming paths gate on both > 0.
-    if (auto st = read_optional_int32_kv(gguf, "stt.parakeet.encoder.streaming.pre_encode_cache_size",
-                                         kFamilyTag, 0, hp.enc_stream_pre_encode_cache_size);
-        st != TRANSCRIBE_OK)
-    {
+    if (auto st = read_optional_int32_kv(gguf, "stt.parakeet.encoder.streaming.pre_encode_cache_size", kFamilyTag, 0,
+                                         hp.enc_stream_pre_encode_cache_size);
+        st != TRANSCRIBE_OK) {
         return st;
     }
-    if (auto st = read_optional_int32_kv(gguf, "stt.parakeet.encoder.streaming.drop_extra_pre_encoded",
-                                         kFamilyTag, 0, hp.enc_stream_drop_extra_pre_encoded);
-        st != TRANSCRIBE_OK)
-    {
+    if (auto st = read_optional_int32_kv(gguf, "stt.parakeet.encoder.streaming.drop_extra_pre_encoded", kFamilyTag, 0,
+                                         hp.enc_stream_drop_extra_pre_encoded);
+        st != TRANSCRIBE_OK) {
         return st;
     }
-    if (auto st = read_optional_int32_kv(gguf, "stt.parakeet.encoder.streaming.sampling_frames_first",
-                                         kFamilyTag, 0, hp.enc_stream_sampling_frames_first);
-        st != TRANSCRIBE_OK)
-    {
+    if (auto st = read_optional_int32_kv(gguf, "stt.parakeet.encoder.streaming.sampling_frames_first", kFamilyTag, 0,
+                                         hp.enc_stream_sampling_frames_first);
+        st != TRANSCRIBE_OK) {
         return st;
     }
 
     // Head kind dispatch. Optional KV, default "tdt" for legacy v2/v3.
     {
         std::string head_kind_str;
-        if (auto st = read_optional_string_kv(gguf, "stt.parakeet.head_kind",
-                                              kFamilyTag, "tdt", head_kind_str);
-            st != TRANSCRIBE_OK)
-        {
+        if (auto st = read_optional_string_kv(gguf, "stt.parakeet.head_kind", kFamilyTag, "tdt", head_kind_str);
+            st != TRANSCRIBE_OK) {
             return st;
         }
         if (head_kind_str == "tdt") {
@@ -240,23 +279,42 @@ transcribe_status read_parakeet_hparams(const gguf_context * gguf,
             hp.head_kind = HeadKind::CTC;
         } else {
             log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "parakeet: unsupported head_kind \"%s\" "
-                         "(allowed: tdt, rnnt, ctc)",
-                         head_kind_str.c_str());
+                    "parakeet: unsupported head_kind \"%s\" "
+                    "(allowed: tdt, rnnt, ctc)",
+                    head_kind_str.c_str());
             return TRANSCRIBE_ERR_GGUF;
         }
     }
 
     if (hp.head_kind != HeadKind::CTC) {
         // Predictor (TDT and RNNT only; CTC has no predictor).
-        if (auto st = read_required_u32_kv(gguf, "stt.parakeet.predictor.hidden", kFamilyTag,   hp.pred_hidden);   st != TRANSCRIBE_OK) return st;
-        if (auto st = read_required_u32_kv(gguf, "stt.parakeet.predictor.n_layers", kFamilyTag, hp.pred_n_layers); st != TRANSCRIBE_OK) return st;
-        if (auto st = read_required_u32_kv(gguf, "stt.parakeet.predictor.vocab", kFamilyTag,    hp.pred_vocab);    st != TRANSCRIBE_OK) return st;
+        if (auto st = read_required_u32_kv(gguf, "stt.parakeet.predictor.hidden", kFamilyTag, hp.pred_hidden);
+            st != TRANSCRIBE_OK) {
+            return st;
+        }
+        if (auto st = read_required_u32_kv(gguf, "stt.parakeet.predictor.n_layers", kFamilyTag, hp.pred_n_layers);
+            st != TRANSCRIBE_OK) {
+            return st;
+        }
+        if (auto st = read_required_u32_kv(gguf, "stt.parakeet.predictor.vocab", kFamilyTag, hp.pred_vocab);
+            st != TRANSCRIBE_OK) {
+            return st;
+        }
 
         // Joint (TDT and RNNT only).
-        if (auto st = read_required_u32_kv(gguf, "stt.parakeet.joint.hidden", kFamilyTag,            hp.joint_hidden);            st != TRANSCRIBE_OK) return st;
-        if (auto st = read_required_u32_kv(gguf, "stt.parakeet.joint.num_extra_outputs", kFamilyTag, hp.joint_num_extra_outputs); st != TRANSCRIBE_OK) return st;
-        if (auto st = read_required_string_kv(gguf, "stt.parakeet.joint.activation", kFamilyTag, hp.joint_activation);        st != TRANSCRIBE_OK) return st;
+        if (auto st = read_required_u32_kv(gguf, "stt.parakeet.joint.hidden", kFamilyTag, hp.joint_hidden);
+            st != TRANSCRIBE_OK) {
+            return st;
+        }
+        if (auto st = read_required_u32_kv(gguf, "stt.parakeet.joint.num_extra_outputs", kFamilyTag,
+                                           hp.joint_num_extra_outputs);
+            st != TRANSCRIBE_OK) {
+            return st;
+        }
+        if (auto st = read_required_string_kv(gguf, "stt.parakeet.joint.activation", kFamilyTag, hp.joint_activation);
+            st != TRANSCRIBE_OK) {
+            return st;
+        }
     }
 
     if (hp.head_kind == HeadKind::TDT) {
@@ -268,8 +326,8 @@ transcribe_status read_parakeet_hparams(const gguf_context * gguf,
             case KvResult::Absent:
             case KvResult::BadType:
                 log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                             "parakeet: required KV \"stt.parakeet.tdt.durations\" "
-                             "missing or wrong type (head_kind=tdt)");
+                        "parakeet: required KV \"stt.parakeet.tdt.durations\" "
+                        "missing or wrong type (head_kind=tdt)");
                 return TRANSCRIBE_ERR_GGUF;
         }
         {
@@ -281,8 +339,8 @@ transcribe_status read_parakeet_hparams(const gguf_context * gguf,
                     break;
                 case KvResult::BadType:
                     log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                                 "parakeet: optional KV \"stt.parakeet.tdt.max_symbols\" "
-                                 "has wrong type");
+                            "parakeet: optional KV \"stt.parakeet.tdt.max_symbols\" "
+                            "has wrong type");
                     return TRANSCRIBE_ERR_GGUF;
             }
         }
@@ -301,81 +359,115 @@ transcribe_status read_parakeet_hparams(const gguf_context * gguf,
     // and loader; reading every field makes the loader the gate that
     // catches a converter that drops one. CMVN/LFR fields are not read
     // (Parakeet doesn't use them).
-    if (auto st = read_required_string_kv(gguf, "stt.frontend.type", kFamilyTag, hp.fe_type);         st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.frontend.num_mels", kFamilyTag, hp.fe_num_mels);     st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.frontend.sample_rate", kFamilyTag, hp.fe_sample_rate);  st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.frontend.n_fft", kFamilyTag, hp.fe_n_fft);        st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.frontend.win_length", kFamilyTag, hp.fe_win_length);   st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.frontend.hop_length", kFamilyTag, hp.fe_hop_length);   st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.frontend.window", kFamilyTag, hp.fe_window);       st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.frontend.normalize", kFamilyTag, hp.fe_normalize);    st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf, "stt.frontend.dither", kFamilyTag, hp.fe_dither);       st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf, "stt.frontend.pre_emphasis", kFamilyTag, hp.fe_pre_emphasis); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf, "stt.frontend.f_min", kFamilyTag, hp.fe_f_min);        st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf, "stt.frontend.f_max", kFamilyTag, hp.fe_f_max);        st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_string_kv(gguf, "stt.frontend.type", kFamilyTag, hp.fe_type); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.num_mels", kFamilyTag, hp.fe_num_mels);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.sample_rate", kFamilyTag, hp.fe_sample_rate);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.n_fft", kFamilyTag, hp.fe_n_fft); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.win_length", kFamilyTag, hp.fe_win_length);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.hop_length", kFamilyTag, hp.fe_hop_length);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_string_kv(gguf, "stt.frontend.window", kFamilyTag, hp.fe_window); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_string_kv(gguf, "stt.frontend.normalize", kFamilyTag, hp.fe_normalize);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.frontend.dither", kFamilyTag, hp.fe_dither); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.frontend.pre_emphasis", kFamilyTag, hp.fe_pre_emphasis);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.frontend.f_min", kFamilyTag, hp.fe_f_min); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.frontend.f_max", kFamilyTag, hp.fe_f_max); st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Prompt MLP. Optional (multilingual variants only). Presence of
     // stt.parakeet.prompt.num_prompts is the gate; absent leaves every
     // prompt_* field zero/empty and the encoder skips the prompt path.
     if (gguf_find_key(gguf, "stt.parakeet.prompt.num_prompts") >= 0) {
-        if (auto st = read_required_u32_kv(gguf, "stt.parakeet.prompt.num_prompts",
-                                           kFamilyTag, hp.prompt_num_prompts);
-            st != TRANSCRIBE_OK) return st;
+        if (auto st = read_required_u32_kv(gguf, "stt.parakeet.prompt.num_prompts", kFamilyTag, hp.prompt_num_prompts);
+            st != TRANSCRIBE_OK) {
+            return st;
+        }
         if (hp.prompt_num_prompts > 0) {
             hp.has_prompt = true;
 
-            if (auto st = read_required_u32_kv(gguf, "stt.parakeet.prompt.hidden",
-                                               kFamilyTag, hp.prompt_hidden);
-                st != TRANSCRIBE_OK) return st;
-            if (auto st = read_required_string_kv(gguf, "stt.parakeet.prompt.field",
-                                                  kFamilyTag, hp.prompt_field);
-                st != TRANSCRIBE_OK) return st;
-            if (auto st = read_required_string_kv(gguf, "stt.parakeet.prompt.activation",
-                                                  kFamilyTag, hp.prompt_activation);
-                st != TRANSCRIBE_OK) return st;
-
-            switch (read_string_array_kv(gguf, "stt.parakeet.prompt.dictionary.locales",
-                                         hp.prompt_dictionary_locales)) {
-                case KvResult::Ok: break;
+            if (auto st = read_required_u32_kv(gguf, "stt.parakeet.prompt.hidden", kFamilyTag, hp.prompt_hidden);
+                st != TRANSCRIBE_OK) {
+                return st;
+            }
+            if (auto st = read_required_string_kv(gguf, "stt.parakeet.prompt.field", kFamilyTag, hp.prompt_field);
+                st != TRANSCRIBE_OK) {
+                return st;
+            }
+            if (auto st =
+                    read_required_string_kv(gguf, "stt.parakeet.prompt.activation", kFamilyTag, hp.prompt_activation);
+                st != TRANSCRIBE_OK) {
+                return st;
+            }
+
+            switch (
+                read_string_array_kv(gguf, "stt.parakeet.prompt.dictionary.locales", hp.prompt_dictionary_locales)) {
+                case KvResult::Ok:
+                    break;
                 case KvResult::Absent:
                     log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                                 "parakeet: stt.parakeet.prompt.dictionary.locales "
-                                 "is required when prompt.num_prompts > 0");
+                            "parakeet: stt.parakeet.prompt.dictionary.locales "
+                            "is required when prompt.num_prompts > 0");
                     return TRANSCRIBE_ERR_GGUF;
                 case KvResult::BadType:
                     log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                                 "parakeet: stt.parakeet.prompt.dictionary.locales "
-                                 "has wrong type (expected string array)");
+                            "parakeet: stt.parakeet.prompt.dictionary.locales "
+                            "has wrong type (expected string array)");
                     return TRANSCRIBE_ERR_GGUF;
             }
-            switch (read_int32_array_kv(gguf, "stt.parakeet.prompt.dictionary.indices",
-                                        hp.prompt_dictionary_indices)) {
-                case KvResult::Ok: break;
+            switch (read_int32_array_kv(gguf, "stt.parakeet.prompt.dictionary.indices", hp.prompt_dictionary_indices)) {
+                case KvResult::Ok:
+                    break;
                 case KvResult::Absent:
                     log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                                 "parakeet: stt.parakeet.prompt.dictionary.indices "
-                                 "is required when prompt.num_prompts > 0");
+                            "parakeet: stt.parakeet.prompt.dictionary.indices "
+                            "is required when prompt.num_prompts > 0");
                     return TRANSCRIBE_ERR_GGUF;
                 case KvResult::BadType:
                     log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                                 "parakeet: stt.parakeet.prompt.dictionary.indices "
-                                 "has wrong type (expected int32 array)");
+                            "parakeet: stt.parakeet.prompt.dictionary.indices "
+                            "has wrong type (expected int32 array)");
                     return TRANSCRIBE_ERR_GGUF;
             }
-            if (hp.prompt_dictionary_locales.size() !=
-                hp.prompt_dictionary_indices.size())
-            {
+            if (hp.prompt_dictionary_locales.size() != hp.prompt_dictionary_indices.size()) {
                 log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                             "parakeet: prompt dictionary locales/indices length "
-                             "mismatch (%zu vs %zu)",
-                             hp.prompt_dictionary_locales.size(),
-                             hp.prompt_dictionary_indices.size());
+                        "parakeet: prompt dictionary locales/indices length "
+                        "mismatch (%zu vs %zu)",
+                        hp.prompt_dictionary_locales.size(), hp.prompt_dictionary_indices.size());
                 return TRANSCRIBE_ERR_GGUF;
             }
             if (gguf_find_key(gguf, "stt.parakeet.prompt.auto_id") >= 0) {
-                if (auto st = read_required_u32_kv(gguf, "stt.parakeet.prompt.auto_id",
-                                                   kFamilyTag, hp.prompt_auto_id);
-                    st != TRANSCRIBE_OK) return st;
+                if (auto st = read_required_u32_kv(gguf, "stt.parakeet.prompt.auto_id", kFamilyTag, hp.prompt_auto_id);
+                    st != TRANSCRIBE_OK) {
+                    return st;
+                }
             } else {
                 hp.prompt_auto_id = -1;
             }
@@ -383,31 +475,27 @@ transcribe_status read_parakeet_hparams(const gguf_context * gguf,
             // The C++ prompt MLP implements ReLU only.
             if (hp.prompt_activation != "relu") {
                 log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                             "parakeet: unsupported prompt activation \"%s\" "
-                             "(only \"relu\" is implemented)",
-                             hp.prompt_activation.c_str());
+                        "parakeet: unsupported prompt activation \"%s\" "
+                        "(only \"relu\" is implemented)",
+                        hp.prompt_activation.c_str());
                 return TRANSCRIBE_ERR_GGUF;
             }
             if (hp.prompt_hidden <= 0) {
-                log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                             "parakeet: prompt.hidden must be > 0 (got %d)",
-                             hp.prompt_hidden);
+                log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "parakeet: prompt.hidden must be > 0 (got %d)", hp.prompt_hidden);
                 return TRANSCRIBE_ERR_GGUF;
             }
             for (int32_t idx : hp.prompt_dictionary_indices) {
                 if (idx < 0 || idx >= hp.prompt_num_prompts) {
                     log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                                 "parakeet: prompt dictionary index %d out of range "
-                                 "[0, %d)", idx, hp.prompt_num_prompts);
+                            "parakeet: prompt dictionary index %d out of range "
+                            "[0, %d)",
+                            idx, hp.prompt_num_prompts);
                     return TRANSCRIBE_ERR_GGUF;
                 }
             }
-            if (hp.prompt_auto_id >= 0 &&
-                hp.prompt_auto_id >= hp.prompt_num_prompts)
-            {
-                log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                             "parakeet: prompt.auto_id %d out of range [0, %d)",
-                             hp.prompt_auto_id, hp.prompt_num_prompts);
+            if (hp.prompt_auto_id >= 0 && hp.prompt_auto_id >= hp.prompt_num_prompts) {
+                log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "parakeet: prompt.auto_id %d out of range [0, %d)",
+                        hp.prompt_auto_id, hp.prompt_num_prompts);
                 return TRANSCRIBE_ERR_GGUF;
             }
         }
@@ -415,17 +503,14 @@ transcribe_status read_parakeet_hparams(const gguf_context * gguf,
 
     // Cross-field invariants — caught here rather than surfacing as
     // confusing shape mismatches downstream.
-    if (hp.enc_n_layers <= 0 || hp.enc_d_model <= 0 || hp.enc_n_heads <= 0 ||
-        hp.enc_d_ff <= 0 || hp.enc_conv_kernel <= 0 ||
-        hp.enc_subsampling_factor <= 0 || hp.enc_subsampling_channels <= 0)
-    {
+    if (hp.enc_n_layers <= 0 || hp.enc_d_model <= 0 || hp.enc_n_heads <= 0 || hp.enc_d_ff <= 0 ||
+        hp.enc_conv_kernel <= 0 || hp.enc_subsampling_factor <= 0 || hp.enc_subsampling_channels <= 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "parakeet: encoder hparams must be positive");
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.enc_d_model % hp.enc_n_heads != 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "parakeet: encoder d_model (%d) not divisible by n_heads (%d)",
-                     hp.enc_d_model, hp.enc_n_heads);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "parakeet: encoder d_model (%d) not divisible by n_heads (%d)",
+                hp.enc_d_model, hp.enc_n_heads);
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.head_kind != HeadKind::CTC) {
@@ -439,14 +524,11 @@ transcribe_status read_parakeet_hparams(const gguf_context * gguf,
         }
         // Joint activation allow-list (the C++ joint forward implements
         // these three).
-        if (hp.joint_activation != "relu" &&
-            hp.joint_activation != "sigmoid" &&
-            hp.joint_activation != "tanh")
-        {
+        if (hp.joint_activation != "relu" && hp.joint_activation != "sigmoid" && hp.joint_activation != "tanh") {
             log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "parakeet: unsupported joint activation \"%s\" "
-                         "(only relu, sigmoid, tanh are implemented)",
-                         hp.joint_activation.c_str());
+                    "parakeet: unsupported joint activation \"%s\" "
+                    "(only relu, sigmoid, tanh are implemented)",
+                    hp.joint_activation.c_str());
             return TRANSCRIBE_ERR_GGUF;
         }
     }
@@ -455,67 +537,64 @@ transcribe_status read_parakeet_hparams(const gguf_context * gguf,
         // non-negative (negative jumps would walk backwards in time).
         if (hp.tdt_durations.empty()) {
             log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "parakeet: stt.parakeet.tdt.durations must be non-empty (head_kind=tdt)");
+                    "parakeet: stt.parakeet.tdt.durations must be non-empty (head_kind=tdt)");
             return TRANSCRIBE_ERR_GGUF;
         }
         if (static_cast<int32_t>(hp.tdt_durations.size()) != hp.joint_num_extra_outputs) {
             log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "parakeet: stt.parakeet.tdt.durations length (%zu) "
-                         "must equal joint.num_extra_outputs (%d)",
-                         hp.tdt_durations.size(), hp.joint_num_extra_outputs);
+                    "parakeet: stt.parakeet.tdt.durations length (%zu) "
+                    "must equal joint.num_extra_outputs (%d)",
+                    hp.tdt_durations.size(), hp.joint_num_extra_outputs);
             return TRANSCRIBE_ERR_GGUF;
         }
         for (int32_t d : hp.tdt_durations) {
             if (d < 0) {
                 log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                             "parakeet: stt.parakeet.tdt.durations contains "
-                             "negative value %d", d);
+                        "parakeet: stt.parakeet.tdt.durations contains "
+                        "negative value %d",
+                        d);
                 return TRANSCRIBE_ERR_GGUF;
             }
         }
         if (hp.tdt_max_symbols < 0) {
             log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "parakeet: stt.parakeet.tdt.max_symbols must be >= 0 "
-                         "(got %d)", hp.tdt_max_symbols);
+                    "parakeet: stt.parakeet.tdt.max_symbols must be >= 0 "
+                    "(got %d)",
+                    hp.tdt_max_symbols);
             return TRANSCRIBE_ERR_GGUF;
         }
     } else if (hp.head_kind == HeadKind::RNNT) {
         // RNNT joint emits exactly vocab+1 — no duration extras.
         if (hp.joint_num_extra_outputs != 0) {
             log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "parakeet: head_kind=rnnt requires joint.num_extra_outputs=0 "
-                         "(got %d)", hp.joint_num_extra_outputs);
+                    "parakeet: head_kind=rnnt requires joint.num_extra_outputs=0 "
+                    "(got %d)",
+                    hp.joint_num_extra_outputs);
             return TRANSCRIBE_ERR_GGUF;
         }
     }
-    if (hp.fe_num_mels <= 0 || hp.fe_sample_rate <= 0 ||
-        hp.fe_n_fft <= 0 || hp.fe_win_length <= 0 || hp.fe_hop_length <= 0)
-    {
+    if (hp.fe_num_mels <= 0 || hp.fe_sample_rate <= 0 || hp.fe_n_fft <= 0 || hp.fe_win_length <= 0 ||
+        hp.fe_hop_length <= 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "parakeet: frontend dimensions must be positive");
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.fe_win_length > hp.fe_n_fft) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "parakeet: frontend win_length (%d) > n_fft (%d)",
-                     hp.fe_win_length, hp.fe_n_fft);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "parakeet: frontend win_length (%d) > n_fft (%d)", hp.fe_win_length,
+                hp.fe_n_fft);
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.fe_f_min < 0.0f || hp.fe_f_max <= hp.fe_f_min) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "parakeet: frontend mel band invalid: f_min=%f f_max=%f",
-                     hp.fe_f_min, hp.fe_f_max);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "parakeet: frontend mel band invalid: f_min=%f f_max=%f", hp.fe_f_min,
+                hp.fe_f_max);
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.fe_dither < 0.0f) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "parakeet: frontend dither must be >= 0 (got %f)",
-                     hp.fe_dither);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "parakeet: frontend dither must be >= 0 (got %f)", hp.fe_dither);
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.fe_type != "mel") {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "parakeet: unsupported frontend type \"%s\" (only \"mel\")",
-                     hp.fe_type.c_str());
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "parakeet: unsupported frontend type \"%s\" (only \"mel\")",
+                hp.fe_type.c_str());
         return TRANSCRIBE_ERR_GGUF;
     }
 
@@ -527,9 +606,9 @@ transcribe_status read_parakeet_hparams(const gguf_context * gguf,
     // Window: only symmetric Hann is implemented.
     if (hp.fe_window != "hann") {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "parakeet: unsupported frontend window \"%s\" "
-                     "(only \"hann\" is implemented)",
-                     hp.fe_window.c_str());
+                "parakeet: unsupported frontend window \"%s\" "
+                "(only \"hann\" is implemented)",
+                hp.fe_window.c_str());
         return TRANSCRIBE_ERR_GGUF;
     }
 
@@ -538,9 +617,9 @@ transcribe_status read_parakeet_hparams(const gguf_context * gguf,
     // not implemented.
     if (hp.fe_normalize != "per_feature" && hp.fe_normalize != "none") {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "parakeet: unsupported frontend normalize \"%s\" "
-                     "(only \"per_feature\" and \"none\" are implemented)",
-                     hp.fe_normalize.c_str());
+                "parakeet: unsupported frontend normalize \"%s\" "
+                "(only \"per_feature\" and \"none\" are implemented)",
+                hp.fe_normalize.c_str());
         return TRANSCRIBE_ERR_GGUF;
     }
 
@@ -548,9 +627,9 @@ transcribe_status read_parakeet_hparams(const gguf_context * gguf,
     // whose bit-reversal produces garbage for non-power-of-two sizes.
     if ((hp.fe_n_fft & (hp.fe_n_fft - 1)) != 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "parakeet: frontend n_fft (%d) must be a power of 2 "
-                     "(radix-2 FFT requirement)",
-                     hp.fe_n_fft);
+                "parakeet: frontend n_fft (%d) must be a power of 2 "
+                "(radix-2 FFT requirement)",
+                hp.fe_n_fft);
         return TRANSCRIBE_ERR_GGUF;
     }
 
@@ -579,41 +658,38 @@ using transcribe::weights::lname;
 //              never produces a tensor the loader refuses).
 constexpr const char * kTag = kFamilyTag;
 
-#define GET_F32(slot, name, ...) \
-    do { \
-        ggml_tensor * _t = transcribe::weights::find_tensor( \
-            ctx_meta, (name), \
-            {GGML_TYPE_F32}, {__VA_ARGS__}, kTag); \
-        if (_t == nullptr) return TRANSCRIBE_ERR_GGUF; \
-        (slot) = _t; \
+#define GET_F32(slot, name, ...)                                                                          \
+    do {                                                                                                  \
+        ggml_tensor * _t =                                                                                \
+            transcribe::weights::find_tensor(ctx_meta, (name), { GGML_TYPE_F32 }, { __VA_ARGS__ }, kTag); \
+        if (_t == nullptr)                                                                                \
+            return TRANSCRIBE_ERR_GGUF;                                                                   \
+        (slot) = _t;                                                                                      \
     } while (0)
 
-#define GET_CONV(slot, name, ...) \
-    do { \
-        ggml_tensor * _t = transcribe::weights::find_tensor( \
-            ctx_meta, (name), \
-            {TRANSCRIBE_QUANT_CONV_TYPES}, \
-            {__VA_ARGS__}, kTag); \
-        if (_t == nullptr) return TRANSCRIBE_ERR_GGUF; \
-        (slot) = _t; \
+#define GET_CONV(slot, name, ...)                                                                              \
+    do {                                                                                                       \
+        ggml_tensor * _t = transcribe::weights::find_tensor(ctx_meta, (name), { TRANSCRIBE_QUANT_CONV_TYPES }, \
+                                                            { __VA_ARGS__ }, kTag);                            \
+        if (_t == nullptr)                                                                                     \
+            return TRANSCRIBE_ERR_GGUF;                                                                        \
+        (slot) = _t;                                                                                           \
     } while (0)
 
-#define GET_LIN(slot, name, ...) \
-    do { \
-        ggml_tensor * _t = transcribe::weights::find_tensor( \
-            ctx_meta, (name), \
-            {TRANSCRIBE_QUANT_LINEAR_TYPES}, \
-            {__VA_ARGS__}, kTag); \
-        if (_t == nullptr) return TRANSCRIBE_ERR_GGUF; \
-        (slot) = _t; \
+#define GET_LIN(slot, name, ...)                                                                                 \
+    do {                                                                                                         \
+        ggml_tensor * _t = transcribe::weights::find_tensor(ctx_meta, (name), { TRANSCRIBE_QUANT_LINEAR_TYPES }, \
+                                                            { __VA_ARGS__ }, kTag);                              \
+        if (_t == nullptr)                                                                                       \
+            return TRANSCRIBE_ERR_GGUF;                                                                          \
+        (slot) = _t;                                                                                             \
     } while (0)
 
-} // namespace
+}  // namespace
 
 transcribe_status build_parakeet_weights(ggml_context *          ctx_meta,
                                          const ParakeetHParams & hp,
-                                         ParakeetWeights &       weights)
-{
+                                         ParakeetWeights &       weights) {
     if (ctx_meta == nullptr) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
@@ -624,10 +700,10 @@ transcribe_status build_parakeet_weights(ggml_context *          ctx_meta,
     const int64_t n_heads  = hp.enc_n_heads;
     const int64_t head_dim = hp.enc_head_dim();
     const int64_t k        = hp.enc_conv_kernel;
-    const int64_t pred_h   = hp.pred_hidden;       // 0 for CTC
-    const int64_t pred_v   = hp.pred_vocab;        // 0 for CTC
-    const int64_t joint_h  = hp.joint_hidden;      // 0 for CTC
-    const int64_t joint_n  = hp.joint_n_classes(); // meaningless for CTC; we read CTC head shape instead
+    const int64_t pred_h   = hp.pred_hidden;        // 0 for CTC
+    const int64_t pred_v   = hp.pred_vocab;         // 0 for CTC
+    const int64_t joint_h  = hp.joint_hidden;       // 0 for CTC
+    const int64_t joint_n  = hp.joint_n_classes();  // meaningless for CTC; we read CTC head shape instead
 
     // The flattened "freq" axis into pre_encode.out is
     // (subsampling_channels * F'), where F' is the freq dim after three
@@ -637,15 +713,12 @@ transcribe_status build_parakeet_weights(ggml_context *          ctx_meta,
     //   non-causal: symmetric (k-1)/2 both sides. 128→64→32→16; 256*16=4096.
     //   causal:     (left=k-1, right=stride-1). 128→65→33→17; 256*17=4352.
     auto pre_encode_F_prime = [&]() {
-        const bool causal =
-            (hp.enc_att_context_style ==
-                 ParakeetHParams::AttContextStyle::ChunkedLimited);
-        const int k = 3, s = 2;
+        const bool causal = (hp.enc_att_context_style == ParakeetHParams::AttContextStyle::ChunkedLimited);
+        const int  k = 3, s = 2;
         // Total per-axis pad: (k-1)/2 + (k-1)/2 = k-1 = 2 for non-causal;
         // (k-1) + (s-1) = 3 for causal.
-        const int total_pad = causal ? ((k - 1) + (s - 1))
-                                     : ((k - 1) / 2 + (k - 1) / 2);
-        int dim = hp.fe_num_mels;
+        const int  total_pad = causal ? ((k - 1) + (s - 1)) : ((k - 1) / 2 + (k - 1) / 2);
+        int        dim       = hp.fe_num_mels;
         for (int i = 0; i < 3; ++i) {
             dim = ((dim + total_pad - k) / s) + 1;
         }
@@ -658,18 +731,18 @@ transcribe_status build_parakeet_weights(ggml_context *          ctx_meta,
     // Conv shapes documented in weights.h. ggml_tensor::ne is fast-to-
     // slow dim order; for an OIHW conv kernel that's [kw, kh, in, out].
     // 1×1 pointwise convs collapse to [1, 1, in, out].
-    GET_CONV(weights.pre_encode.conv0_w, "enc.pre_encode.conv.0.weight", 3, 3, 1,        channels);
-    GET_F32 (weights.pre_encode.conv0_b, "enc.pre_encode.conv.0.bias", channels);
-    GET_CONV(weights.pre_encode.conv2_w, "enc.pre_encode.conv.2.weight", 3, 3, 1,        channels);
-    GET_F32 (weights.pre_encode.conv2_b, "enc.pre_encode.conv.2.bias", channels);
+    GET_CONV(weights.pre_encode.conv0_w, "enc.pre_encode.conv.0.weight", 3, 3, 1, channels);
+    GET_F32(weights.pre_encode.conv0_b, "enc.pre_encode.conv.0.bias", channels);
+    GET_CONV(weights.pre_encode.conv2_w, "enc.pre_encode.conv.2.weight", 3, 3, 1, channels);
+    GET_F32(weights.pre_encode.conv2_b, "enc.pre_encode.conv.2.bias", channels);
     GET_CONV(weights.pre_encode.conv3_w, "enc.pre_encode.conv.3.weight", 1, 1, channels, channels);
-    GET_F32 (weights.pre_encode.conv3_b, "enc.pre_encode.conv.3.bias", channels);
-    GET_CONV(weights.pre_encode.conv5_w, "enc.pre_encode.conv.5.weight", 3, 3, 1,        channels);
-    GET_F32 (weights.pre_encode.conv5_b, "enc.pre_encode.conv.5.bias", channels);
+    GET_F32(weights.pre_encode.conv3_b, "enc.pre_encode.conv.3.bias", channels);
+    GET_CONV(weights.pre_encode.conv5_w, "enc.pre_encode.conv.5.weight", 3, 3, 1, channels);
+    GET_F32(weights.pre_encode.conv5_b, "enc.pre_encode.conv.5.bias", channels);
     GET_CONV(weights.pre_encode.conv6_w, "enc.pre_encode.conv.6.weight", 1, 1, channels, channels);
-    GET_F32 (weights.pre_encode.conv6_b, "enc.pre_encode.conv.6.bias", channels);
-    GET_LIN (weights.pre_encode.out_w,   "enc.pre_encode.out.weight", pre_encode_in, d_model);
-    GET_F32 (weights.pre_encode.out_b,   "enc.pre_encode.out.bias", d_model);
+    GET_F32(weights.pre_encode.conv6_b, "enc.pre_encode.conv.6.bias", channels);
+    GET_LIN(weights.pre_encode.out_w, "enc.pre_encode.out.weight", pre_encode_in, d_model);
+    GET_F32(weights.pre_encode.out_b, "enc.pre_encode.out.bias", d_model);
 
     // ----- encoder blocks -----
     weights.blocks.assign(hp.enc_n_layers, ParakeetBlock{});
@@ -678,64 +751,64 @@ transcribe_status build_parakeet_weights(ggml_context *          ctx_meta,
 
         // Macaron FF1.
         GET_F32(b.norm_ff1_w, lname("enc.blocks.%d.norm_ff1.weight", i), d_model);
-        GET_F32(b.norm_ff1_b, lname("enc.blocks.%d.norm_ff1.bias",   i), d_model);
+        GET_F32(b.norm_ff1_b, lname("enc.blocks.%d.norm_ff1.bias", i), d_model);
         GET_LIN(b.ff1_lin1_w, lname("enc.blocks.%d.ff1.linear1.weight", i), d_model, d_ff);
-        GET_LIN(b.ff1_lin2_w, lname("enc.blocks.%d.ff1.linear2.weight", i), d_ff,    d_model);
+        GET_LIN(b.ff1_lin2_w, lname("enc.blocks.%d.ff1.linear2.weight", i), d_ff, d_model);
 
         // Self-attention with relative position. Q/K/V/out biases only
         // when use_bias=true; linear_pos is bias-free even then.
         GET_F32(b.norm_attn_w, lname("enc.blocks.%d.norm_attn.weight", i), d_model);
-        GET_F32(b.norm_attn_b, lname("enc.blocks.%d.norm_attn.bias",   i), d_model);
-        GET_LIN(b.attn_q_w,    lname("enc.blocks.%d.attn.linear_q.weight",   i), d_model, d_model);
-        GET_LIN(b.attn_k_w,    lname("enc.blocks.%d.attn.linear_k.weight",   i), d_model, d_model);
-        GET_LIN(b.attn_v_w,    lname("enc.blocks.%d.attn.linear_v.weight",   i), d_model, d_model);
-        GET_LIN(b.attn_out_w,  lname("enc.blocks.%d.attn.linear_out.weight", i), d_model, d_model);
-        GET_LIN(b.attn_pos_w,  lname("enc.blocks.%d.attn.linear_pos.weight", i), d_model, d_model);
+        GET_F32(b.norm_attn_b, lname("enc.blocks.%d.norm_attn.bias", i), d_model);
+        GET_LIN(b.attn_q_w, lname("enc.blocks.%d.attn.linear_q.weight", i), d_model, d_model);
+        GET_LIN(b.attn_k_w, lname("enc.blocks.%d.attn.linear_k.weight", i), d_model, d_model);
+        GET_LIN(b.attn_v_w, lname("enc.blocks.%d.attn.linear_v.weight", i), d_model, d_model);
+        GET_LIN(b.attn_out_w, lname("enc.blocks.%d.attn.linear_out.weight", i), d_model, d_model);
+        GET_LIN(b.attn_pos_w, lname("enc.blocks.%d.attn.linear_pos.weight", i), d_model, d_model);
         // pos_bias_u/v are added directly to a fp32 q tensor via
         // ggml_add — must stay fp32 to avoid a mixed-type broadcast.
-        GET_F32(b.attn_pos_u,  lname("enc.blocks.%d.attn.pos_bias_u",        i), head_dim, n_heads);
-        GET_F32(b.attn_pos_v,  lname("enc.blocks.%d.attn.pos_bias_v",        i), head_dim, n_heads);
+        GET_F32(b.attn_pos_u, lname("enc.blocks.%d.attn.pos_bias_u", i), head_dim, n_heads);
+        GET_F32(b.attn_pos_v, lname("enc.blocks.%d.attn.pos_bias_v", i), head_dim, n_heads);
 
         // Conv module. pointwise1 doubles the channel count for the
         // GLU split; depthwise has groups=d_model so its weight is
         // [kernel, 1, d_model] in ggml ne order. pointwise2 collapses
         // back to d_model.
-        GET_F32 (b.norm_conv_w, lname("enc.blocks.%d.norm_conv.weight", i), d_model);
-        GET_F32 (b.norm_conv_b, lname("enc.blocks.%d.norm_conv.bias",   i), d_model);
-        GET_CONV(b.conv_pw1_w,  lname("enc.blocks.%d.conv.pointwise1.weight", i), 1, d_model, 2 * d_model);
-        GET_CONV(b.conv_dw_w,   lname("enc.blocks.%d.conv.depthwise.weight",  i), k, 1,       d_model);
-        GET_CONV(b.conv_pw2_w,  lname("enc.blocks.%d.conv.pointwise2.weight", i), 1, d_model, d_model);
-        GET_F32 (b.conv_bn_w,   lname("enc.blocks.%d.conv.bn.weight",       i), d_model);
-        GET_F32 (b.conv_bn_b,   lname("enc.blocks.%d.conv.bn.bias",         i), d_model);
+        GET_F32(b.norm_conv_w, lname("enc.blocks.%d.norm_conv.weight", i), d_model);
+        GET_F32(b.norm_conv_b, lname("enc.blocks.%d.norm_conv.bias", i), d_model);
+        GET_CONV(b.conv_pw1_w, lname("enc.blocks.%d.conv.pointwise1.weight", i), 1, d_model, 2 * d_model);
+        GET_CONV(b.conv_dw_w, lname("enc.blocks.%d.conv.depthwise.weight", i), k, 1, d_model);
+        GET_CONV(b.conv_pw2_w, lname("enc.blocks.%d.conv.pointwise2.weight", i), 1, d_model, d_model);
+        GET_F32(b.conv_bn_w, lname("enc.blocks.%d.conv.bn.weight", i), d_model);
+        GET_F32(b.conv_bn_b, lname("enc.blocks.%d.conv.bn.bias", i), d_model);
         if (hp.enc_conv_norm_type == ParakeetHParams::ConvNormType::BatchNorm) {
-            GET_F32 (b.conv_bn_rm, lname("enc.blocks.%d.conv.bn.running_mean", i), d_model);
-            GET_F32 (b.conv_bn_rv, lname("enc.blocks.%d.conv.bn.running_var",  i), d_model);
+            GET_F32(b.conv_bn_rm, lname("enc.blocks.%d.conv.bn.running_mean", i), d_model);
+            GET_F32(b.conv_bn_rv, lname("enc.blocks.%d.conv.bn.running_var", i), d_model);
         }
 
         // Macaron FF2.
         GET_F32(b.norm_ff2_w, lname("enc.blocks.%d.norm_ff2.weight", i), d_model);
-        GET_F32(b.norm_ff2_b, lname("enc.blocks.%d.norm_ff2.bias",   i), d_model);
+        GET_F32(b.norm_ff2_b, lname("enc.blocks.%d.norm_ff2.bias", i), d_model);
         GET_LIN(b.ff2_lin1_w, lname("enc.blocks.%d.ff2.linear1.weight", i), d_model, d_ff);
-        GET_LIN(b.ff2_lin2_w, lname("enc.blocks.%d.ff2.linear2.weight", i), d_ff,    d_model);
+        GET_LIN(b.ff2_lin2_w, lname("enc.blocks.%d.ff2.linear2.weight", i), d_ff, d_model);
 
         // Final per-block layer norm.
         GET_F32(b.norm_out_w, lname("enc.blocks.%d.norm_out.weight", i), d_model);
-        GET_F32(b.norm_out_b, lname("enc.blocks.%d.norm_out.bias",   i), d_model);
+        GET_F32(b.norm_out_b, lname("enc.blocks.%d.norm_out.bias", i), d_model);
 
         // Optional encoder linear/conv biases (use_bias=true only;
         // linear_pos has no bias slot).
         if (hp.enc_use_bias) {
-            GET_F32(b.ff1_lin1_b,  lname("enc.blocks.%d.ff1.linear1.bias",      i), d_ff);
-            GET_F32(b.ff1_lin2_b,  lname("enc.blocks.%d.ff1.linear2.bias",      i), d_model);
-            GET_F32(b.attn_q_b,    lname("enc.blocks.%d.attn.linear_q.bias",    i), d_model);
-            GET_F32(b.attn_k_b,    lname("enc.blocks.%d.attn.linear_k.bias",    i), d_model);
-            GET_F32(b.attn_v_b,    lname("enc.blocks.%d.attn.linear_v.bias",    i), d_model);
-            GET_F32(b.attn_out_b,  lname("enc.blocks.%d.attn.linear_out.bias",  i), d_model);
-            GET_F32(b.conv_pw1_b,  lname("enc.blocks.%d.conv.pointwise1.bias", i), 2 * d_model);
-            GET_F32(b.conv_dw_b,   lname("enc.blocks.%d.conv.depthwise.bias",  i), d_model);
-            GET_F32(b.conv_pw2_b,  lname("enc.blocks.%d.conv.pointwise2.bias", i), d_model);
-            GET_F32(b.ff2_lin1_b,  lname("enc.blocks.%d.ff2.linear1.bias",      i), d_ff);
-            GET_F32(b.ff2_lin2_b,  lname("enc.blocks.%d.ff2.linear2.bias",      i), d_model);
+            GET_F32(b.ff1_lin1_b, lname("enc.blocks.%d.ff1.linear1.bias", i), d_ff);
+            GET_F32(b.ff1_lin2_b, lname("enc.blocks.%d.ff1.linear2.bias", i), d_model);
+            GET_F32(b.attn_q_b, lname("enc.blocks.%d.attn.linear_q.bias", i), d_model);
+            GET_F32(b.attn_k_b, lname("enc.blocks.%d.attn.linear_k.bias", i), d_model);
+            GET_F32(b.attn_v_b, lname("enc.blocks.%d.attn.linear_v.bias", i), d_model);
+            GET_F32(b.attn_out_b, lname("enc.blocks.%d.attn.linear_out.bias", i), d_model);
+            GET_F32(b.conv_pw1_b, lname("enc.blocks.%d.conv.pointwise1.bias", i), 2 * d_model);
+            GET_F32(b.conv_dw_b, lname("enc.blocks.%d.conv.depthwise.bias", i), d_model);
+            GET_F32(b.conv_pw2_b, lname("enc.blocks.%d.conv.pointwise2.bias", i), d_model);
+            GET_F32(b.ff2_lin1_b, lname("enc.blocks.%d.ff2.linear1.bias", i), d_ff);
+            GET_F32(b.ff2_lin2_b, lname("enc.blocks.%d.ff2.linear2.bias", i), d_model);
         }
     }
 
@@ -752,51 +825,48 @@ transcribe_status build_parakeet_weights(ggml_context *          ctx_meta,
         }
         const int64_t n_classes = ctc_peek->ne[2];
         if (n_classes <= 1) {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "parakeet: head.ctc.weight vocab+1 (=%lld) must be > 1",
-                         (long long)n_classes);
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "parakeet: head.ctc.weight vocab+1 (=%lld) must be > 1",
+                    (long long) n_classes);
             return TRANSCRIBE_ERR_GGUF;
         }
         GET_LIN(weights.ctc_head.weight, "head.ctc.weight", 1, d_model, n_classes);
-        GET_F32(weights.ctc_head.bias,   "head.ctc.bias",   n_classes);
+        GET_F32(weights.ctc_head.bias, "head.ctc.bias", n_classes);
         // Stash the resolved vocab+1 into hp. const_cast is safe: the
         // loader is the single producer of hp, writable while loading.
-        const_cast<ParakeetHParams &>(hp).head_ctc_n_classes =
-            static_cast<int32_t>(n_classes);
+        const_cast<ParakeetHParams &>(hp).head_ctc_n_classes = static_cast<int32_t>(n_classes);
     } else {
         // ----- predictor (TDT, RNNT) -----
         GET_LIN(weights.predictor.embed_w, "pred.embed.weight", pred_h, pred_v);
 
         weights.predictor.lstm.assign(hp.pred_n_layers, ParakeetPredictor::LstmLayer{});
         for (int i = 0; i < hp.pred_n_layers; ++i) {
-            auto & l = weights.predictor.lstm[i];
+            auto &        l     = weights.predictor.lstm[i];
             // Wx/Wh both project from pred_hidden; 4*hidden output =
             // concatenated (i, f, g, o) gates.
             const int64_t gates = 4 * pred_h;
-            GET_LIN(l.Wx, lname("pred.lstm.%d.Wx",   i), pred_h, gates);
-            GET_LIN(l.Wh, lname("pred.lstm.%d.Wh",   i), pred_h, gates);
-            GET_F32(l.b,  lname("pred.lstm.%d.bias", i), gates);
+            GET_LIN(l.Wx, lname("pred.lstm.%d.Wx", i), pred_h, gates);
+            GET_LIN(l.Wh, lname("pred.lstm.%d.Wh", i), pred_h, gates);
+            GET_F32(l.b, lname("pred.lstm.%d.bias", i), gates);
         }
 
         // ----- joint (TDT, RNNT) -----
-        GET_LIN(weights.joint.enc_w,  "joint.enc.weight", d_model, joint_h);
-        GET_F32(weights.joint.enc_b,  "joint.enc.bias", joint_h);
-        GET_LIN(weights.joint.pred_w, "joint.pred.weight", pred_h,  joint_h);
+        GET_LIN(weights.joint.enc_w, "joint.enc.weight", d_model, joint_h);
+        GET_F32(weights.joint.enc_b, "joint.enc.bias", joint_h);
+        GET_LIN(weights.joint.pred_w, "joint.pred.weight", pred_h, joint_h);
         GET_F32(weights.joint.pred_b, "joint.pred.bias", joint_h);
-        GET_LIN(weights.joint.out_w,  "joint.out.weight", joint_h, joint_n);
-        GET_F32(weights.joint.out_b,  "joint.out.bias", joint_n);
+        GET_LIN(weights.joint.out_w, "joint.out.weight", joint_h, joint_n);
+        GET_F32(weights.joint.out_b, "joint.out.bias", joint_n);
     }
 
     // ----- prompt MLP (multilingual variants, has_prompt only) -----
     // PyTorch nn.Sequential indexing preserved (.0 input, .2 output).
     if (hp.has_prompt) {
         const int64_t prompt_h = hp.prompt_hidden;
-        const int64_t in_dim   = static_cast<int64_t>(d_model) +
-                                 static_cast<int64_t>(hp.prompt_num_prompts);
-        GET_LIN(weights.prompt.mlp0_w, "prompt.mlp.0.weight", in_dim,   prompt_h);
-        GET_F32(weights.prompt.mlp0_b, "prompt.mlp.0.bias",   prompt_h);
+        const int64_t in_dim   = static_cast<int64_t>(d_model) + static_cast<int64_t>(hp.prompt_num_prompts);
+        GET_LIN(weights.prompt.mlp0_w, "prompt.mlp.0.weight", in_dim, prompt_h);
+        GET_F32(weights.prompt.mlp0_b, "prompt.mlp.0.bias", prompt_h);
         GET_LIN(weights.prompt.mlp2_w, "prompt.mlp.2.weight", prompt_h, d_model);
-        GET_F32(weights.prompt.mlp2_b, "prompt.mlp.2.bias",   d_model);
+        GET_F32(weights.prompt.mlp2_b, "prompt.mlp.2.bias", d_model);
     }
 
     return TRANSCRIBE_OK;
@@ -806,4 +876,4 @@ transcribe_status build_parakeet_weights(ggml_context *          ctx_meta,
 #undef GET_CONV
 #undef GET_LIN
 
-} // namespace transcribe::parakeet
+}  // namespace transcribe::parakeet
diff --git a/src/arch/parakeet/weights.h b/src/arch/parakeet/weights.h
index 0b4511a4..b6e291ee 100644
--- a/src/arch/parakeet/weights.h
+++ b/src/arch/parakeet/weights.h
@@ -51,19 +51,19 @@ struct ParakeetHParams {
     HeadKind head_kind = HeadKind::TDT;
 
     // Encoder (Conformer).
-    int32_t enc_n_layers          = 0;
-    int32_t enc_d_model           = 0;
-    int32_t enc_n_heads           = 0;
-    int32_t enc_d_ff              = 0; // d_model * ff_expansion_factor
-    int32_t enc_conv_kernel       = 0; // depthwise conv kernel inside the Conformer block
-    int32_t enc_subsampling_factor   = 0; // total downsampling on the time axis
-    int32_t enc_subsampling_channels = 0; // intermediate channel count in pre_encode
-    int32_t enc_pos_emb_max_len   = 0;
-    bool    enc_use_bias          = false;
+    int32_t enc_n_layers             = 0;
+    int32_t enc_d_model              = 0;
+    int32_t enc_n_heads              = 0;
+    int32_t enc_d_ff                 = 0;  // d_model * ff_expansion_factor
+    int32_t enc_conv_kernel          = 0;  // depthwise conv kernel inside the Conformer block
+    int32_t enc_subsampling_factor   = 0;  // total downsampling on the time axis
+    int32_t enc_subsampling_channels = 0;  // intermediate channel count in pre_encode
+    int32_t enc_pos_emb_max_len      = 0;
+    bool    enc_use_bias             = false;
     // NeMo's RelPositionalEncoding multiplies x by sqrt(d_model) when
     // xscaling=True. Default false so legacy GGUFs (v2/v3, xscaling=False)
     // keep working unchanged.
-    bool    enc_xscaling          = false;
+    bool    enc_xscaling             = false;
     // Local attention window. -1/-1 = full attention (most variants).
     // When non-negative, each query attends to keys within [left, right]
     // per enc_att_context_style below:
@@ -73,8 +73,8 @@ struct ParakeetHParams {
     //   ChunkedLimited — full RelPositionalEncoding (pos_emb 2T-1) plus a
     //     host-side chunked mask; chunk_size = right+1, left_chunks =
     //     left/chunk_size. nemotron-speech-streaming-en-0.6b ([70, 13]).
-    int32_t enc_att_context_left  = -1;
-    int32_t enc_att_context_right = -1;
+    int32_t enc_att_context_left     = -1;
+    int32_t enc_att_context_right    = -1;
 
     // Multi-lookahead training menu for cache-aware streaming models. A
     // flat GGUF int32 array [L0,R0,L1,R1,...]; index 0 is the default
@@ -144,12 +144,12 @@ struct ParakeetHParams {
     // Predictor (RNN-T prediction network). TDT and RNNT only; zero for CTC.
     int32_t pred_hidden   = 0;
     int32_t pred_n_layers = 0;
-    int32_t pred_vocab    = 0; // includes the +1 "start" / blank-row entry of the embed matrix
-                               // (raw token vocab size is pred_vocab - 1)
+    int32_t pred_vocab    = 0;  // includes the +1 "start" / blank-row entry of the embed matrix
+                                // (raw token vocab size is pred_vocab - 1)
 
     // Joint network. TDT and RNNT only; zero for CTC.
-    int32_t joint_hidden            = 0;
-    int32_t joint_num_extra_outputs = 0; // TDT durations count; 0 for RNNT
+    int32_t     joint_hidden            = 0;
+    int32_t     joint_num_extra_outputs = 0;  // TDT durations count; 0 for RNNT
     // Joint output activation (stt.parakeet.joint.activation), validated
     // against the C++ joint forward's allow-list at load. v2/v3 ship
     // "relu". Read so the C++ side doesn't hard-code an activation and
@@ -172,14 +172,14 @@ struct ParakeetHParams {
     // the converter emits and the C++ frontend reads; the loader gates on
     // it. CMVN/LFR fields are omitted (no published Parakeet variant uses
     // them).
-    std::string fe_type;          // "mel" for parakeet
+    std::string fe_type;  // "mel" for parakeet
     int32_t     fe_num_mels    = 0;
     int32_t     fe_sample_rate = 0;
     int32_t     fe_n_fft       = 0;
-    int32_t     fe_win_length  = 0;  // samples
-    int32_t     fe_hop_length  = 0;  // samples
-    std::string fe_window;        // "hann" for parakeet
-    std::string fe_normalize;     // "per_feature" for parakeet
+    int32_t     fe_win_length  = 0;      // samples
+    int32_t     fe_hop_length  = 0;      // samples
+    std::string fe_window;               // "hann" for parakeet
+    std::string fe_normalize;            // "per_feature" for parakeet
     float       fe_dither       = 0.0f;
     float       fe_pre_emphasis = 0.0f;  // 0.0 == disabled
     float       fe_f_min        = 0.0f;
@@ -200,25 +200,25 @@ struct ParakeetHParams {
     //   enc_out := y
     // Gated on has_prompt (stt.parakeet.prompt.num_prompts present).
     // Today: nemotron-3.5-asr-streaming-0.6b.
-    bool                       has_prompt              = false;
-    int32_t                    prompt_num_prompts      = 0;
-    int32_t                    prompt_hidden           = 0;
-    std::string                prompt_field;
-    std::string                prompt_activation;
-    std::vector<std::string>   prompt_dictionary_locales;
-    std::vector<int32_t>       prompt_dictionary_indices;
-    int32_t                    prompt_auto_id          = -1;
+    bool                     has_prompt         = false;
+    int32_t                  prompt_num_prompts = 0;
+    int32_t                  prompt_hidden      = 0;
+    std::string              prompt_field;
+    std::string              prompt_activation;
+    std::vector<std::string> prompt_dictionary_locales;
+    std::vector<int32_t>     prompt_dictionary_indices;
+    int32_t                  prompt_auto_id = -1;
 
     // Derived. Convenience accessors keyed off the above.
     int32_t enc_head_dim() const { return enc_n_heads > 0 ? enc_d_model / enc_n_heads : 0; }
+
     int32_t joint_n_classes() const { return (pred_vocab - 1) + joint_num_extra_outputs + 1; }
 };
 
 // Read every required stt.parakeet.* / stt.frontend.* KV into hp.
 // Returns INVALID_ARG if gguf is null, ERR_GGUF on a missing/wrong-type
 // key or a cross-field invariant failure (e.g. d_model % n_heads != 0).
-transcribe_status read_parakeet_hparams(const gguf_context * gguf,
-                                        ParakeetHParams &    hp);
+transcribe_status read_parakeet_hparams(const gguf_context * gguf, ParakeetHParams & hp);
 
 // Weight slots. Every ggml_tensor* below is borrowed into the model's
 // ggml_context and is invalidated when the model is freed.
@@ -227,16 +227,16 @@ struct ParakeetPreEncode {
     // dw_striding subsampling: 1 standard conv + 2 depthwise-separable
     // conv pairs = 8x time downsampling. Indices follow NeMo's
     // torch.nn.Sequential (1 and 4 are activation modules, skipped).
-    ggml_tensor * conv0_w = nullptr; // [out=channels,        in=1,        kh=3, kw=3]
-    ggml_tensor * conv0_b = nullptr; // [channels]
-    ggml_tensor * conv2_w = nullptr; // [out=channels,        in=1 (dw),   kh=3, kw=3]
-    ggml_tensor * conv2_b = nullptr; // [channels]
-    ggml_tensor * conv3_w = nullptr; // [out=channels,        in=channels, kh=1, kw=1]
-    ggml_tensor * conv3_b = nullptr; // [channels]
-    ggml_tensor * conv5_w = nullptr; // [out=channels,        in=1 (dw),   kh=3, kw=3]
-    ggml_tensor * conv5_b = nullptr; // [channels]
-    ggml_tensor * conv6_w = nullptr; // [out=channels,        in=channels, kh=1, kw=1]
-    ggml_tensor * conv6_b = nullptr; // [channels]
+    ggml_tensor * conv0_w = nullptr;  // [out=channels,        in=1,        kh=3, kw=3]
+    ggml_tensor * conv0_b = nullptr;  // [channels]
+    ggml_tensor * conv2_w = nullptr;  // [out=channels,        in=1 (dw),   kh=3, kw=3]
+    ggml_tensor * conv2_b = nullptr;  // [channels]
+    ggml_tensor * conv3_w = nullptr;  // [out=channels,        in=channels, kh=1, kw=1]
+    ggml_tensor * conv3_b = nullptr;  // [channels]
+    ggml_tensor * conv5_w = nullptr;  // [out=channels,        in=1 (dw),   kh=3, kw=3]
+    ggml_tensor * conv5_b = nullptr;  // [channels]
+    ggml_tensor * conv6_w = nullptr;  // [out=channels,        in=channels, kh=1, kw=1]
+    ggml_tensor * conv6_b = nullptr;  // [channels]
     // Final projection from flattened [channels * (num_mels / subsampling)] to d_model.
     ggml_tensor * out_w   = nullptr;
     ggml_tensor * out_b   = nullptr;
@@ -247,90 +247,93 @@ struct ParakeetPreEncode {
 // populated only when enc_use_bias=true; null for the v2/v3 baseline.
 struct ParakeetBlock {
     // Macaron feed-forward 1.
-    ggml_tensor * norm_ff1_w = nullptr; // [d_model]
-    ggml_tensor * norm_ff1_b = nullptr; // [d_model]
-    ggml_tensor * ff1_lin1_w = nullptr; // [d_ff,    d_model]
-    ggml_tensor * ff1_lin1_b = nullptr; // [d_ff],    nullable (use_bias)
-    ggml_tensor * ff1_lin2_w = nullptr; // [d_model, d_ff]
-    ggml_tensor * ff1_lin2_b = nullptr; // [d_model], nullable (use_bias)
+    ggml_tensor * norm_ff1_w = nullptr;  // [d_model]
+    ggml_tensor * norm_ff1_b = nullptr;  // [d_model]
+    ggml_tensor * ff1_lin1_w = nullptr;  // [d_ff,    d_model]
+    ggml_tensor * ff1_lin1_b = nullptr;  // [d_ff],    nullable (use_bias)
+    ggml_tensor * ff1_lin2_w = nullptr;  // [d_model, d_ff]
+    ggml_tensor * ff1_lin2_b = nullptr;  // [d_model], nullable (use_bias)
 
     // Self-attention with relative positional encoding.
-    ggml_tensor * norm_attn_w  = nullptr; // [d_model]
-    ggml_tensor * norm_attn_b  = nullptr; // [d_model]
-    ggml_tensor * attn_q_w     = nullptr; // [d_model, d_model]
-    ggml_tensor * attn_q_b     = nullptr; // [d_model], nullable (use_bias)
-    ggml_tensor * attn_k_w     = nullptr; // [d_model, d_model]
-    ggml_tensor * attn_k_b     = nullptr; // [d_model], nullable (use_bias)
-    ggml_tensor * attn_v_w     = nullptr; // [d_model, d_model]
-    ggml_tensor * attn_v_b     = nullptr; // [d_model], nullable (use_bias)
-    ggml_tensor * attn_out_w   = nullptr; // [d_model, d_model]
-    ggml_tensor * attn_out_b   = nullptr; // [d_model], nullable (use_bias)
-    ggml_tensor * attn_pos_w   = nullptr; // [d_model, d_model]   (linear_pos is bias-free in NeMo even when use_bias=true)
-    ggml_tensor * attn_pos_u   = nullptr; // [n_heads, head_dim]   learned rel-pos bias u
-    ggml_tensor * attn_pos_v   = nullptr; // [n_heads, head_dim]   learned rel-pos bias v
+    ggml_tensor * norm_attn_w = nullptr;  // [d_model]
+    ggml_tensor * norm_attn_b = nullptr;  // [d_model]
+    ggml_tensor * attn_q_w    = nullptr;  // [d_model, d_model]
+    ggml_tensor * attn_q_b    = nullptr;  // [d_model], nullable (use_bias)
+    ggml_tensor * attn_k_w    = nullptr;  // [d_model, d_model]
+    ggml_tensor * attn_k_b    = nullptr;  // [d_model], nullable (use_bias)
+    ggml_tensor * attn_v_w    = nullptr;  // [d_model, d_model]
+    ggml_tensor * attn_v_b    = nullptr;  // [d_model], nullable (use_bias)
+    ggml_tensor * attn_out_w  = nullptr;  // [d_model, d_model]
+    ggml_tensor * attn_out_b  = nullptr;  // [d_model], nullable (use_bias)
+    ggml_tensor * attn_pos_w =
+        nullptr;  // [d_model, d_model]   (linear_pos is bias-free in NeMo even when use_bias=true)
+    ggml_tensor * attn_pos_u = nullptr;  // [n_heads, head_dim]   learned rel-pos bias u
+    ggml_tensor * attn_pos_v = nullptr;  // [n_heads, head_dim]   learned rel-pos bias v
 
     // Convolution module: pointwise -> GLU -> depthwise -> BN -> activation -> pointwise.
-    ggml_tensor * norm_conv_w  = nullptr; // [d_model]
-    ggml_tensor * norm_conv_b  = nullptr; // [d_model]
-    ggml_tensor * conv_pw1_w   = nullptr; // [2*d_model, d_model, 1]   conv1d k=1; 2x for GLU
-    ggml_tensor * conv_pw1_b   = nullptr; // [2*d_model], nullable (use_bias)
-    ggml_tensor * conv_dw_w    = nullptr; // [d_model,   1,       k]   depthwise conv1d
-    ggml_tensor * conv_dw_b    = nullptr; // [d_model],   nullable (use_bias)
-    ggml_tensor * conv_pw2_w   = nullptr; // [d_model,   d_model, 1]   conv1d k=1
-    ggml_tensor * conv_pw2_b   = nullptr; // [d_model],   nullable (use_bias)
-    ggml_tensor * conv_bn_w    = nullptr; // [d_model]   BN scale
-    ggml_tensor * conv_bn_b    = nullptr; // [d_model]   BN shift
-    ggml_tensor * conv_bn_rm   = nullptr; // [d_model]   running_mean
-    ggml_tensor * conv_bn_rv   = nullptr; // [d_model]   running_var
+    ggml_tensor * norm_conv_w = nullptr;  // [d_model]
+    ggml_tensor * norm_conv_b = nullptr;  // [d_model]
+    ggml_tensor * conv_pw1_w  = nullptr;  // [2*d_model, d_model, 1]   conv1d k=1; 2x for GLU
+    ggml_tensor * conv_pw1_b  = nullptr;  // [2*d_model], nullable (use_bias)
+    ggml_tensor * conv_dw_w   = nullptr;  // [d_model,   1,       k]   depthwise conv1d
+    ggml_tensor * conv_dw_b   = nullptr;  // [d_model],   nullable (use_bias)
+    ggml_tensor * conv_pw2_w  = nullptr;  // [d_model,   d_model, 1]   conv1d k=1
+    ggml_tensor * conv_pw2_b  = nullptr;  // [d_model],   nullable (use_bias)
+    ggml_tensor * conv_bn_w   = nullptr;  // [d_model]   BN scale
+    ggml_tensor * conv_bn_b   = nullptr;  // [d_model]   BN shift
+    ggml_tensor * conv_bn_rm  = nullptr;  // [d_model]   running_mean
+    ggml_tensor * conv_bn_rv  = nullptr;  // [d_model]   running_var
 
     // Fused BN parameters (computed at load time, replaces batch_norm()
     // in the graph with a single mul + add):
     //   fused_scale = bn_w / sqrt(bn_rv + eps)
     //   fused_bias  = bn_b - bn_rm * fused_scale
-    ggml_tensor * conv_bn_fused_scale = nullptr; // [d_model]
-    ggml_tensor * conv_bn_fused_bias  = nullptr; // [d_model]
+    ggml_tensor * conv_bn_fused_scale = nullptr;  // [d_model]
+    ggml_tensor * conv_bn_fused_bias  = nullptr;  // [d_model]
 
     // Macaron feed-forward 2.
-    ggml_tensor * norm_ff2_w = nullptr; // [d_model]
-    ggml_tensor * norm_ff2_b = nullptr; // [d_model]
-    ggml_tensor * ff2_lin1_w = nullptr; // [d_ff,    d_model]
-    ggml_tensor * ff2_lin1_b = nullptr; // [d_ff],    nullable (use_bias)
-    ggml_tensor * ff2_lin2_w = nullptr; // [d_model, d_ff]
-    ggml_tensor * ff2_lin2_b = nullptr; // [d_model], nullable (use_bias)
+    ggml_tensor * norm_ff2_w = nullptr;  // [d_model]
+    ggml_tensor * norm_ff2_b = nullptr;  // [d_model]
+    ggml_tensor * ff2_lin1_w = nullptr;  // [d_ff,    d_model]
+    ggml_tensor * ff2_lin1_b = nullptr;  // [d_ff],    nullable (use_bias)
+    ggml_tensor * ff2_lin2_w = nullptr;  // [d_model, d_ff]
+    ggml_tensor * ff2_lin2_b = nullptr;  // [d_model], nullable (use_bias)
 
     // Final per-block layer norm.
-    ggml_tensor * norm_out_w = nullptr; // [d_model]
-    ggml_tensor * norm_out_b = nullptr; // [d_model]
+    ggml_tensor * norm_out_w = nullptr;  // [d_model]
+    ggml_tensor * norm_out_b = nullptr;  // [d_model]
 };
 
 struct ParakeetPredictor {
     // Token embedding; the +1 row is NeMo's "start of sequence" embedding.
-    ggml_tensor * embed_w = nullptr; // [pred_vocab, pred_hidden]
+    ggml_tensor * embed_w = nullptr;  // [pred_vocab, pred_hidden]
 
     // 2-layer LSTM (v2/v3 0.6b). Concatenated gate weights in PyTorch
     // (i, f, g, o) order, 4*pred_hidden rows.
     struct LstmLayer {
-        ggml_tensor * Wx = nullptr; // [4*pred_hidden, pred_hidden]   (input-to-hidden, layer 0 input dim is pred_hidden because of the embed)
-        ggml_tensor * Wh = nullptr; // [4*pred_hidden, pred_hidden]   (hidden-to-hidden)
-        ggml_tensor * b  = nullptr; // [4*pred_hidden]
+        ggml_tensor * Wx =
+            nullptr;  // [4*pred_hidden, pred_hidden]   (input-to-hidden, layer 0 input dim is pred_hidden because of the embed)
+        ggml_tensor * Wh = nullptr;  // [4*pred_hidden, pred_hidden]   (hidden-to-hidden)
+        ggml_tensor * b  = nullptr;  // [4*pred_hidden]
     };
-    std::vector<LstmLayer> lstm; // pred_n_layers entries
+
+    std::vector<LstmLayer> lstm;  // pred_n_layers entries
 };
 
 struct ParakeetJoint {
-    ggml_tensor * enc_w  = nullptr; // [joint_hidden, enc_d_model]
-    ggml_tensor * enc_b  = nullptr; // [joint_hidden]
-    ggml_tensor * pred_w = nullptr; // [joint_hidden, pred_hidden]
-    ggml_tensor * pred_b = nullptr; // [joint_hidden]
-    ggml_tensor * out_w  = nullptr; // [joint_n_classes, joint_hidden]
-    ggml_tensor * out_b  = nullptr; // [joint_n_classes]
+    ggml_tensor * enc_w  = nullptr;  // [joint_hidden, enc_d_model]
+    ggml_tensor * enc_b  = nullptr;  // [joint_hidden]
+    ggml_tensor * pred_w = nullptr;  // [joint_hidden, pred_hidden]
+    ggml_tensor * pred_b = nullptr;  // [joint_hidden]
+    ggml_tensor * out_w  = nullptr;  // [joint_n_classes, joint_hidden]
+    ggml_tensor * out_b  = nullptr;  // [joint_n_classes]
 };
 
 // CTC head. Single 1×1 Conv1d projecting d_model -> vocab+1. Loaded
 // only when head_kind=CTC; predictor + joint stay empty in that case.
 struct ParakeetCtcHead {
-    ggml_tensor * weight = nullptr; // [vocab+1, d_model, 1]   conv1d k=1
-    ggml_tensor * bias   = nullptr; // [vocab+1]
+    ggml_tensor * weight = nullptr;  // [vocab+1, d_model, 1]   conv1d k=1
+    ggml_tensor * bias   = nullptr;  // [vocab+1]
 };
 
 // Language-conditioning prompt MLP (multilingual variants). NeMo's
@@ -339,19 +342,19 @@ struct ParakeetCtcHead {
 // Loaded only when hp.has_prompt is true; otherwise the slots stay
 // null and the encoder skips the prompt path.
 struct ParakeetPromptMlp {
-    ggml_tensor * mlp0_w = nullptr; // [prompt_hidden, d_model + num_prompts]
-    ggml_tensor * mlp0_b = nullptr; // [prompt_hidden]
-    ggml_tensor * mlp2_w = nullptr; // [d_model, prompt_hidden]
-    ggml_tensor * mlp2_b = nullptr; // [d_model]
+    ggml_tensor * mlp0_w = nullptr;  // [prompt_hidden, d_model + num_prompts]
+    ggml_tensor * mlp0_b = nullptr;  // [prompt_hidden]
+    ggml_tensor * mlp2_w = nullptr;  // [d_model, prompt_hidden]
+    ggml_tensor * mlp2_b = nullptr;  // [d_model]
 };
 
 struct ParakeetWeights {
     ParakeetPreEncode          pre_encode;
-    std::vector<ParakeetBlock> blocks; // hp.enc_n_layers entries
-    ParakeetPredictor          predictor; // empty when head_kind=CTC
-    ParakeetJoint              joint;     // empty when head_kind=CTC
-    ParakeetCtcHead            ctc_head;  // populated when head_kind=CTC
-    ParakeetPromptMlp          prompt;    // populated when hp.has_prompt
+    std::vector<ParakeetBlock> blocks;     // hp.enc_n_layers entries
+    ParakeetPredictor          predictor;  // empty when head_kind=CTC
+    ParakeetJoint              joint;      // empty when head_kind=CTC
+    ParakeetCtcHead            ctc_head;   // populated when head_kind=CTC
+    ParakeetPromptMlp          prompt;     // populated when hp.has_prompt
 };
 
 // Walk the canonical tensor list, look up each tensor by name, validate
@@ -364,4 +367,4 @@ transcribe_status build_parakeet_weights(ggml_context *          ctx_meta,
                                          const ParakeetHParams & hp,
                                          ParakeetWeights &       weights);
 
-} // namespace transcribe::parakeet
+}  // namespace transcribe::parakeet
diff --git a/src/arch/qwen3_asr/capabilities.cpp b/src/arch/qwen3_asr/capabilities.cpp
index eb9c9c25..4737e588 100644
--- a/src/arch/qwen3_asr/capabilities.cpp
+++ b/src/arch/qwen3_asr/capabilities.cpp
@@ -22,4 +22,4 @@ void apply_family_invariants(transcribe_model & model) {
     transcribe::set_feature(&model, TRANSCRIBE_FEATURE_CANCELLATION, true);
 }
 
-} // namespace transcribe::qwen3_asr
+}  // namespace transcribe::qwen3_asr
diff --git a/src/arch/qwen3_asr/decoder.cpp b/src/arch/qwen3_asr/decoder.cpp
index ecc11186..70de99b4 100644
--- a/src/arch/qwen3_asr/decoder.cpp
+++ b/src/arch/qwen3_asr/decoder.cpp
@@ -12,11 +12,10 @@
 #include "decoder.h"
 
 #include "causal_lm/causal_lm.h"
+#include "ggml.h"
 #include "transcribe-debug.h"
 #include "transcribe-log.h"
 
-#include "ggml.h"
-
 #include <cmath>
 #include <cstdio>
 
@@ -25,13 +24,15 @@ namespace transcribe::qwen3_asr {
 namespace {
 
 ggml_tensor * named(ggml_tensor * t, const char * name) {
-    if (t != nullptr && name != nullptr) ggml_set_name(t, name);
+    if (t != nullptr && name != nullptr) {
+        ggml_set_name(t, name);
+    }
     return t;
 }
 
 // Build a BlockView from one decoder-block weight slot.
 causal_lm::BlockView to_block_view(const QwenAsrDecBlock & b) {
-    causal_lm::BlockView v {};
+    causal_lm::BlockView v{};
     v.norm_attn_w   = b.norm_attn_w;
     v.norm_ffn_w    = b.norm_ffn_w;
     v.attn_q_w      = b.attn_q_w;
@@ -46,7 +47,7 @@ causal_lm::BlockView to_block_view(const QwenAsrDecBlock & b) {
 }
 
 causal_lm::BlockParams to_block_params(const QwenAsrHParams & hp) {
-    causal_lm::BlockParams p {};
+    causal_lm::BlockParams p{};
     p.n_heads      = hp.dec_n_heads;
     p.n_kv_heads   = hp.dec_n_kv_heads;
     p.head_dim     = hp.dec_head_dim;
@@ -56,40 +57,35 @@ causal_lm::BlockParams to_block_params(const QwenAsrHParams & hp) {
     return p;
 }
 
-} // namespace
+}  // namespace
 
-PrefillBuild build_prefill_graph(ggml_context *                  ctx,
-                                 const QwenAsrWeights &          weights,
-                                 const QwenAsrHParams &          hp,
+PrefillBuild build_prefill_graph(ggml_context *                   ctx,
+                                 const QwenAsrWeights &           weights,
+                                 const QwenAsrHParams &           hp,
                                  transcribe::causal_lm::KvCache & kv_cache,
-                                 int                             T_prompt,
-                                 int                             T_enc,
-                                 int                             prefix_len,
-                                 int                             suffix_len,
-                                 bool                            use_flash,
-                                 bool                            slice_last,
-                                 int                             kv_batch_slot,
-                                 int                             kv_n_batch)
-{
-    PrefillBuild pb {};
+                                 int                              T_prompt,
+                                 int                              T_enc,
+                                 int                              prefix_len,
+                                 int                              suffix_len,
+                                 bool                             use_flash,
+                                 bool                             slice_last,
+                                 int                              kv_batch_slot,
+                                 int                              kv_n_batch) {
+    PrefillBuild pb{};
     pb.T_prompt   = T_prompt;
     pb.T_enc      = T_enc;
     pb.prefix_len = prefix_len;
     pb.suffix_len = suffix_len;
 
     if (ctx == nullptr || T_prompt <= 0 || T_enc <= 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "qwen3_asr decoder: invalid arg (T_prompt=%d, T_enc=%d)",
-                     T_prompt, T_enc);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "qwen3_asr decoder: invalid arg (T_prompt=%d, T_enc=%d)", T_prompt, T_enc);
         return pb;
     }
-    if (prefix_len < 0 || suffix_len < 0 ||
-        prefix_len + T_enc + suffix_len != T_prompt)
-    {
+    if (prefix_len < 0 || suffix_len < 0 || prefix_len + T_enc + suffix_len != T_prompt) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "qwen3_asr decoder: prefix_len(%d) + T_enc(%d) + "
-                     "suffix_len(%d) != T_prompt(%d)",
-                     prefix_len, T_enc, suffix_len, T_prompt);
+                "qwen3_asr decoder: prefix_len(%d) + T_enc(%d) + "
+                "suffix_len(%d) != T_prompt(%d)",
+                prefix_len, T_enc, suffix_len, T_prompt);
         return pb;
     }
     if (kv_cache.self_k == nullptr || kv_cache.self_v == nullptr) {
@@ -97,9 +93,8 @@ PrefillBuild build_prefill_graph(ggml_context *                  ctx,
         return pb;
     }
     if (T_prompt > kv_cache.n_ctx) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "qwen3_asr decoder: T_prompt=%d exceeds kv_cache.n_ctx=%d",
-                     T_prompt, kv_cache.n_ctx);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "qwen3_asr decoder: T_prompt=%d exceeds kv_cache.n_ctx=%d", T_prompt,
+                kv_cache.n_ctx);
         return pb;
     }
 
@@ -110,8 +105,8 @@ PrefillBuild build_prefill_graph(ggml_context *                  ctx,
     // Note: `enc_output_dim == dec_hidden` is an audio-injection
     // precondition; validated in read_qwen3_asr_hparams.
 
-    const auto block_params = to_block_params(hp);
-    const float rms_eps = hp.dec_rms_norm_eps;
+    const auto  block_params = to_block_params(hp);
+    const float rms_eps      = hp.dec_rms_norm_eps;
 
     // Graph inputs.
     pb.input_ids_in = ggml_new_tensor_1d(ctx, GGML_TYPE_I32, T_prompt);
@@ -134,68 +129,56 @@ PrefillBuild build_prefill_graph(ggml_context *                  ctx,
 
     ggml_cgraph * gf = ggml_new_graph_custom(ctx, /*size=*/16384, /*grads=*/false);
     if (gf == nullptr) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "qwen3_asr decoder: ggml_new_graph_custom failed");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "qwen3_asr decoder: ggml_new_graph_custom failed");
         return pb;
     }
     pb.graph = gf;
 
     // Token embedding (all positions, for the dump).
-    ggml_tensor * token_emb_all = ggml_get_rows(
-        ctx, weights.dec_embed.token_w, pb.input_ids_in);
+    ggml_tensor * token_emb_all = ggml_get_rows(ctx, weights.dec_embed.token_w, pb.input_ids_in);
     named(token_emb_all, "dec.token_emb");
     pb.dumps.token_emb = token_emb_all;
     transcribe::debug::mark_tensor_for_dump(token_emb_all);
 
     // Audio injection via 3-way concat.
     // Single contiguous audio block at positions [prefix_len, prefix_len+T_enc).
-    const size_t emb_elem = ggml_element_size(token_emb_all);
+    const size_t  emb_elem = ggml_element_size(token_emb_all);
     ggml_tensor * x_prefix = nullptr;
     if (prefix_len > 0) {
-        x_prefix = ggml_view_2d(
-            ctx, token_emb_all,
-            hidden, prefix_len,
-            emb_elem * hidden,
-            /*off=*/0);
+        x_prefix = ggml_view_2d(ctx, token_emb_all, hidden, prefix_len, emb_elem * hidden,
+                                /*off=*/0);
         x_prefix = ggml_cont(ctx, x_prefix);
     }
     ggml_tensor * x_audio = pb.enc_out_in;
 
     ggml_tensor * x_suffix = nullptr;
     if (suffix_len > 0) {
-        x_suffix = ggml_view_2d(
-            ctx, token_emb_all,
-            hidden, suffix_len,
-            emb_elem * hidden,
-            emb_elem * hidden * static_cast<size_t>(prefix_len + T_enc));
+        x_suffix = ggml_view_2d(ctx, token_emb_all, hidden, suffix_len, emb_elem * hidden,
+                                emb_elem * hidden * static_cast<size_t>(prefix_len + T_enc));
         x_suffix = ggml_cont(ctx, x_suffix);
     }
 
     ggml_tensor * x = x_audio;
-    if (x_prefix != nullptr) x = ggml_concat(ctx, x_prefix, x, /*dim=*/1);
-    if (x_suffix != nullptr) x = ggml_concat(ctx, x, x_suffix, /*dim=*/1);
+    if (x_prefix != nullptr) {
+        x = ggml_concat(ctx, x_prefix, x, /*dim=*/1);
+    }
+    if (x_suffix != nullptr) {
+        x = ggml_concat(ctx, x, x_suffix, /*dim=*/1);
+    }
     named(x, "dec.audio_injected");
     pb.dumps.audio_injected = x;
     transcribe::debug::mark_tensor_for_dump(x);
 
     // Block stack.
     for (int il = 0; il < n_layer; ++il) {
-        causal_lm::BlockOpts opts {};
+        causal_lm::BlockOpts opts{};
         opts.use_flash             = use_flash;
         opts.slice_last_before_ffn = slice_last && (il == n_layer - 1);
         opts.kv_batch_slot         = kv_batch_slot;
         opts.kv_n_batch            = kv_n_batch;
 
-        x = causal_lm::block_prefill(
-            ctx, gf, x,
-            to_block_view(weights.dec_blocks[il]),
-            block_params,
-            kv_cache,
-            il,
-            T_prompt,
-            pb.mask_in,
-            pb.positions_in,
-            opts);
+        x = causal_lm::block_prefill(ctx, gf, x, to_block_view(weights.dec_blocks[il]), block_params, kv_cache, il,
+                                     T_prompt, pb.mask_in, pb.positions_in, opts);
 
         if (il == 0) {
             named(x, "dec.block.0.out");
@@ -211,8 +194,7 @@ PrefillBuild build_prefill_graph(ggml_context *                  ctx,
     }
 
     // Final RMSNorm + tied lm_head.
-    x = ggml_mul(ctx, ggml_rms_norm(ctx, x, rms_eps),
-                 weights.dec_final.norm_w);
+    x = ggml_mul(ctx, ggml_rms_norm(ctx, x, rms_eps), weights.dec_final.norm_w);
     named(x, "dec.out_before_head");
     pb.dumps.out_before_head = x;
     transcribe::debug::mark_tensor_for_dump(x);
@@ -223,16 +205,13 @@ PrefillBuild build_prefill_graph(ggml_context *                  ctx,
     if (slice_last) {
         last_x = x;
     } else {
-        last_x = ggml_view_2d(
-            ctx, x,
-            hidden, 1,
-            ggml_element_size(x) * hidden,
-            ggml_element_size(x) * hidden * static_cast<size_t>(T_prompt - 1));
+        last_x = ggml_view_2d(ctx, x, hidden, 1, ggml_element_size(x) * hidden,
+                              ggml_element_size(x) * hidden * static_cast<size_t>(T_prompt - 1));
         last_x = ggml_cont(ctx, last_x);
     }
 
     ggml_tensor * logits = ggml_mul_mat(ctx, weights.dec_embed.token_w, last_x);
-    logits = ggml_reshape_1d(ctx, logits, vocab);
+    logits               = ggml_reshape_1d(ctx, logits, vocab);
     named(logits, "dec.logits_raw");
     pb.dumps.logits_raw = logits;
     transcribe::debug::mark_tensor_for_dump(logits);
@@ -242,30 +221,38 @@ PrefillBuild build_prefill_graph(ggml_context *                  ctx,
 
     ggml_build_forward_expand(gf, pb.out);
 
-    if (pb.dumps.token_emb)       ggml_build_forward_expand(gf, pb.dumps.token_emb);
-    if (pb.dumps.audio_injected)  ggml_build_forward_expand(gf, pb.dumps.audio_injected);
-    if (pb.dumps.block_0_out)     ggml_build_forward_expand(gf, pb.dumps.block_0_out);
-    if (pb.dumps.block_last_out)  ggml_build_forward_expand(gf, pb.dumps.block_last_out);
-    if (pb.dumps.out_before_head) ggml_build_forward_expand(gf, pb.dumps.out_before_head);
+    if (pb.dumps.token_emb) {
+        ggml_build_forward_expand(gf, pb.dumps.token_emb);
+    }
+    if (pb.dumps.audio_injected) {
+        ggml_build_forward_expand(gf, pb.dumps.audio_injected);
+    }
+    if (pb.dumps.block_0_out) {
+        ggml_build_forward_expand(gf, pb.dumps.block_0_out);
+    }
+    if (pb.dumps.block_last_out) {
+        ggml_build_forward_expand(gf, pb.dumps.block_last_out);
+    }
+    if (pb.dumps.out_before_head) {
+        ggml_build_forward_expand(gf, pb.dumps.out_before_head);
+    }
 
     return pb;
 }
 
 // Step graph (single-token decode)
 
-StepBuild build_step_graph(ggml_context *                  ctx,
-                           const QwenAsrWeights &          weights,
-                           const QwenAsrHParams &          hp,
+StepBuild build_step_graph(ggml_context *                   ctx,
+                           const QwenAsrWeights &           weights,
+                           const QwenAsrHParams &           hp,
                            transcribe::causal_lm::KvCache & kv_cache,
-                           int                             max_n_kv,
-                           bool                            use_flash)
-{
-    StepBuild sb {};
+                           int                              max_n_kv,
+                           bool                             use_flash) {
+    StepBuild sb{};
     sb.max_n_kv = max_n_kv;
 
     if (ctx == nullptr || max_n_kv <= 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "qwen3_asr step: invalid arg (max_n_kv=%d)", max_n_kv);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "qwen3_asr step: invalid arg (max_n_kv=%d)", max_n_kv);
         return sb;
     }
     if (kv_cache.self_k == nullptr) {
@@ -273,9 +260,8 @@ StepBuild build_step_graph(ggml_context *                  ctx,
         return sb;
     }
     if (max_n_kv > kv_cache.n_ctx) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "qwen3_asr step: max_n_kv=%d exceeds kv_cache.n_ctx=%d",
-                     max_n_kv, kv_cache.n_ctx);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "qwen3_asr step: max_n_kv=%d exceeds kv_cache.n_ctx=%d", max_n_kv,
+                kv_cache.n_ctx);
         return sb;
     }
 
@@ -307,8 +293,7 @@ StepBuild build_step_graph(ggml_context *                  ctx,
 
     ggml_cgraph * gf = ggml_new_graph_custom(ctx, /*size=*/8192, /*grads=*/false);
     if (gf == nullptr) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "qwen3_asr step: ggml_new_graph_custom failed");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "qwen3_asr step: ggml_new_graph_custom failed");
         return sb;
     }
     sb.graph = gf;
@@ -319,24 +304,14 @@ StepBuild build_step_graph(ggml_context *                  ctx,
 
     // Block stack.
     for (int il = 0; il < n_layer; ++il) {
-        x = causal_lm::block_step(
-            ctx, gf, x,
-            to_block_view(weights.dec_blocks[il]),
-            block_params,
-            kv_cache,
-            il,
-            max_n_kv,
-            sb.mask_in,
-            sb.position_in,
-            sb.kv_idx_in,
-            use_flash);
+        x = causal_lm::block_step(ctx, gf, x, to_block_view(weights.dec_blocks[il]), block_params, kv_cache, il,
+                                  max_n_kv, sb.mask_in, sb.position_in, sb.kv_idx_in, use_flash);
     }
 
     // Final RMSNorm + tied lm_head.
-    x = ggml_mul(ctx, ggml_rms_norm(ctx, x, rms_eps),
-                 weights.dec_final.norm_w);
+    x                    = ggml_mul(ctx, ggml_rms_norm(ctx, x, rms_eps), weights.dec_final.norm_w);
     ggml_tensor * logits = ggml_mul_mat(ctx, weights.dec_embed.token_w, x);
-    logits = ggml_reshape_1d(ctx, logits, vocab);
+    logits               = ggml_reshape_1d(ctx, logits, vocab);
     ggml_set_name(logits, "step.logits");
 
     // argmax on-device → 4-byte readback instead of vocab-sized vector.
@@ -355,42 +330,37 @@ StepBuild build_step_graph(ggml_context *                  ctx,
     return sb;
 }
 
-PrefillBuildBatched build_prefill_graph_batched(
-    ggml_context *                  ctx,
-    const QwenAsrWeights &          weights,
-    const QwenAsrHParams &          hp,
-    transcribe::causal_lm::KvCache & kv_cache,
-    int                             T_prompt_max,
-    int                             T_enc_max,
-    int                             n_batch,
-    bool                            use_flash)
-{
-    PrefillBuildBatched pb {};
+PrefillBuildBatched build_prefill_graph_batched(ggml_context *                   ctx,
+                                                const QwenAsrWeights &           weights,
+                                                const QwenAsrHParams &           hp,
+                                                transcribe::causal_lm::KvCache & kv_cache,
+                                                int                              T_prompt_max,
+                                                int                              T_enc_max,
+                                                int                              n_batch,
+                                                bool                             use_flash) {
+    PrefillBuildBatched pb{};
     pb.T_prompt_max = T_prompt_max;
     pb.T_enc_max    = T_enc_max;
     pb.n_batch      = n_batch;
 
     if (ctx == nullptr || T_prompt_max <= 0 || T_enc_max <= 0 || n_batch <= 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "qwen3_asr prefill(batched): invalid arg "
-                     "(T_prompt_max=%d, T_enc_max=%d, n_batch=%d)",
-                     T_prompt_max, T_enc_max, n_batch);
+                "qwen3_asr prefill(batched): invalid arg "
+                "(T_prompt_max=%d, T_enc_max=%d, n_batch=%d)",
+                T_prompt_max, T_enc_max, n_batch);
         return pb;
     }
     if (kv_cache.self_k == nullptr || kv_cache.n_batch != n_batch) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "qwen3_asr prefill(batched): kv_cache mismatch");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "qwen3_asr prefill(batched): kv_cache mismatch");
         return pb;
     }
     if (!use_flash) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "qwen3_asr prefill(batched): requires use_flash");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "qwen3_asr prefill(batched): requires use_flash");
         return pb;
     }
     if (T_prompt_max > kv_cache.n_ctx) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "qwen3_asr prefill(batched): T_prompt_max=%d > n_ctx=%d",
-                     T_prompt_max, kv_cache.n_ctx);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "qwen3_asr prefill(batched): T_prompt_max=%d > n_ctx=%d", T_prompt_max,
+                kv_cache.n_ctx);
         return pb;
     }
 
@@ -407,13 +377,11 @@ PrefillBuildBatched build_prefill_graph_batched(
     ggml_set_input(pb.input_ids_in);
 
     // Audio injection via elementwise blend (no set_rows); see decoder.h.
-    pb.audio_dense_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, hidden,
-                                           static_cast<int64_t>(T_prompt_max) * B);
+    pb.audio_dense_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, hidden, static_cast<int64_t>(T_prompt_max) * B);
     ggml_set_name(pb.audio_dense_in, "prefill.audio_dense");
     ggml_set_input(pb.audio_dense_in);
 
-    pb.keep_mask_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, 1,
-                                         static_cast<int64_t>(T_prompt_max) * B);
+    pb.keep_mask_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, 1, static_cast<int64_t>(T_prompt_max) * B);
     ggml_set_name(pb.keep_mask_in, "prefill.keep_mask");
     ggml_set_input(pb.keep_mask_in);
 
@@ -435,8 +403,7 @@ PrefillBuildBatched build_prefill_graph_batched(
 
     ggml_cgraph * gf = ggml_new_graph_custom(ctx, /*size=*/16384, /*grads=*/false);
     if (gf == nullptr) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "qwen3_asr prefill(batched): ggml_new_graph_custom failed");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "qwen3_asr prefill(batched): ggml_new_graph_custom failed");
         return pb;
     }
     pb.graph = gf;
@@ -444,25 +411,18 @@ PrefillBuildBatched build_prefill_graph_batched(
     // Token embedding for the full padded prompt. get_rows over a 2D table
     // wants a 1D index, so flatten [T_prompt_max, B] -> [T_prompt_max*B], then
     // reshape the result back to [hidden, T_prompt_max, B].
-    ggml_tensor * ids_flat =
-        ggml_reshape_1d(ctx, pb.input_ids_in,
-                        static_cast<int64_t>(T_prompt_max) * B);
+    ggml_tensor * ids_flat = ggml_reshape_1d(ctx, pb.input_ids_in, static_cast<int64_t>(T_prompt_max) * B);
     // x = x*keep_mask + audio_dense (keep_mask broadcasts over hidden), then
     // reshape to 3D for the batched block stack.
-    ggml_tensor * x = ggml_get_rows(ctx, weights.dec_embed.token_w, ids_flat);
-    x = ggml_add(ctx, ggml_mul(ctx, x, pb.keep_mask_in), pb.audio_dense_in);
-    x = ggml_reshape_3d(ctx, x, hidden, T_prompt_max, B);
+    ggml_tensor * x        = ggml_get_rows(ctx, weights.dec_embed.token_w, ids_flat);
+    x                      = ggml_add(ctx, ggml_mul(ctx, x, pb.keep_mask_in), pb.audio_dense_in);
+    x                      = ggml_reshape_3d(ctx, x, hidden, T_prompt_max, B);
 
     for (int il = 0; il < n_layer; ++il) {
-        x = causal_lm::block_prefill_batched(
-            ctx, gf, x,
-            to_block_view(weights.dec_blocks[il]),
-            block_params, kv_cache, il,
-            T_prompt_max, B,
-            pb.mask_in, pb.positions_in, pb.kv_idx_in, use_flash);
+        x = causal_lm::block_prefill_batched(ctx, gf, x, to_block_view(weights.dec_blocks[il]), block_params, kv_cache,
+                                             il, T_prompt_max, B, pb.mask_in, pb.positions_in, pb.kv_idx_in, use_flash);
         if (x == nullptr) {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "qwen3_asr prefill(batched): block %d failed", il);
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "qwen3_asr prefill(batched): block %d failed", il);
             pb.graph = nullptr;
             return pb;
         }
@@ -470,12 +430,11 @@ PrefillBuildBatched build_prefill_graph_batched(
 
     // Gather each utterance's last real position: [hidden, 1, B] -> [hidden, B].
     ggml_tensor * x_last = ggml_get_rows(ctx, x, pb.last_idx_in);
-    x_last = ggml_reshape_2d(ctx, x_last, hidden, B);
+    x_last               = ggml_reshape_2d(ctx, x_last, hidden, B);
 
-    x_last = ggml_mul(ctx, ggml_rms_norm(ctx, x_last, rms_eps),
-                      weights.dec_final.norm_w);
+    x_last               = ggml_mul(ctx, ggml_rms_norm(ctx, x_last, rms_eps), weights.dec_final.norm_w);
     ggml_tensor * logits = ggml_mul_mat(ctx, weights.dec_embed.token_w, x_last);
-    logits = ggml_reshape_2d(ctx, logits, vocab, B);
+    logits               = ggml_reshape_2d(ctx, logits, vocab, B);
     ggml_set_name(logits, "prefill.logits");
     pb.logits = logits;
 
@@ -489,45 +448,40 @@ PrefillBuildBatched build_prefill_graph_batched(
     return pb;
 }
 
-StepBuildBatched build_step_graph_batched(
-    ggml_context *                  ctx,
-    const QwenAsrWeights &          weights,
-    const QwenAsrHParams &          hp,
-    transcribe::causal_lm::KvCache & kv_cache,
-    int                             max_n_kv,
-    int                             n_batch,
-    bool                            use_flash)
-{
-    StepBuildBatched sb {};
+StepBuildBatched build_step_graph_batched(ggml_context *                   ctx,
+                                          const QwenAsrWeights &           weights,
+                                          const QwenAsrHParams &           hp,
+                                          transcribe::causal_lm::KvCache & kv_cache,
+                                          int                              max_n_kv,
+                                          int                              n_batch,
+                                          bool                             use_flash) {
+    StepBuildBatched sb{};
     sb.max_n_kv = max_n_kv;
     sb.n_batch  = n_batch;
 
     if (ctx == nullptr || max_n_kv <= 0 || n_batch <= 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "qwen3_asr step(batched): invalid arg "
-                     "(max_n_kv=%d, n_batch=%d)", max_n_kv, n_batch);
+                "qwen3_asr step(batched): invalid arg "
+                "(max_n_kv=%d, n_batch=%d)",
+                max_n_kv, n_batch);
         return sb;
     }
     if (kv_cache.self_k == nullptr) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "qwen3_asr step(batched): kv_cache not initialized");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "qwen3_asr step(batched): kv_cache not initialized");
         return sb;
     }
     if (kv_cache.n_batch != n_batch) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "qwen3_asr step(batched): kv_cache.n_batch=%d != %d",
-                     kv_cache.n_batch, n_batch);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "qwen3_asr step(batched): kv_cache.n_batch=%d != %d", kv_cache.n_batch,
+                n_batch);
         return sb;
     }
     if (max_n_kv > kv_cache.n_ctx) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "qwen3_asr step(batched): max_n_kv=%d exceeds n_ctx=%d",
-                     max_n_kv, kv_cache.n_ctx);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "qwen3_asr step(batched): max_n_kv=%d exceeds n_ctx=%d", max_n_kv,
+                kv_cache.n_ctx);
         return sb;
     }
     if (!use_flash) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "qwen3_asr step(batched): requires use_flash");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "qwen3_asr step(batched): requires use_flash");
         return sb;
     }
 
@@ -557,8 +511,7 @@ StepBuildBatched build_step_graph_batched(
 
     ggml_cgraph * gf = ggml_new_graph_custom(ctx, /*size=*/8192, /*grads=*/false);
     if (gf == nullptr) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "qwen3_asr step(batched): ggml_new_graph_custom failed");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "qwen3_asr step(batched): ggml_new_graph_custom failed");
         return sb;
     }
     sb.graph = gf;
@@ -569,31 +522,20 @@ StepBuildBatched build_step_graph_batched(
 
     // Block stack.
     for (int il = 0; il < n_layer; ++il) {
-        x = causal_lm::block_step_batched(
-            ctx, gf, x,
-            to_block_view(weights.dec_blocks[il]),
-            block_params,
-            kv_cache,
-            il,
-            max_n_kv,
-            B,
-            sb.mask_in,
-            sb.position_in,
-            sb.kv_idx_in,
-            use_flash);
+        x = causal_lm::block_step_batched(ctx, gf, x, to_block_view(weights.dec_blocks[il]), block_params, kv_cache, il,
+                                          max_n_kv, B, sb.mask_in, sb.position_in, sb.kv_idx_in, use_flash);
         if (x == nullptr) {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "qwen3_asr step(batched): block %d build failed", il);
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "qwen3_asr step(batched): block %d build failed", il);
             sb.graph = nullptr;
             return sb;
         }
     }
 
     // Final RMSNorm + tied lm_head.
-    x = ggml_mul(ctx, ggml_rms_norm(ctx, x, rms_eps),
-                 weights.dec_final.norm_w);            // [hidden, B]
+    x                    = ggml_mul(ctx, ggml_rms_norm(ctx, x, rms_eps),
+                                    weights.dec_final.norm_w);      // [hidden, B]
     ggml_tensor * logits = ggml_mul_mat(ctx, weights.dec_embed.token_w, x);
-    logits = ggml_reshape_2d(ctx, logits, vocab, B);    // [vocab, B]
+    logits               = ggml_reshape_2d(ctx, logits, vocab, B);  // [vocab, B]
     ggml_set_name(logits, "step.logits");
     sb.logits = logits;
 
@@ -610,4 +552,4 @@ StepBuildBatched build_step_graph_batched(
     return sb;
 }
 
-} // namespace transcribe::qwen3_asr
+}  // namespace transcribe::qwen3_asr
diff --git a/src/arch/qwen3_asr/decoder.h b/src/arch/qwen3_asr/decoder.h
index 44800448..f43ac58f 100644
--- a/src/arch/qwen3_asr/decoder.h
+++ b/src/arch/qwen3_asr/decoder.h
@@ -31,11 +31,10 @@
 
 #pragma once
 
-#include "qwen3_asr.h"
 #include "causal_lm/causal_lm.h"
-#include "weights.h"
-
 #include "ggml.h"
+#include "qwen3_asr.h"
+#include "weights.h"
 
 struct ggml_context;
 struct ggml_cgraph;
@@ -53,18 +52,18 @@ struct DecoderDumps {
 };
 
 struct PrefillBuild {
-    ggml_tensor * input_ids_in    = nullptr;  // [T_prompt] i32 (for dec.token_emb dump)
-    ggml_tensor * enc_out_in      = nullptr;  // [enc_output_dim, T_enc] f32
-    ggml_tensor * positions_in    = nullptr;  // [T_prompt] i32 for RoPE
-    ggml_tensor * mask_in         = nullptr;  // [T_prompt, T_prompt] f16 (causal)
-    ggml_tensor * out             = nullptr;  // [vocab_size] — last-position logits
-    DecoderDumps  dumps {};
-    ggml_cgraph * graph           = nullptr;
-
-    int           T_prompt        = 0;
-    int           T_enc           = 0;
-    int           prefix_len      = 0;  // # prompt tokens before the audio block
-    int           suffix_len      = 0;  // # prompt tokens after the audio block
+    ggml_tensor * input_ids_in = nullptr;  // [T_prompt] i32 (for dec.token_emb dump)
+    ggml_tensor * enc_out_in   = nullptr;  // [enc_output_dim, T_enc] f32
+    ggml_tensor * positions_in = nullptr;  // [T_prompt] i32 for RoPE
+    ggml_tensor * mask_in      = nullptr;  // [T_prompt, T_prompt] f16 (causal)
+    ggml_tensor * out          = nullptr;  // [vocab_size] — last-position logits
+    DecoderDumps  dumps{};
+    ggml_cgraph * graph = nullptr;
+
+    int T_prompt   = 0;
+    int T_enc      = 0;
+    int prefix_len = 0;  // # prompt tokens before the audio block
+    int suffix_len = 0;  // # prompt tokens after the audio block
 };
 
 // Build a prefill graph: token-embed the full prompt, concat
@@ -74,30 +73,30 @@ struct PrefillBuild {
 // [prefix_len, prefix_len + T_enc). Callers set kv_cache.n / .head = T_prompt
 // after compute. kv_batch_slot / kv_n_batch route this utterance's KV into a
 // batched cache slab; defaults (0, 1) reproduce the single-shot layout.
-PrefillBuild build_prefill_graph(ggml_context *                ctx,
-                                 const QwenAsrWeights &        weights,
-                                 const QwenAsrHParams &        hp,
+PrefillBuild build_prefill_graph(ggml_context *                   ctx,
+                                 const QwenAsrWeights &           weights,
+                                 const QwenAsrHParams &           hp,
                                  transcribe::causal_lm::KvCache & kv_cache,
-                                 int                           T_prompt,
-                                 int                           T_enc,
-                                 int                           prefix_len,
-                                 int                           suffix_len,
-                                 bool                          use_flash,
-                                 bool                          slice_last,
-                                 int                           kv_batch_slot = 0,
-                                 int                           kv_n_batch    = 1);
+                                 int                              T_prompt,
+                                 int                              T_enc,
+                                 int                              prefix_len,
+                                 int                              suffix_len,
+                                 bool                             use_flash,
+                                 bool                             slice_last,
+                                 int                              kv_batch_slot = 0,
+                                 int                              kv_n_batch    = 1);
 
 // ---------- Step graph (one token) ----------
 
 struct StepBuild {
-    ggml_tensor * input_id_in  = nullptr;  // [1] i32
-    ggml_tensor * position_in  = nullptr;  // [1] i32, value = n_past
-    ggml_tensor * kv_idx_in    = nullptr;  // [1] i64, KV write position
-    ggml_tensor * mask_in      = nullptr;  // [max_n_kv, 1] f16
-    ggml_tensor * out          = nullptr;  // [1] i32 — argmax token id
-    ggml_cgraph * graph        = nullptr;
-
-    int           max_n_kv     = 0;  // static shape sized for whole run
+    ggml_tensor * input_id_in = nullptr;  // [1] i32
+    ggml_tensor * position_in = nullptr;  // [1] i32, value = n_past
+    ggml_tensor * kv_idx_in   = nullptr;  // [1] i64, KV write position
+    ggml_tensor * mask_in     = nullptr;  // [max_n_kv, 1] f16
+    ggml_tensor * out         = nullptr;  // [1] i32 — argmax token id
+    ggml_cgraph * graph       = nullptr;
+
+    int max_n_kv = 0;  // static shape sized for whole run
 };
 
 // Build a static-shape single-token step graph reused across every step.
@@ -108,17 +107,17 @@ struct StepBuild {
 //   kv_idx_in   [1]      — where to write K/V (via ggml_set_rows)
 //   mask_in     [max_n_kv, 1] — attention mask; positions > n_past hold -inf
 // Reuse avoids per-step rebuild + sched_alloc overhead (~0.4 ms/step).
-StepBuild build_step_graph(ggml_context *                  ctx,
-                           const QwenAsrWeights &          weights,
-                           const QwenAsrHParams &          hp,
+StepBuild build_step_graph(ggml_context *                   ctx,
+                           const QwenAsrWeights &           weights,
+                           const QwenAsrHParams &           hp,
                            transcribe::causal_lm::KvCache & kv_cache,
-                           int                             max_n_kv,
-                           bool                            use_flash);
+                           int                              max_n_kv,
+                           bool                             use_flash);
 
 // ---------- Batched prefill graph (B utterances, T tokens each) ----------
 
 struct PrefillBuildBatched {
-    ggml_tensor * input_ids_in = nullptr;  // [T_prompt_max, B] i32 (audio_token placeholders)
+    ggml_tensor * input_ids_in   = nullptr;  // [T_prompt_max, B] i32 (audio_token placeholders)
     // Audio injection via elementwise blend (no set_rows): audio_dense holds the
     // enc_out embeds scattered host-side into their prompt positions (zero
     // elsewhere), keep_mask is 0 there and 1 elsewhere, block input is
@@ -126,13 +125,13 @@ struct PrefillBuildBatched {
     // (forced by k-quant token_embd get_rows) cleanly, unlike a set_rows.
     ggml_tensor * audio_dense_in = nullptr;  // [dec_hidden, T_prompt_max*B] f32
     ggml_tensor * keep_mask_in   = nullptr;  // [1, T_prompt_max*B] f32 (0=audio,1=keep)
-    ggml_tensor * positions_in = nullptr;  // [T_prompt_max] i32 (shared 0..T-1)
-    ggml_tensor * mask_in      = nullptr;  // [T_prompt_max, T_prompt_max] f16 causal (shared)
-    ggml_tensor * kv_idx_in    = nullptr;  // [T_prompt_max, B] i64 (idx[t,b] = t)
-    ggml_tensor * last_idx_in  = nullptr;  // [1, B] i32 (each utterance's last real position)
-    ggml_tensor * logits       = nullptr;  // [vocab, B] last-real-position logits
-    ggml_tensor * out          = nullptr;  // [B] i32 argmax (first generated token)
-    ggml_cgraph * graph        = nullptr;
+    ggml_tensor * positions_in   = nullptr;  // [T_prompt_max] i32 (shared 0..T-1)
+    ggml_tensor * mask_in        = nullptr;  // [T_prompt_max, T_prompt_max] f16 causal (shared)
+    ggml_tensor * kv_idx_in      = nullptr;  // [T_prompt_max, B] i64 (idx[t,b] = t)
+    ggml_tensor * last_idx_in    = nullptr;  // [1, B] i32 (each utterance's last real position)
+    ggml_tensor * logits         = nullptr;  // [vocab, B] last-real-position logits
+    ggml_tensor * out            = nullptr;  // [B] i32 argmax (first generated token)
+    ggml_cgraph * graph          = nullptr;
 
     int T_prompt_max = 0;
     int T_enc_max    = 0;
@@ -144,15 +143,14 @@ struct PrefillBuildBatched {
 // Audio is injected by the elementwise blend (audio_dense_in / keep_mask_in).
 // Per-utterance last-real-position logits are gathered via last_idx_in, so the
 // readback is [vocab, B]. Requires use_flash.
-PrefillBuildBatched build_prefill_graph_batched(
-    ggml_context *                  ctx,
-    const QwenAsrWeights &          weights,
-    const QwenAsrHParams &          hp,
-    transcribe::causal_lm::KvCache & kv_cache,
-    int                             T_prompt_max,
-    int                             T_enc_max,
-    int                             n_batch,
-    bool                            use_flash);
+PrefillBuildBatched build_prefill_graph_batched(ggml_context *                   ctx,
+                                                const QwenAsrWeights &           weights,
+                                                const QwenAsrHParams &           hp,
+                                                transcribe::causal_lm::KvCache & kv_cache,
+                                                int                              T_prompt_max,
+                                                int                              T_enc_max,
+                                                int                              n_batch,
+                                                bool                             use_flash);
 
 // ---------- Batched step graph (B utterances, one token each) ----------
 
@@ -165,8 +163,8 @@ struct StepBuildBatched {
     ggml_tensor * out          = nullptr;  // [B] i32 — per-row argmax token id
     ggml_cgraph * graph        = nullptr;
 
-    int           max_n_kv     = 0;
-    int           n_batch      = 0;
+    int max_n_kv = 0;
+    int n_batch  = 0;
 };
 
 // Build a static-shape batched step graph reused across every step for an
@@ -176,13 +174,12 @@ struct StepBuildBatched {
 //   kv_idx_in    [1, B]         — KV write row per utterance (= its n_past)
 //   mask_in      [max_n_kv,1,1,B] — per-utterance attention mask
 // Requires use_flash (block_step_batched has no manual-GQA path).
-StepBuildBatched build_step_graph_batched(
-    ggml_context *                  ctx,
-    const QwenAsrWeights &          weights,
-    const QwenAsrHParams &          hp,
-    transcribe::causal_lm::KvCache & kv_cache,
-    int                             max_n_kv,
-    int                             n_batch,
-    bool                            use_flash);
-
-} // namespace transcribe::qwen3_asr
+StepBuildBatched build_step_graph_batched(ggml_context *                   ctx,
+                                          const QwenAsrWeights &           weights,
+                                          const QwenAsrHParams &           hp,
+                                          transcribe::causal_lm::KvCache & kv_cache,
+                                          int                              max_n_kv,
+                                          int                              n_batch,
+                                          bool                             use_flash);
+
+}  // namespace transcribe::qwen3_asr
diff --git a/src/arch/qwen3_asr/encoder.cpp b/src/arch/qwen3_asr/encoder.cpp
index 044b175e..c569d56b 100644
--- a/src/arch/qwen3_asr/encoder.cpp
+++ b/src/arch/qwen3_asr/encoder.cpp
@@ -5,11 +5,10 @@
 
 #include "encoder.h"
 
+#include "ggml.h"
 #include "transcribe-debug.h"
 #include "transcribe-log.h"
 
-#include "ggml.h"
-
 #include <cmath>
 #include <cstdio>
 #include <cstring>
@@ -24,44 +23,46 @@ int32_t aftercnn_len(int32_t mel_len) {
     // Three rounds of Conv2d(stride=2, pad=1, kernel=3):
     //   out = floor((L + 2*1 - 3) / 2) + 1 = floor((L-1)/2) + 1
     // which equals (L + 1) / 2 for L >= 1 under C integer division.
-    auto step = [](int32_t L) { return (L + 1) / 2; };
+    auto step = [](int32_t L) {
+        return (L + 1) / 2;
+    };
     return step(step(step(mel_len)));
 }
 
-EncoderTiming compute_encoder_timing(int32_t n_mel_frames,
-                                     const QwenAsrHParams & hp)
-{
-    EncoderTiming t {};
+EncoderTiming compute_encoder_timing(int32_t n_mel_frames, const QwenAsrHParams & hp) {
+    EncoderTiming t{};
     t.n_mel_frames  = n_mel_frames;
     t.mel_per_chunk = hp.enc_n_window * 2;
     if (n_mel_frames <= 0 || t.mel_per_chunk <= 0) {
         return t;
     }
-    t.n_chunks = (n_mel_frames + t.mel_per_chunk - 1) / t.mel_per_chunk;
+    t.n_chunks   = (n_mel_frames + t.mel_per_chunk - 1) / t.mel_per_chunk;
     int32_t last = n_mel_frames - (t.n_chunks - 1) * t.mel_per_chunk;
-    if (last == 0) last = t.mel_per_chunk;
-    t.last_chunk_real_mel  = last;
-    t.per_chunk_aftercnn   = aftercnn_len(t.mel_per_chunk);
-    t.last_chunk_aftercnn  = aftercnn_len(last);
-    t.T_enc_padded         = t.n_chunks * t.per_chunk_aftercnn;
-    t.T_enc                = (t.n_chunks - 1) * t.per_chunk_aftercnn + t.last_chunk_aftercnn;
-    t.aftercnn_lens_total  = aftercnn_len(n_mel_frames);
+    if (last == 0) {
+        last = t.mel_per_chunk;
+    }
+    t.last_chunk_real_mel = last;
+    t.per_chunk_aftercnn  = aftercnn_len(t.mel_per_chunk);
+    t.last_chunk_aftercnn = aftercnn_len(last);
+    t.T_enc_padded        = t.n_chunks * t.per_chunk_aftercnn;
+    t.T_enc               = (t.n_chunks - 1) * t.per_chunk_aftercnn + t.last_chunk_aftercnn;
+    t.aftercnn_lens_total = aftercnn_len(n_mel_frames);
     return t;
 }
 
-std::vector<float> build_sinusoid_pe(int32_t d_model, int32_t length,
-                                     double max_timescale)
-{
+std::vector<float> build_sinusoid_pe(int32_t d_model, int32_t length, double max_timescale) {
     std::vector<float> pe(static_cast<size_t>(d_model) * length, 0.0f);
-    if (d_model <= 0 || length <= 0 || (d_model % 2) != 0) return pe;
+    if (d_model <= 0 || length <= 0 || (d_model % 2) != 0) {
+        return pe;
+    }
 
-    const int32_t half = d_model / 2;
-    const double log_ts = std::log(max_timescale) / (half - 1);
+    const int32_t half   = d_model / 2;
+    const double  log_ts = std::log(max_timescale) / (half - 1);
 
     for (int32_t p = 0; p < length; ++p) {
         for (int32_t k = 0; k < half; ++k) {
-            const double inv_ts = std::exp(-log_ts * k);
-            const double scaled = static_cast<double>(p) * inv_ts;
+            const double inv_ts                             = std::exp(-log_ts * k);
+            const double scaled                             = static_cast<double>(p) * inv_ts;
             pe[static_cast<size_t>(p) * d_model + k]        = static_cast<float>(std::sin(scaled));
             pe[static_cast<size_t>(p) * d_model + k + half] = static_cast<float>(std::cos(scaled));
         }
@@ -69,10 +70,8 @@ std::vector<float> build_sinusoid_pe(int32_t d_model, int32_t length,
     return pe;
 }
 
-std::vector<float> build_cu_seqlens_mask(const EncoderTiming & t,
-                                         const QwenAsrHParams & hp)
-{
-    (void)hp;
+std::vector<float> build_cu_seqlens_mask(const EncoderTiming & t, const QwenAsrHParams & hp) {
+    (void) hp;
     const int32_t T = t.T_enc;
     // Full attention over the valid aftercnn rows. The measured
     // upstream reference (qwen_asr 0.0.6 + transformers eager / sdpa)
@@ -102,29 +101,23 @@ ggml_tensor * named(ggml_tensor * t, const char * name) {
     return t;
 }
 
-ggml_tensor * add_conv_bias(ggml_context * ctx, ggml_tensor * x,
-                            ggml_tensor * bias)
-{
+ggml_tensor * add_conv_bias(ggml_context * ctx, ggml_tensor * x, ggml_tensor * bias) {
     // bias is [channels]; reshape to [1, 1, channels, 1] to broadcast
     // across the spatial and batch axes of conv output [W, H, C, N].
     ggml_tensor * b4 = ggml_reshape_4d(ctx, bias, 1, 1, bias->ne[0], 1);
     return ggml_add(ctx, x, b4);
 }
 
-ggml_tensor * layer_norm(ggml_context * ctx, ggml_tensor * x,
-                         ggml_tensor * gamma, ggml_tensor * beta)
-{
+ggml_tensor * layer_norm(ggml_context * ctx, ggml_tensor * x, ggml_tensor * gamma, ggml_tensor * beta) {
     ggml_tensor * y = ggml_norm(ctx, x, kLayerNormEps);
-    y = ggml_mul(ctx, y, gamma);
+    y               = ggml_mul(ctx, y, gamma);
     if (beta != nullptr) {
         y = ggml_add(ctx, y, beta);
     }
     return y;
 }
 
-ggml_tensor * linear(ggml_context * ctx, ggml_tensor * x,
-                     ggml_tensor * w, ggml_tensor * b)
-{
+ggml_tensor * linear(ggml_context * ctx, ggml_tensor * x, ggml_tensor * w, ggml_tensor * b) {
     ggml_tensor * y = ggml_mul_mat(ctx, w, x);
     if (b != nullptr) {
         y = ggml_add(ctx, y, b);
@@ -135,14 +128,13 @@ ggml_tensor * linear(ggml_context * ctx, ggml_tensor * x,
 // One encoder block: pre-LN self-attention (bidirectional, full-
 // sequence mask supplied by the caller) + pre-LN GELU FFN. Residuals
 // are full 1.0.
-ggml_tensor * build_enc_block(ggml_context *         ctx,
-                              ggml_tensor *          x,
-                              ggml_tensor *          mask,
+ggml_tensor * build_enc_block(ggml_context *          ctx,
+                              ggml_tensor *           x,
+                              ggml_tensor *           mask,
                               const QwenAsrEncBlock & w,
-                              int                    d_model,
-                              int                    n_heads,
-                              bool                   use_flash)
-{
+                              int                     d_model,
+                              int                     n_heads,
+                              bool                    use_flash) {
     const int     head_dim = d_model / n_heads;
     const float   scale    = 1.0f / std::sqrt(static_cast<float>(head_dim));
     const int64_t T        = x->ne[1];
@@ -170,20 +162,16 @@ ggml_tensor * build_enc_block(ggml_context *         ctx,
 
     ggml_tensor * o;
     if (use_flash) {
-        o = ggml_flash_attn_ext(ctx, q, k, v, mask,
-                                scale, /*max_bias=*/0.0f,
+        o = ggml_flash_attn_ext(ctx, q, k, v, mask, scale, /*max_bias=*/0.0f,
                                 /*logit_softcap=*/0.0f);
-        o = (B == 1) ? ggml_reshape_2d(ctx, o, d_model, T)
-                     : ggml_reshape_3d(ctx, o, d_model, T, B);
+        o = (B == 1) ? ggml_reshape_2d(ctx, o, d_model, T) : ggml_reshape_3d(ctx, o, d_model, T, B);
     } else {
-        ggml_tensor * kq = ggml_mul_mat(ctx, k, q);
-        ggml_tensor * kq_soft =
-            ggml_soft_max_ext(ctx, kq, mask, scale, /*max_bias=*/0.0f);
-        ggml_tensor * v_t = ggml_cont(ctx, ggml_permute(ctx, v, 1, 0, 2, 3));
-        o = ggml_mul_mat(ctx, v_t, kq_soft);
-        o = ggml_cont(ctx, ggml_permute(ctx, o, 0, 2, 1, 3));
-        o = (B == 1) ? ggml_reshape_2d(ctx, o, d_model, T)
-                     : ggml_reshape_3d(ctx, o, d_model, T, B);
+        ggml_tensor * kq      = ggml_mul_mat(ctx, k, q);
+        ggml_tensor * kq_soft = ggml_soft_max_ext(ctx, kq, mask, scale, /*max_bias=*/0.0f);
+        ggml_tensor * v_t     = ggml_cont(ctx, ggml_permute(ctx, v, 1, 0, 2, 3));
+        o                     = ggml_mul_mat(ctx, v_t, kq_soft);
+        o                     = ggml_cont(ctx, ggml_permute(ctx, o, 0, 2, 1, 3));
+        o                     = (B == 1) ? ggml_reshape_2d(ctx, o, d_model, T) : ggml_reshape_3d(ctx, o, d_model, T, B);
     }
 
     o = linear(ctx, o, w.attn_out_w, w.attn_out_b);
@@ -192,30 +180,29 @@ ggml_tensor * build_enc_block(ggml_context *         ctx,
 
     // ----- FFN sub-layer -----
     ggml_tensor * y = layer_norm(ctx, x, w.norm_ffn_w, w.norm_ffn_b);
-    y = linear(ctx, y, w.fc1_w, w.fc1_b);
+    y               = linear(ctx, y, w.fc1_w, w.fc1_b);
     // PyTorch F.gelu default is the exact erf GELU.
-    y = ggml_gelu_erf(ctx, y);
-    y = linear(ctx, y, w.fc2_w, w.fc2_b);
+    y               = ggml_gelu_erf(ctx, y);
+    y               = linear(ctx, y, w.fc2_w, w.fc2_b);
 
     return ggml_add(ctx, x, y);
 }
 
-} // namespace
+}  // namespace
 
 EncoderBuild build_encoder_graph(ggml_context *         ctx,
                                  const QwenAsrWeights & weights,
                                  const QwenAsrHParams & hp,
                                  const EncoderTiming &  timing,
-                                 bool                   use_flash)
-{
-    EncoderBuild eb {};
+                                 bool                   use_flash) {
+    EncoderBuild eb{};
     eb.timing = timing;
 
     if (ctx == nullptr || timing.n_chunks <= 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "qwen3_asr encoder: invalid arg "
-                     "(ctx=%p, n_chunks=%d)",
-                     static_cast<void *>(ctx), timing.n_chunks);
+                "qwen3_asr encoder: invalid arg "
+                "(ctx=%p, n_chunks=%d)",
+                static_cast<void *>(ctx), timing.n_chunks);
         return eb;
     }
 
@@ -231,15 +218,15 @@ EncoderBuild build_encoder_graph(ggml_context *         ctx,
     // shape see T_enc (not T_enc_padded). This matches the reference
     // byte-for-byte at the pos_add.out boundary and upward.
 
-    const int64_t d_model        = hp.enc_d_model;
-    const int64_t n_heads        = hp.enc_n_heads;
-    const int64_t ds_h           = hp.enc_downsample_hidden;
-    const int64_t n_mels         = hp.enc_num_mel_bins;
-    const int64_t mel_per_chunk  = timing.mel_per_chunk;
-    const int64_t n_chunks       = timing.n_chunks;
-    const int64_t T_per_chunk    = timing.per_chunk_aftercnn;
-    const int64_t T_enc_padded   = timing.T_enc_padded;
-    const int64_t T_enc          = timing.T_enc;
+    const int64_t d_model       = hp.enc_d_model;
+    const int64_t n_heads       = hp.enc_n_heads;
+    const int64_t ds_h          = hp.enc_downsample_hidden;
+    const int64_t n_mels        = hp.enc_num_mel_bins;
+    const int64_t mel_per_chunk = timing.mel_per_chunk;
+    const int64_t n_chunks      = timing.n_chunks;
+    const int64_t T_per_chunk   = timing.per_chunk_aftercnn;
+    const int64_t T_enc_padded  = timing.T_enc_padded;
+    const int64_t T_enc         = timing.T_enc;
 
     // ----- Graph inputs -----
     // mel layout: ggml fast-to-slow ne=[mel_per_chunk, n_mels, 1, n_chunks]
@@ -247,20 +234,16 @@ EncoderBuild build_encoder_graph(ggml_context *         ctx,
     // symmetric 3×3 kernel and symmetric stride/pad is invariant under
     // a W/H swap, so this is equivalent to Cohere's time-along-H
     // convention.
-    eb.mel_in = ggml_new_tensor_4d(ctx, GGML_TYPE_F32,
-                                   mel_per_chunk, n_mels, 1, n_chunks);
+    eb.mel_in = ggml_new_tensor_4d(ctx, GGML_TYPE_F32, mel_per_chunk, n_mels, 1, n_chunks);
     named(eb.mel_in, "enc.mel_in");
     ggml_set_input(eb.mel_in);
     eb.dumps.mel_in = eb.mel_in;
 
-    eb.pos_emb_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32,
-                                       d_model, T_per_chunk);
+    eb.pos_emb_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, d_model, T_per_chunk);
     named(eb.pos_emb_in, "enc.pos_emb.in");
     ggml_set_input(eb.pos_emb_in);
 
-    eb.mask_in = ggml_new_tensor_2d(ctx,
-                                    use_flash ? GGML_TYPE_F16 : GGML_TYPE_F32,
-                                    T_enc, T_enc);
+    eb.mask_in = ggml_new_tensor_2d(ctx, use_flash ? GGML_TYPE_F16 : GGML_TYPE_F32, T_enc, T_enc);
     named(eb.mask_in, "enc.attn_mask.in");
     ggml_set_input(eb.mask_in);
 
@@ -277,13 +260,11 @@ EncoderBuild build_encoder_graph(ggml_context *         ctx,
     x = add_conv_bias(ctx, x, weights.enc_subsample.conv0_b);
     x = ggml_gelu_erf(ctx, x);
 
-    x = ggml_conv_2d(ctx, weights.enc_subsample.conv1_w, x,
-                     2, 2, 1, 1, 1, 1);
+    x = ggml_conv_2d(ctx, weights.enc_subsample.conv1_w, x, 2, 2, 1, 1, 1, 1);
     x = add_conv_bias(ctx, x, weights.enc_subsample.conv1_b);
     x = ggml_gelu_erf(ctx, x);
 
-    x = ggml_conv_2d(ctx, weights.enc_subsample.conv2_w, x,
-                     2, 2, 1, 1, 1, 1);
+    x = ggml_conv_2d(ctx, weights.enc_subsample.conv2_w, x, 2, 2, 1, 1, 1, 1);
     x = add_conv_bias(ctx, x, weights.enc_subsample.conv2_b);
     x = ggml_gelu_erf(ctx, x);
     // Now ne = [W=mel_ds, H=n_mels_ds, C=ds_h, N=n_chunks].
@@ -292,10 +273,9 @@ EncoderBuild build_encoder_graph(ggml_context *         ctx,
     const int64_t H_ds = x->ne[1];
     if (W_ds != T_per_chunk) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "qwen3_asr encoder: post-conv W=%lld does not match "
-                     "per_chunk_aftercnn=%lld",
-                     static_cast<long long>(W_ds),
-                     static_cast<long long>(T_per_chunk));
+                "qwen3_asr encoder: post-conv W=%lld does not match "
+                "per_chunk_aftercnn=%lld",
+                static_cast<long long>(W_ds), static_cast<long long>(T_per_chunk));
         return eb;
     }
 
@@ -366,10 +346,8 @@ EncoderBuild build_encoder_graph(ggml_context *         ctx,
     // ----- 18 encoder blocks -----
     const int n_layers = static_cast<int>(weights.enc_blocks.size());
     for (int i = 0; i < n_layers; ++i) {
-        x = build_enc_block(ctx, x, eb.mask_in, weights.enc_blocks[i],
-                            static_cast<int>(d_model),
-                            static_cast<int>(n_heads),
-                            use_flash);
+        x = build_enc_block(ctx, x, eb.mask_in, weights.enc_blocks[i], static_cast<int>(d_model),
+                            static_cast<int>(n_heads), use_flash);
         if (i == 0) {
             named(x, "enc.block.0.out");
             eb.dumps.block_0_out = x;
@@ -403,20 +381,31 @@ EncoderBuild build_encoder_graph(ggml_context *         ctx,
     // leaves headroom for debug-name nodes.
     eb.graph = ggml_new_graph_custom(ctx, /*size=*/8192, /*grads=*/false);
     if (eb.graph == nullptr) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "qwen3_asr encoder: ggml_new_graph_custom failed");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "qwen3_asr encoder: ggml_new_graph_custom failed");
         return eb;
     }
     ggml_build_forward_expand(eb.graph, eb.out);
 
     // Force evaluation of non-output debug tensors so they survive the
     // scheduler's live-range packing and are readable after compute.
-    if (eb.dumps.subsample_out)  ggml_build_forward_expand(eb.graph, eb.dumps.subsample_out);
-    if (eb.dumps.pos_add_out)    ggml_build_forward_expand(eb.graph, eb.dumps.pos_add_out);
-    if (eb.dumps.block_0_out)    ggml_build_forward_expand(eb.graph, eb.dumps.block_0_out);
-    if (eb.dumps.block_last_out) ggml_build_forward_expand(eb.graph, eb.dumps.block_last_out);
-    if (eb.dumps.ln_post_out)    ggml_build_forward_expand(eb.graph, eb.dumps.ln_post_out);
-    if (eb.dumps.proj_out)       ggml_build_forward_expand(eb.graph, eb.dumps.proj_out);
+    if (eb.dumps.subsample_out) {
+        ggml_build_forward_expand(eb.graph, eb.dumps.subsample_out);
+    }
+    if (eb.dumps.pos_add_out) {
+        ggml_build_forward_expand(eb.graph, eb.dumps.pos_add_out);
+    }
+    if (eb.dumps.block_0_out) {
+        ggml_build_forward_expand(eb.graph, eb.dumps.block_0_out);
+    }
+    if (eb.dumps.block_last_out) {
+        ggml_build_forward_expand(eb.graph, eb.dumps.block_last_out);
+    }
+    if (eb.dumps.ln_post_out) {
+        ggml_build_forward_expand(eb.graph, eb.dumps.ln_post_out);
+    }
+    if (eb.dumps.proj_out) {
+        ggml_build_forward_expand(eb.graph, eb.dumps.proj_out);
+    }
 
     return eb;
 }
@@ -426,13 +415,13 @@ EncoderBuildBatched build_encoder_graph_batched(ggml_context *         ctx,
                                                 const QwenAsrHParams & hp,
                                                 int                    n_chunks_max,
                                                 int                    n_batch,
-                                                bool                   use_flash)
-{
-    EncoderBuildBatched eb {};
+                                                bool                   use_flash) {
+    EncoderBuildBatched eb{};
     if (ctx == nullptr || n_chunks_max <= 0 || n_batch <= 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "qwen3_asr encoder(batched): invalid arg "
-                     "(n_chunks_max=%d, n_batch=%d)", n_chunks_max, n_batch);
+                "qwen3_asr encoder(batched): invalid arg "
+                "(n_chunks_max=%d, n_batch=%d)",
+                n_chunks_max, n_batch);
         return eb;
     }
 
@@ -443,7 +432,7 @@ EncoderBuildBatched build_encoder_graph_batched(ggml_context *         ctx,
     const int64_t mel_per_chunk = hp.enc_n_window * 2;
     const int64_t T_per_chunk   = aftercnn_len(static_cast<int32_t>(mel_per_chunk));
     const int64_t B             = n_batch;
-    const int64_t N             = B * n_chunks_max;          // packed conv batch
+    const int64_t N             = B * n_chunks_max;  // packed conv batch
     const int64_t T_pad_max     = n_chunks_max * T_per_chunk;
 
     eb.n_batch      = n_batch;
@@ -452,8 +441,7 @@ EncoderBuildBatched build_encoder_graph_batched(ggml_context *         ctx,
     eb.T_pad_max    = static_cast<int>(T_pad_max);
 
     // ----- Graph inputs -----
-    eb.mel_in = ggml_new_tensor_4d(ctx, GGML_TYPE_F32,
-                                   mel_per_chunk, n_mels, 1, N);
+    eb.mel_in = ggml_new_tensor_4d(ctx, GGML_TYPE_F32, mel_per_chunk, n_mels, 1, N);
     named(eb.mel_in, "enc.mel_in");
     ggml_set_input(eb.mel_in);
 
@@ -462,33 +450,30 @@ EncoderBuildBatched build_encoder_graph_batched(ggml_context *         ctx,
     ggml_set_input(eb.pos_emb_in);
 
     // Key-pad mask: per-utterance [T_pad_max, T_pad_max, 1, B]. Built host-side.
-    eb.mask_in = ggml_new_tensor_4d(ctx,
-                                    use_flash ? GGML_TYPE_F16 : GGML_TYPE_F32,
-                                    T_pad_max, T_pad_max, 1, B);
+    eb.mask_in = ggml_new_tensor_4d(ctx, use_flash ? GGML_TYPE_F16 : GGML_TYPE_F32, T_pad_max, T_pad_max, 1, B);
     named(eb.mask_in, "enc.attn_mask.in");
     ggml_set_input(eb.mask_in);
 
     // ----- Subsample: 3x Conv2d + GELU (per-chunk over N = B*n_chunks_max) -----
     ggml_tensor * x = eb.mel_in;
-    x = ggml_conv_2d(ctx, weights.enc_subsample.conv0_w, x, 2, 2, 1, 1, 1, 1);
-    x = add_conv_bias(ctx, x, weights.enc_subsample.conv0_b);
-    x = ggml_gelu_erf(ctx, x);
-    x = ggml_conv_2d(ctx, weights.enc_subsample.conv1_w, x, 2, 2, 1, 1, 1, 1);
-    x = add_conv_bias(ctx, x, weights.enc_subsample.conv1_b);
-    x = ggml_gelu_erf(ctx, x);
-    x = ggml_conv_2d(ctx, weights.enc_subsample.conv2_w, x, 2, 2, 1, 1, 1, 1);
-    x = add_conv_bias(ctx, x, weights.enc_subsample.conv2_b);
-    x = ggml_gelu_erf(ctx, x);
+    x               = ggml_conv_2d(ctx, weights.enc_subsample.conv0_w, x, 2, 2, 1, 1, 1, 1);
+    x               = add_conv_bias(ctx, x, weights.enc_subsample.conv0_b);
+    x               = ggml_gelu_erf(ctx, x);
+    x               = ggml_conv_2d(ctx, weights.enc_subsample.conv1_w, x, 2, 2, 1, 1, 1, 1);
+    x               = add_conv_bias(ctx, x, weights.enc_subsample.conv1_b);
+    x               = ggml_gelu_erf(ctx, x);
+    x               = ggml_conv_2d(ctx, weights.enc_subsample.conv2_w, x, 2, 2, 1, 1, 1, 1);
+    x               = add_conv_bias(ctx, x, weights.enc_subsample.conv2_b);
+    x               = ggml_gelu_erf(ctx, x);
     // ne = [W=T_per_chunk, H=n_mels_ds, C=ds_h, N].
 
     const int64_t W_ds = x->ne[0];
     const int64_t H_ds = x->ne[1];
     if (W_ds != T_per_chunk) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "qwen3_asr encoder(batched): post-conv W=%lld != "
-                     "per_chunk_aftercnn=%lld",
-                     static_cast<long long>(W_ds),
-                     static_cast<long long>(T_per_chunk));
+                "qwen3_asr encoder(batched): post-conv W=%lld != "
+                "per_chunk_aftercnn=%lld",
+                static_cast<long long>(W_ds), static_cast<long long>(T_per_chunk));
         return eb;
     }
 
@@ -511,8 +496,7 @@ EncoderBuildBatched build_encoder_graph_batched(ggml_context *         ctx,
     // ----- 18 encoder blocks (batch on ne[2], per-utterance key-pad mask) -----
     const int n_layers = static_cast<int>(weights.enc_blocks.size());
     for (int i = 0; i < n_layers; ++i) {
-        x = build_enc_block(ctx, x, eb.mask_in, weights.enc_blocks[i],
-                            static_cast<int>(d_model),
+        x = build_enc_block(ctx, x, eb.mask_in, weights.enc_blocks[i], static_cast<int>(d_model),
                             static_cast<int>(n_heads), use_flash);
     }
 
@@ -528,12 +512,11 @@ EncoderBuildBatched build_encoder_graph_batched(ggml_context *         ctx,
 
     eb.graph = ggml_new_graph_custom(ctx, /*size=*/8192, /*grads=*/false);
     if (eb.graph == nullptr) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "qwen3_asr encoder(batched): ggml_new_graph_custom failed");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "qwen3_asr encoder(batched): ggml_new_graph_custom failed");
         return eb;
     }
     ggml_build_forward_expand(eb.graph, eb.out);
     return eb;
 }
 
-} // namespace transcribe::qwen3_asr
+}  // namespace transcribe::qwen3_asr
diff --git a/src/arch/qwen3_asr/encoder.h b/src/arch/qwen3_asr/encoder.h
index a3d26e15..92db6102 100644
--- a/src/arch/qwen3_asr/encoder.h
+++ b/src/arch/qwen3_asr/encoder.h
@@ -29,9 +29,8 @@
 
 #pragma once
 
-#include "weights.h"
-
 #include "ggml.h"
+#include "weights.h"
 
 #include <vector>
 
@@ -58,20 +57,17 @@ struct EncoderTiming {
 // Apply the 3x stride-2 pad-1 kernel-3 downsampling formula three times.
 int32_t aftercnn_len(int32_t mel_len);
 
-EncoderTiming compute_encoder_timing(int32_t n_mel_frames,
-                                     const QwenAsrHParams & hp);
+EncoderTiming compute_encoder_timing(int32_t n_mel_frames, const QwenAsrHParams & hp);
 
 // Sinusoidal position table, row-major "[length, d_model]" layout.
 // Matches SinusoidsPositionEmbedding: the first d_model/2 channels are
 // sin(p * inv_ts[k]), the second d_model/2 are cos(p * inv_ts[k]).
-std::vector<float> build_sinusoid_pe(int32_t d_model, int32_t length,
-                                     double max_timescale = 10000.0);
+std::vector<float> build_sinusoid_pe(int32_t d_model, int32_t length, double max_timescale = 10000.0);
 
 // Additive attention bias [T_enc, T_enc]. All zeros — full bidirectional
 // attention over the pad-trimmed sequence (the eager baseline, not vLLM's
 // cu_seqlens block-diagonal pattern).
-std::vector<float> build_cu_seqlens_mask(const EncoderTiming & t,
-                                         const QwenAsrHParams & hp);
+std::vector<float> build_cu_seqlens_mask(const EncoderTiming & t, const QwenAsrHParams & hp);
 
 struct EncoderDumps {
     ggml_tensor * mel_in         = nullptr;  // graph input
@@ -88,9 +84,9 @@ struct EncoderBuild {
     ggml_tensor * pos_emb_in = nullptr;  // [d_model, per_chunk_aftercnn]
     ggml_tensor * mask_in    = nullptr;  // [T_enc, T_enc]
     ggml_tensor * out        = nullptr;  // [output_dim, T_enc]
-    EncoderDumps  dumps {};
-    ggml_cgraph * graph      = nullptr;
-    EncoderTiming timing {};
+    EncoderDumps  dumps{};
+    ggml_cgraph * graph = nullptr;
+    EncoderTiming timing{};
 };
 
 EncoderBuild build_encoder_graph(ggml_context *         ctx,
@@ -110,10 +106,10 @@ struct EncoderBuildBatched {
     ggml_tensor * out        = nullptr;  // [output_dim, T_pad_max, B]
     ggml_cgraph * graph      = nullptr;
 
-    int n_batch       = 0;
-    int n_chunks_max  = 0;
-    int T_per_chunk   = 0;
-    int T_pad_max     = 0;  // n_chunks_max * per_chunk_aftercnn
+    int n_batch      = 0;
+    int n_chunks_max = 0;
+    int T_per_chunk  = 0;
+    int T_pad_max    = 0;  // n_chunks_max * per_chunk_aftercnn
 };
 
 // Build one encoder graph that processes B utterances in parallel on the
@@ -135,4 +131,4 @@ EncoderBuildBatched build_encoder_graph_batched(ggml_context *         ctx,
                                                 int                    n_batch,
                                                 bool                   use_flash = false);
 
-} // namespace transcribe::qwen3_asr
+}  // namespace transcribe::qwen3_asr
diff --git a/src/arch/qwen3_asr/model.cpp b/src/arch/qwen3_asr/model.cpp
index 2b55d245..f208e946 100644
--- a/src/arch/qwen3_asr/model.cpp
+++ b/src/arch/qwen3_asr/model.cpp
@@ -1,12 +1,12 @@
 // arch/qwen3_asr/model.cpp - Qwen3-ASR family handler.
 
-#include "qwen3_asr.h"
-
+#include "causal_lm/causal_lm.h"
 #include "decoder.h"
 #include "encoder.h"
-#include "weights.h"
-
-#include "causal_lm/causal_lm.h"
+#include "ggml-backend.h"
+#include "ggml.h"
+#include "gguf.h"
+#include "qwen3_asr.h"
 #include "transcribe-arch.h"
 #include "transcribe-batch-util.h"
 #include "transcribe-debug.h"
@@ -17,17 +17,14 @@
 #include "transcribe-log.h"
 #include "transcribe-mel.h"
 #include "transcribe-meta.h"
-
-#include "ggml.h"
-#include "ggml-backend.h"
-#include "gguf.h"
+#include "weights.h"
 
 #include <algorithm>
+#include <cmath>
 #include <cstdint>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
-#include <cmath>
 #include <limits>
 #include <memory>
 #include <string>
@@ -40,7 +37,7 @@ namespace transcribe::qwen3_asr {
 
 extern const Arch arch;
 
-static_assert(std::is_base_of_v<transcribe_model,   QwenAsrModel>);
+static_assert(std::is_base_of_v<transcribe_model, QwenAsrModel>);
 static_assert(std::is_base_of_v<transcribe_session, QwenAsrSession>);
 
 QwenAsrSession::~QwenAsrSession() {
@@ -66,9 +63,7 @@ QwenAsrModel::~QwenAsrModel() {
         backend_buffer = nullptr;
     }
     packed_gate_up.free();
-    for (auto it = plan.scheduler_list.rbegin();
-         it != plan.scheduler_list.rend(); ++it)
-    {
+    for (auto it = plan.scheduler_list.rbegin(); it != plan.scheduler_list.rend(); ++it) {
         ggml_backend_free(*it);
     }
     plan.scheduler_list.clear();
@@ -108,13 +103,11 @@ int qwen3_context_ceiling(int32_t n_ctx_knob, const QwenAsrHParams & hp) {
 // within this bound a long transcript may truncate at the generation budget
 // (transcribe_was_truncated) — max_audio_ms is the input bound.
 int64_t qwen3_max_audio_ms(const QwenAsrHParams & hp) {
-    if (hp.dec_max_position_embeddings <= 0 ||
-        hp.fe_hop_length <= 0 || hp.fe_sample_rate <= 0) {
+    if (hp.dec_max_position_embeddings <= 0 || hp.fe_hop_length <= 0 || hp.fe_sample_rate <= 0) {
         return 0;
     }
     constexpr int k_prompt_overhead = 48;  // chat affixes; advisory
-    const int max_audio_tokens =
-        hp.dec_max_position_embeddings - k_prompt_overhead - k_max_new;
+    const int     max_audio_tokens  = hp.dec_max_position_embeddings - k_prompt_overhead - k_max_new;
     if (max_audio_tokens <= 0) {
         return 0;
     }
@@ -125,17 +118,12 @@ int64_t qwen3_max_audio_ms(const QwenAsrHParams & hp) {
 }
 
 // Forward declarations for helpers defined further down in this file.
-transcribe_status resolve_chat_tokens(const transcribe::Tokenizer & tok,
-                                      ChatTokens &                  out);
-
-transcribe_status load(
-    Loader &                         loader,
-    const transcribe_model_load_params *  params,
-    transcribe_model **              out_model)
-{
+transcribe_status resolve_chat_tokens(const transcribe::Tokenizer & tok, ChatTokens & out);
+
+transcribe_status load(Loader & loader, const transcribe_model_load_params * params, transcribe_model ** out_model) {
     const int64_t t_load_start = ggml_time_us();
 
-    auto m = std::make_unique<QwenAsrModel>();
+    auto m       = std::make_unique<QwenAsrModel>();
     m->arch      = &arch;
     m->t_load_us = 0;
     m->variant   = loader.variant().empty() ? k_default_variant : loader.variant();
@@ -145,27 +133,30 @@ transcribe_status load(
     m->caps.n_languages = 0;
     m->caps.languages   = nullptr;
 
-    if (const transcribe_status st = read_capability_kv(loader.gguf(), m->caps);
-        st != TRANSCRIBE_OK) return st;
-    if (const transcribe_status st = read_languages_kv(loader.gguf(), *m);
-        st != TRANSCRIBE_OK) return st;
+    if (const transcribe_status st = read_capability_kv(loader.gguf(), m->caps); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (const transcribe_status st = read_languages_kv(loader.gguf(), *m); st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Tokenizer (byte-level BPE; loader handles the "gpt2" model tag).
-    if (const transcribe_status st = m->tok.load(loader.gguf());
-        st != TRANSCRIBE_OK) return st;
+    if (const transcribe_status st = m->tok.load(loader.gguf()); st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Chat template (read here so its absence surfaces at load, not mid-decode).
-    (void)read_optional_string_kv(
-        loader.gguf(), "tokenizer.chat_template", "qwen3_asr",
-        "", m->chat_template);
+    (void) read_optional_string_kv(loader.gguf(), "tokenizer.chat_template", "qwen3_asr", "", m->chat_template);
 
     // Resolve chat-template special-token ids at load so a vocab drift surfaces
     // here instead of silently producing a wrong prompt at decode time.
-    if (const transcribe_status st = resolve_chat_tokens(m->tok, m->chat_tokens);
-        st != TRANSCRIBE_OK) return st;
+    if (const transcribe_status st = resolve_chat_tokens(m->tok, m->chat_tokens); st != TRANSCRIBE_OK) {
+        return st;
+    }
 
-    if (const transcribe_status st = read_qwen3_asr_hparams(loader.gguf(), m->hparams);
-        st != TRANSCRIBE_OK) return st;
+    if (const transcribe_status st = read_qwen3_asr_hparams(loader.gguf(), m->hparams); st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Publish the input-length ceiling now that the decoder context window
     // and frontend rate are known.
@@ -173,18 +164,15 @@ transcribe_status load(
 
     // Basis for transcribe_session_get_limits: the same constants
     // qwen3_max_audio_ms uses, so the limit recomputes at a lowered n_ctx.
-    if (m->hparams.dec_max_position_embeddings > 0 &&
-        m->hparams.fe_hop_length > 0 && m->hparams.fe_sample_rate > 0) {
-        m->limits.has_context_cap = true;
-        m->limits.model_max_ctx   = m->hparams.dec_max_position_embeddings;
-        m->limits.prompt_overhead = 48;
-        m->limits.gen_reserve     = k_max_new;
+    if (m->hparams.dec_max_position_embeddings > 0 && m->hparams.fe_hop_length > 0 && m->hparams.fe_sample_rate > 0) {
+        m->limits.has_context_cap    = true;
+        m->limits.model_max_ctx      = m->hparams.dec_max_position_embeddings;
+        m->limits.prompt_overhead    = 48;
+        m->limits.gen_reserve        = k_max_new;
         // audio_tokens ≈ mel_frames / 8 ; mel_frames = ms*sr/(hop*1000)
-        m->limits.ms_per_audio_token =
-            8.0 * m->hparams.fe_hop_length * 1000.0 / m->hparams.fe_sample_rate;
+        m->limits.ms_per_audio_token = 8.0 * m->hparams.fe_hop_length * 1000.0 / m->hparams.fe_sample_rate;
         m->limits.kv_elems_per_ctx_token =
-            (int64_t) m->hparams.dec_n_kv_heads *
-            m->hparams.dec_head_dim * m->hparams.dec_n_layers * 2;
+            (int64_t) m->hparams.dec_n_kv_heads * m->hparams.dec_head_dim * m->hparams.dec_n_layers * 2;
     }
 
     m->hparams.vocab_size   = m->tok.n_tokens();
@@ -192,20 +180,18 @@ transcribe_status load(
     m->hparams.eos_token_id = m->tok.eos_id();
 
     if (m->hparams.vocab_size != m->hparams.dec_vocab_size) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "qwen3_asr: tokenizer vocab (%d) != decoder vocab_size (%d)",
-                     m->hparams.vocab_size, m->hparams.dec_vocab_size);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "qwen3_asr: tokenizer vocab (%d) != decoder vocab_size (%d)",
+                m->hparams.vocab_size, m->hparams.dec_vocab_size);
         return TRANSCRIBE_ERR_GGUF;
     }
     if (m->hparams.eos_token_id < 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "qwen3_asr: GGUF tokenizer has no eos_token_id");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "qwen3_asr: GGUF tokenizer has no eos_token_id");
         return TRANSCRIBE_ERR_GGUF;
     }
 
     // Mel frontend (Whisper-style 128-bin log-mel at 16 kHz, 30 s max).
     {
-        transcribe::MelConfig cfg {};
+        transcribe::MelConfig cfg{};
         cfg.sample_rate  = m->hparams.fe_sample_rate;
         cfg.num_mels     = m->hparams.fe_num_mels;
         cfg.n_fft        = m->hparams.fe_n_fft;
@@ -221,22 +207,16 @@ transcribe_status load(
         // Optional filterbank + window buffers baked by the converter; if
         // present MelFrontend uses them instead of reconstructing from hparams.
         {
-            using R = transcribe::load_common::ReadF32Result;
-            const size_t fb_elems =
-                static_cast<size_t>(cfg.num_mels) *
-                static_cast<size_t>(cfg.n_fft / 2 + 1);
-            const auto fb_rc = transcribe::load_common::read_f32_tensor_checked(
-                loader.gguf(), loader.path(),
-                "frontend.mel_filterbank", fb_elems,
-                "qwen3_asr", cfg.filterbank);
+            using R               = transcribe::load_common::ReadF32Result;
+            const size_t fb_elems = static_cast<size_t>(cfg.num_mels) * static_cast<size_t>(cfg.n_fft / 2 + 1);
+            const auto   fb_rc    = transcribe::load_common::read_f32_tensor_checked(
+                loader.gguf(), loader.path(), "frontend.mel_filterbank", fb_elems, "qwen3_asr", cfg.filterbank);
             if (fb_rc != R::Ok && fb_rc != R::Absent) {
                 return TRANSCRIBE_ERR_GGUF;
             }
             const size_t win_elems = static_cast<size_t>(cfg.win_length);
-            const auto win_rc = transcribe::load_common::read_f32_tensor_checked(
-                loader.gguf(), loader.path(),
-                "frontend.window", win_elems,
-                "qwen3_asr", cfg.window);
+            const auto   win_rc    = transcribe::load_common::read_f32_tensor_checked(
+                loader.gguf(), loader.path(), "frontend.window", win_elems, "qwen3_asr", cfg.window);
             if (win_rc != R::Ok && win_rc != R::Absent) {
                 return TRANSCRIBE_ERR_GGUF;
             }
@@ -246,53 +226,44 @@ transcribe_status load(
     }
 
     // Reopen with no_alloc to build the tensor catalog.
-    gguf_init_params init_params {};
+    gguf_init_params init_params{};
     init_params.no_alloc = true;
     init_params.ctx      = &m->ctx_meta;
 
-    gguf_context * gguf_data = gguf_init_from_file(loader.path().c_str(),
-                                                   init_params);
+    gguf_context * gguf_data = gguf_init_from_file(loader.path().c_str(), init_params);
     if (gguf_data == nullptr) {
         return TRANSCRIBE_ERR_GGUF;
     }
 
-    if (const transcribe_status st = build_qwen3_asr_weights(
-            m->ctx_meta, m->hparams, m->weights);
-        st != TRANSCRIBE_OK)
-    {
+    if (const transcribe_status st = build_qwen3_asr_weights(m->ctx_meta, m->hparams, m->weights);
+        st != TRANSCRIBE_OK) {
         gguf_free(gguf_data);
         return st;
     }
 
     // Backend plan.
-    const transcribe_backend_request backend_req =
-        (params != nullptr) ? params->backend : TRANSCRIBE_BACKEND_AUTO;
+    const transcribe_backend_request backend_req = (params != nullptr) ? params->backend : TRANSCRIBE_BACKEND_AUTO;
     if (const transcribe_status st = transcribe::load_common::init_backends(
             backend_req, (params != nullptr) ? params->gpu_device : 0, "qwen3_asr", m->plan);
-        st != TRANSCRIBE_OK)
-    {
+        st != TRANSCRIBE_OK) {
         gguf_free(gguf_data);
         return st;
     }
-    m->backend = ggml_backend_name(m->plan.primary);
+    m->backend         = ggml_backend_name(m->plan.primary);
     m->primary_backend = m->plan.primary;
 
-    ggml_backend_buffer_t weights_buffer =
-        ggml_backend_alloc_ctx_tensors(m->ctx_meta, m->plan.primary);
+    ggml_backend_buffer_t weights_buffer = ggml_backend_alloc_ctx_tensors(m->ctx_meta, m->plan.primary);
     if (weights_buffer == nullptr) {
         gguf_free(gguf_data);
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "qwen3_asr: ggml_backend_alloc_ctx_tensors failed");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "qwen3_asr: ggml_backend_alloc_ctx_tensors failed");
         return TRANSCRIBE_ERR_GGUF;
     }
     m->backend_buffer = weights_buffer;
-    ggml_backend_buffer_set_usage(weights_buffer,
-                                  GGML_BACKEND_BUFFER_USAGE_WEIGHTS);
+    ggml_backend_buffer_set_usage(weights_buffer, GGML_BACKEND_BUFFER_USAGE_WEIGHTS);
 
-    if (const transcribe_status st = transcribe::load_common::stream_tensor_data(
-            loader.path(), gguf_data, m->ctx_meta, "qwen3_asr");
-        st != TRANSCRIBE_OK)
-    {
+    if (const transcribe_status st =
+            transcribe::load_common::stream_tensor_data(loader.path(), gguf_data, m->ctx_meta, "qwen3_asr");
+        st != TRANSCRIBE_OK) {
         gguf_free(gguf_data);
         return st;
     }
@@ -306,36 +277,28 @@ transcribe_status load(
         std::vector<transcribe::causal_lm::GateUpEntry> entries;
         entries.reserve(m->weights.dec_blocks.size());
         for (auto & b : m->weights.dec_blocks) {
-            entries.push_back({b.ffn_gate_w, b.ffn_up_w, &b.ffn_gate_up_w});
+            entries.push_back({ b.ffn_gate_w, b.ffn_up_w, &b.ffn_gate_up_w });
         }
-        if (!transcribe::causal_lm::pack_gate_up(
-                m->plan.primary,
-                m->hparams.dec_hidden,
-                m->hparams.dec_intermediate,
-                entries,
-                m->packed_gate_up,
-                "qwen3_asr"))
-        {
+        if (!transcribe::causal_lm::pack_gate_up(m->plan.primary, m->hparams.dec_hidden, m->hparams.dec_intermediate,
+                                                 entries, m->packed_gate_up, "qwen3_asr")) {
             m->packed_gate_up.free();
             return TRANSCRIBE_ERR_GGUF;
         }
     }
 
     m->t_load_us = ggml_time_us() - t_load_start;
-    *out_model = m.release();
+    *out_model   = m.release();
     return TRANSCRIBE_OK;
 }
 
-transcribe_status init_context(
-    transcribe_model *                model,
-    const transcribe_session_params * params,
-    transcribe_session **             out_ctx)
-{
+transcribe_status init_context(transcribe_model *                model,
+                               const transcribe_session_params * params,
+                               transcribe_session **             out_ctx) {
     if (model->arch != &arch) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
 
-    auto cc = std::make_unique<QwenAsrSession>();
+    auto cc       = std::make_unique<QwenAsrSession>();
     cc->model     = model;
     cc->n_threads = params->n_threads;
     cc->kv_type   = params->kv_type;
@@ -350,20 +313,17 @@ transcribe_status init_context(
     auto * cm = static_cast<QwenAsrModel *>(model);
     {
         ggml_type kv_type = GGML_TYPE_F16;
-        if (cc->kv_type == TRANSCRIBE_KV_TYPE_F32) kv_type = GGML_TYPE_F32;
+        if (cc->kv_type == TRANSCRIBE_KV_TYPE_F32) {
+            kv_type = GGML_TYPE_F32;
+        }
         if (!transcribe::causal_lm::kv_init(cc->kv_cache, cm->plan.primary,
-                                           /*n_ctx=*/2048,
-                                           cm->hparams.dec_n_kv_heads,
-                                           cm->hparams.dec_head_dim,
-                                           cm->hparams.dec_n_layers,
-                                           kv_type))
-        {
+                                            /*n_ctx=*/2048, cm->hparams.dec_n_kv_heads, cm->hparams.dec_head_dim,
+                                            cm->hparams.dec_n_layers, kv_type)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "qwen3_asr init_context: KV cache allocation failed "
-                "(n_ctx=2048, %d kv-heads x %d head-dim x %d layers) — "
-                "out of memory.",
-                cm->hparams.dec_n_kv_heads, cm->hparams.dec_head_dim,
-                cm->hparams.dec_n_layers);
+                                "qwen3_asr init_context: KV cache allocation failed "
+                                "(n_ctx=2048, %d kv-heads x %d head-dim x %d layers) — "
+                                "out of memory.",
+                                cm->hparams.dec_n_kv_heads, cm->hparams.dec_head_dim, cm->hparams.dec_n_layers);
             return TRANSCRIBE_ERR_OOM;
         }
     }
@@ -376,27 +336,24 @@ transcribe_status init_context(
 // Hard-fails with TRANSCRIBE_ERR_GGUF on a missing piece (a vocab reorder
 // surfaces here at load). The newline is stored in its GPT-2 byte-level form
 // (\n → U+010A "Ċ", \xC4\x8A); roles and <|im_*|> tokens are verbatim.
-transcribe_status resolve_chat_tokens(const transcribe::Tokenizer & tok,
-                                      ChatTokens &                  out)
-{
+transcribe_status resolve_chat_tokens(const transcribe::Tokenizer & tok, ChatTokens & out) {
     struct PieceSlot {
         const char * piece;
         int32_t *    slot;
     };
+
     const PieceSlot pieces[] = {
-        { "<|im_start|>",  &out.im_start       },
-        { "<|im_end|>",    &out.im_end         },
-        { "\xC4\x8A",      &out.newline        },   // "Ċ" = byte-level \n
-        { "system",        &out.role_system    },
-        { "user",          &out.role_user      },
-        { "assistant",     &out.role_assistant },
+        { "<|im_start|>", &out.im_start       },
+        { "<|im_end|>",   &out.im_end         },
+        { "\xC4\x8A",     &out.newline        }, // "Ċ" = byte-level \n
+        { "system",       &out.role_system    },
+        { "user",         &out.role_user      },
+        { "assistant",    &out.role_assistant },
     };
     for (const auto & p : pieces) {
         const int id = tok.find(p.piece);
         if (id < 0) {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "qwen3_asr: chat-template piece \"%s\" not in tokenizer",
-                         p.piece);
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "qwen3_asr: chat-template piece \"%s\" not in tokenizer", p.piece);
             return TRANSCRIBE_ERR_GGUF;
         }
         *p.slot = id;
@@ -414,13 +371,12 @@ transcribe_status resolve_chat_tokens(const transcribe::Tokenizer & tok,
 // System prompt is empty. A non-null `lang_prefix_ids` (resolved via
 // encode_language_prefix) is appended after the trailing newline to force an
 // output language; kept out of here so this stays a pure token-id assembler.
-void build_prompt_tokens(const QwenAsrHParams &           hp,
-                         const ChatTokens &               ct,
-                         int                              T_enc,
-                         const std::vector<int32_t> *     lang_prefix_ids,
-                         std::vector<int32_t> &           out_ids,
-                         std::vector<int64_t> &           out_audio_positions)
-{
+void build_prompt_tokens(const QwenAsrHParams &       hp,
+                         const ChatTokens &           ct,
+                         int                          T_enc,
+                         const std::vector<int32_t> * lang_prefix_ids,
+                         std::vector<int32_t> &       out_ids,
+                         std::vector<int64_t> &       out_audio_positions) {
     out_ids.clear();
     out_audio_positions.clear();
 
@@ -450,14 +406,13 @@ void build_prompt_tokens(const QwenAsrHParams &           hp,
     out_ids.push_back(ct.newline);
 
     if (lang_prefix_ids != nullptr && !lang_prefix_ids->empty()) {
-        out_ids.insert(out_ids.end(),
-                       lang_prefix_ids->begin(),
-                       lang_prefix_ids->end());
+        out_ids.insert(out_ids.end(), lang_prefix_ids->begin(), lang_prefix_ids->end());
     }
 }
 
-} // namespace  (close anon temporarily for the two external-linkage helpers
-  // below; encode_language_prefix matches the qwen3_asr.h declaration.)
+}  // namespace
+
+// below; encode_language_prefix matches the qwen3_asr.h declaration.)
 
 // BCP-47 → publisher canonical name ("English", "Chinese", ...), which the
 // prompt renders instead of the code. Frozen per release
@@ -467,37 +422,38 @@ struct LangNameEntry {
     const char * bcp47;
     const char * pub_name;
 };
+
 constexpr LangNameEntry k_qwen3_asr_language_names[] = {
-    {"zh",  "Chinese"},
-    {"en",  "English"},
-    {"yue", "Cantonese"},
-    {"ar",  "Arabic"},
-    {"de",  "German"},
-    {"fr",  "French"},
-    {"es",  "Spanish"},
-    {"pt",  "Portuguese"},
-    {"id",  "Indonesian"},
-    {"it",  "Italian"},
-    {"ko",  "Korean"},
-    {"ru",  "Russian"},
-    {"th",  "Thai"},
-    {"vi",  "Vietnamese"},
-    {"ja",  "Japanese"},
-    {"tr",  "Turkish"},
-    {"hi",  "Hindi"},
-    {"ms",  "Malay"},
-    {"nl",  "Dutch"},
-    {"sv",  "Swedish"},
-    {"da",  "Danish"},
-    {"fi",  "Finnish"},
-    {"pl",  "Polish"},
-    {"cs",  "Czech"},
-    {"fil", "Filipino"},
-    {"fa",  "Persian"},
-    {"el",  "Greek"},
-    {"ro",  "Romanian"},
-    {"hu",  "Hungarian"},
-    {"mk",  "Macedonian"},
+    { "zh",  "Chinese"    },
+    { "en",  "English"    },
+    { "yue", "Cantonese"  },
+    { "ar",  "Arabic"     },
+    { "de",  "German"     },
+    { "fr",  "French"     },
+    { "es",  "Spanish"    },
+    { "pt",  "Portuguese" },
+    { "id",  "Indonesian" },
+    { "it",  "Italian"    },
+    { "ko",  "Korean"     },
+    { "ru",  "Russian"    },
+    { "th",  "Thai"       },
+    { "vi",  "Vietnamese" },
+    { "ja",  "Japanese"   },
+    { "tr",  "Turkish"    },
+    { "hi",  "Hindi"      },
+    { "ms",  "Malay"      },
+    { "nl",  "Dutch"      },
+    { "sv",  "Swedish"    },
+    { "da",  "Danish"     },
+    { "fi",  "Finnish"    },
+    { "pl",  "Polish"     },
+    { "cs",  "Czech"      },
+    { "fil", "Filipino"   },
+    { "fa",  "Persian"    },
+    { "el",  "Greek"      },
+    { "ro",  "Romanian"   },
+    { "hu",  "Hungarian"  },
+    { "mk",  "Macedonian" },
 };
 
 // Resolve a caller-supplied BCP-47 code to the token-id sequence the chat
@@ -508,8 +464,7 @@ constexpr LangNameEntry k_qwen3_asr_language_names[] = {
 // code here means converter/map drift — surface as UNSUPPORTED_LANGUAGE.
 transcribe_status encode_language_prefix(const transcribe::Tokenizer & tok,
                                          const char *                  bcp47,
-                                         std::vector<int32_t> &        out_ids)
-{
+                                         std::vector<int32_t> &        out_ids) {
     out_ids.clear();
     if (bcp47 == nullptr || bcp47[0] == '\0') {
         return TRANSCRIBE_ERR_INVALID_ARG;
@@ -523,28 +478,27 @@ transcribe_status encode_language_prefix(const transcribe::Tokenizer & tok,
     }
     if (pub_name == nullptr) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "qwen3_asr: no canonical publisher name for "
-                     "language=\"%s\"", bcp47);
+                "qwen3_asr: no canonical publisher name for "
+                "language=\"%s\"",
+                bcp47);
         return TRANSCRIBE_ERR_UNSUPPORTED_LANGUAGE;
     }
     if (!tok.has_encoder()) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "qwen3_asr: tokenizer missing encoder (merges "
-                     "unavailable); cannot render language hint");
+                "qwen3_asr: tokenizer missing encoder (merges "
+                "unavailable); cannot render language hint");
         return TRANSCRIBE_ERR_GGUF;
     }
     const int asr_text_id = tok.find("<asr_text>");
     if (asr_text_id < 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "qwen3_asr: tokenizer vocab missing <asr_text> "
-                     "special token");
+                "qwen3_asr: tokenizer vocab missing <asr_text> "
+                "special token");
         return TRANSCRIBE_ERR_GGUF;
     }
     std::string text = "language ";
     text += pub_name;
-    if (const transcribe_status st = tok.encode(text, out_ids);
-        st != TRANSCRIBE_OK)
-    {
+    if (const transcribe_status st = tok.encode(text, out_ids); st != TRANSCRIBE_OK) {
         return st;
     }
     out_ids.push_back(asr_text_id);
@@ -556,37 +510,30 @@ namespace {  // reopen anon for the rest of the file's helpers.
 // Host-side pack [n_mels, T_mel] mel into batched chunks
 // [mel_per_chunk, n_mels, 1, n_chunks]. Chunks shorter than
 // mel_per_chunk are zero-padded.
-void pack_mel_chunks(const float *         mel,       // [n_mels, T_mel]
+void pack_mel_chunks(const float *         mel,  // [n_mels, T_mel]
                      int                   n_mels,
                      int                   n_mel_frames,
                      const EncoderTiming & t,
-                     std::vector<float> &  out)
-{
+                     std::vector<float> &  out) {
     const size_t per_chunk_elems = static_cast<size_t>(t.mel_per_chunk) * n_mels;
     out.assign(per_chunk_elems * t.n_chunks, 0.0f);
 
     for (int c = 0; c < t.n_chunks; ++c) {
-        const int tail = (c == t.n_chunks - 1)
-                       ? t.last_chunk_real_mel : t.mel_per_chunk;
+        const int tail = (c == t.n_chunks - 1) ? t.last_chunk_real_mel : t.mel_per_chunk;
         for (int m = 0; m < n_mels; ++m) {
-            const float * src = mel
-                + static_cast<size_t>(m) * n_mel_frames
-                + static_cast<size_t>(c) * t.mel_per_chunk;
-            float * dst = out.data()
-                + static_cast<size_t>(c) * per_chunk_elems
-                + static_cast<size_t>(m) * t.mel_per_chunk;
+            const float * src = mel + static_cast<size_t>(m) * n_mel_frames + static_cast<size_t>(c) * t.mel_per_chunk;
+            float *       dst =
+                out.data() + static_cast<size_t>(c) * per_chunk_elems + static_cast<size_t>(m) * t.mel_per_chunk;
             std::memcpy(dst, src, tail * sizeof(float));
             // trailing frames in the tail chunk stay 0.0 (zero pad).
         }
     }
 }
 
-transcribe_status run(
-    transcribe_session *      session,
-    const float *             pcm,
-    int                       n_samples,
-    const transcribe_run_params * params)
-{
+transcribe_status run(transcribe_session *          session,
+                      const float *                 pcm,
+                      int                           n_samples,
+                      const transcribe_run_params * params) {
     if (session == nullptr || pcm == nullptr || n_samples <= 0) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
@@ -607,15 +554,11 @@ transcribe_status run(
     // "language X<asr_text>" prefix, stripped by the output parser below). A
     // non-null code is resolved to "language {Name}<asr_text>" tokens that seed
     // the assistant turn; a resolve failure surfaces as UNSUPPORTED_LANGUAGE.
-    std::vector<int32_t> lang_prefix_ids;
+    std::vector<int32_t>         lang_prefix_ids;
     const std::vector<int32_t> * lang_prefix_ptr = nullptr;
-    if (params != nullptr && params->language != nullptr &&
-        params->language[0] != '\0')
-    {
-        if (const transcribe_status st = encode_language_prefix(
-                cm->tok, params->language, lang_prefix_ids);
-            st != TRANSCRIBE_OK)
-        {
+    if (params != nullptr && params->language != nullptr && params->language[0] != '\0') {
+        if (const transcribe_status st = encode_language_prefix(cm->tok, params->language, lang_prefix_ids);
+            st != TRANSCRIBE_OK) {
             return st;
         }
         lang_prefix_ptr = &lang_prefix_ids;
@@ -625,22 +568,17 @@ transcribe_status run(
 
     // Mel front-end.
     if (!cm->mel.has_value()) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "qwen3_asr run: model has no MelFrontend");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "qwen3_asr run: model has no MelFrontend");
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
-    const int64_t t_mel_start = ggml_time_us();
-    int mel_n_mels   = 0;
-    int mel_n_frames = 0;
-    if (const transcribe_status mst = cm->mel->compute(
-            pcm, static_cast<size_t>(n_samples),
-            cc->mel_buf, mel_n_mels, mel_n_frames,
-            cc->n_threads);
-        mst != TRANSCRIBE_OK)
-    {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "qwen3_asr run: MelFrontend::compute failed (%s)",
-                     transcribe_status_string(mst));
+    const int64_t t_mel_start  = ggml_time_us();
+    int           mel_n_mels   = 0;
+    int           mel_n_frames = 0;
+    if (const transcribe_status mst =
+            cm->mel->compute(pcm, static_cast<size_t>(n_samples), cc->mel_buf, mel_n_mels, mel_n_frames, cc->n_threads);
+        mst != TRANSCRIBE_OK) {
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "qwen3_asr run: MelFrontend::compute failed (%s)",
+                transcribe_status_string(mst));
         return mst;
     }
     cc->t_mel_us = ggml_time_us() - t_mel_start;
@@ -650,18 +588,17 @@ transcribe_status run(
     // the same data, so the comparison point lives on the host.
     if (transcribe::debug::enabled()) {
         const long long shape[2] = { mel_n_mels, mel_n_frames };
-        transcribe::debug::dump_host_f32(
-            "enc.mel.in", cc->mel_buf.data(),
-            static_cast<long long>(cc->mel_buf.size()),
-            shape, 2, "frontend.mel.norm");
+        transcribe::debug::dump_host_f32("enc.mel.in", cc->mel_buf.data(), static_cast<long long>(cc->mel_buf.size()),
+                                         shape, 2, "frontend.mel.norm");
     }
 
     // Compute encoder timing + reject unsupported shapes.
     EncoderTiming timing = compute_encoder_timing(mel_n_frames, cm->hparams);
     if (timing.n_chunks <= 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "qwen3_asr run: encoder timing is degenerate "
-                     "(n_mel_frames=%d)", mel_n_frames);
+                "qwen3_asr run: encoder timing is degenerate "
+                "(n_mel_frames=%d)",
+                mel_n_frames);
         return TRANSCRIBE_ERR_GGUF;
     }
 
@@ -669,14 +606,14 @@ transcribe_status run(
     // per-run cost (graph build, sched alloc, uploads, prefill compute)
     // that the public transcribe_timings (mel/encode/decode) doesn't
     // expose, for the TRANSCRIBE_PERF_DEBUG breakdown.
-    const int64_t t_enc_build_start = ggml_time_us();
-    int64_t t_enc_build_us       = 0;
-    int64_t t_enc_d2h_us         = 0;
-    int64_t t_prefill_build_us   = 0;
-    int64_t t_prefill_compute_us = 0;
-    int64_t t_prefill_logits_us  = 0;
-    int64_t t_step_loop_us       = 0;
-    int     n_steps              = 0;
+    const int64_t t_enc_build_start    = ggml_time_us();
+    int64_t       t_enc_build_us       = 0;
+    int64_t       t_enc_d2h_us         = 0;
+    int64_t       t_prefill_build_us   = 0;
+    int64_t       t_prefill_compute_us = 0;
+    int64_t       t_prefill_logits_us  = 0;
+    int64_t       t_step_loop_us       = 0;
+    int           n_steps              = 0;
 
     if (cc->compute_ctx != nullptr) {
         ggml_free(cc->compute_ctx);
@@ -684,58 +621,48 @@ transcribe_status run(
     }
 
     {
-        ggml_init_params ip {};
-        ip.mem_size   = 16 * 1024 * 1024;
-        ip.mem_buffer = nullptr;
-        ip.no_alloc   = true;
+        ggml_init_params ip{};
+        ip.mem_size     = 16 * 1024 * 1024;
+        ip.mem_buffer   = nullptr;
+        ip.no_alloc     = true;
         cc->compute_ctx = ggml_init(ip);
         if (cc->compute_ctx == nullptr) {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "qwen3_asr run: ggml_init for compute_ctx failed");
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "qwen3_asr run: ggml_init for compute_ctx failed");
             return TRANSCRIBE_ERR_GGUF;
         }
     }
 
     // Build encoder graph.
-    EncoderBuild eb = build_encoder_graph(cc->compute_ctx, cm->weights,
-                                          cm->hparams, timing,
-                                          cc->encoder_use_flash);
+    EncoderBuild eb = build_encoder_graph(cc->compute_ctx, cm->weights, cm->hparams, timing, cc->encoder_use_flash);
     if (eb.graph == nullptr || eb.out == nullptr) {
         return TRANSCRIBE_ERR_GGUF;
     }
 
     // Allocate + compute encoder graph.
     if (cc->sched == nullptr) {
-        cc->sched = ggml_backend_sched_new(
-            cm->plan.scheduler_list.data(), nullptr,
-            static_cast<int>(cm->plan.scheduler_list.size()),
-            16384, false, true);
+        cc->sched = ggml_backend_sched_new(cm->plan.scheduler_list.data(), nullptr,
+                                           static_cast<int>(cm->plan.scheduler_list.size()), 16384, false, true);
         if (cc->sched == nullptr) {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "qwen3_asr run: ggml_backend_sched_new failed");
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "qwen3_asr run: ggml_backend_sched_new failed");
             return TRANSCRIBE_ERR_GGUF;
         }
     }
     ggml_backend_sched_reset(cc->sched);
     if (!ggml_backend_sched_alloc_graph(cc->sched, eb.graph)) {
         transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "qwen3_asr run: encoder graph allocation failed — out of memory.");
+                            "qwen3_asr run: encoder graph allocation failed — out of memory.");
         return TRANSCRIBE_ERR_OOM;
     }
 
     // Pack + upload mel.
     std::vector<float> mel_batched;
-    pack_mel_chunks(cc->mel_buf.data(), mel_n_mels, mel_n_frames,
-                    timing, mel_batched);
-    ggml_backend_tensor_set(eb.mel_in, mel_batched.data(),
-                            0, mel_batched.size() * sizeof(float));
+    pack_mel_chunks(cc->mel_buf.data(), mel_n_mels, mel_n_frames, timing, mel_batched);
+    ggml_backend_tensor_set(eb.mel_in, mel_batched.data(), 0, mel_batched.size() * sizeof(float));
 
     // Positional embedding.
     {
-        std::vector<float> pe = build_sinusoid_pe(
-            cm->hparams.enc_d_model, timing.per_chunk_aftercnn);
-        ggml_backend_tensor_set(eb.pos_emb_in, pe.data(),
-                                0, pe.size() * sizeof(float));
+        std::vector<float> pe = build_sinusoid_pe(cm->hparams.enc_d_model, timing.per_chunk_aftercnn);
+        ggml_backend_tensor_set(eb.pos_emb_in, pe.data(), 0, pe.size() * sizeof(float));
     }
 
     // Attention mask (block-diagonal from cu_seqlens).
@@ -743,27 +670,21 @@ transcribe_status run(
         std::vector<float> mask = build_cu_seqlens_mask(timing, cm->hparams);
         if (cc->encoder_use_flash) {
             std::vector<ggml_fp16_t> mask_f16(mask.size());
-            for (size_t i = 0; i < mask.size(); ++i)
+            for (size_t i = 0; i < mask.size(); ++i) {
                 mask_f16[i] = ggml_fp32_to_fp16(mask[i]);
-            ggml_backend_tensor_set(eb.mask_in, mask_f16.data(),
-                                    0, mask_f16.size() * sizeof(ggml_fp16_t));
+            }
+            ggml_backend_tensor_set(eb.mask_in, mask_f16.data(), 0, mask_f16.size() * sizeof(ggml_fp16_t));
         } else {
-            ggml_backend_tensor_set(eb.mask_in, mask.data(),
-                                    0, mask.size() * sizeof(float));
+            ggml_backend_tensor_set(eb.mask_in, mask.data(), 0, mask.size() * sizeof(float));
         }
     }
 
     transcribe::configure_sched_n_threads(cc->sched, cc->n_threads);
 
     const int64_t t_enc_start = ggml_time_us();
-    t_enc_build_us = t_enc_start - t_enc_build_start;
-    if (const ggml_status gs =
-            ggml_backend_sched_graph_compute(cc->sched, eb.graph);
-        gs != GGML_STATUS_SUCCESS)
-    {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "qwen3_asr run: encoder graph compute failed (%d)",
-                     static_cast<int>(gs));
+    t_enc_build_us            = t_enc_start - t_enc_build_start;
+    if (const ggml_status gs = ggml_backend_sched_graph_compute(cc->sched, eb.graph); gs != GGML_STATUS_SUCCESS) {
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "qwen3_asr run: encoder graph compute failed (%d)", static_cast<int>(gs));
         return TRANSCRIBE_ERR_GGUF;
     }
     cc->t_encode_us = ggml_time_us() - t_enc_start;
@@ -774,17 +695,16 @@ transcribe_status run(
             transcribe::debug::dump_tensor(name, t, stage);
         }
     };
-    try_dump("enc.subsample.out",  eb.dumps.subsample_out,  "enc.subsample");
-    try_dump("enc.pos_add.out",    eb.dumps.pos_add_out,    "enc.pos_add");
-    try_dump("enc.block.0.out",    eb.dumps.block_0_out,    "enc.block.0");
+    try_dump("enc.subsample.out", eb.dumps.subsample_out, "enc.subsample");
+    try_dump("enc.pos_add.out", eb.dumps.pos_add_out, "enc.pos_add");
+    try_dump("enc.block.0.out", eb.dumps.block_0_out, "enc.block.0");
     {
         char bname[64];
-        std::snprintf(bname, sizeof(bname), "enc.block.%d.out",
-                      cm->hparams.enc_n_layers - 1);
+        std::snprintf(bname, sizeof(bname), "enc.block.%d.out", cm->hparams.enc_n_layers - 1);
         try_dump(bname, eb.dumps.block_last_out, "enc.block.last");
     }
-    try_dump("enc.ln_post.out",    eb.dumps.ln_post_out,    "enc.ln_post");
-    try_dump("enc.proj.out",       eb.dumps.proj_out,       "enc.proj");
+    try_dump("enc.ln_post.out", eb.dumps.ln_post_out, "enc.ln_post");
+    try_dump("enc.proj.out", eb.dumps.proj_out, "enc.proj");
 
     // Read encoder output to host for the LM prefill. The graph already
     // dropped the aftercnn pad rows (see encoder.cpp), so eb.out is exactly
@@ -792,40 +712,35 @@ transcribe_status run(
     // shape.
     const int d_enc = static_cast<int>(eb.out->ne[0]);
     const int T_enc = static_cast<int>(eb.out->ne[1]);
-    cc->enc_host.resize(static_cast<size_t>(d_enc) *
-                        static_cast<size_t>(T_enc));
+    cc->enc_host.resize(static_cast<size_t>(d_enc) * static_cast<size_t>(T_enc));
     const int64_t t_d2h_start = ggml_time_us();
-    ggml_backend_tensor_get(eb.out, cc->enc_host.data(), 0,
-                            cc->enc_host.size() * sizeof(float));
+    ggml_backend_tensor_get(eb.out, cc->enc_host.data(), 0, cc->enc_host.size() * sizeof(float));
     t_enc_d2h_us = ggml_time_us() - t_d2h_start;
 
     // Decode phase begins. t_dec_start covers prompt + KV init + prefill
     // build/compute + step loop (prefill is part of "decode" to users).
-    const int64_t t_dec_start = ggml_time_us();
+    const int64_t t_dec_start           = ggml_time_us();
     const int64_t t_prefill_build_start = t_dec_start;
 
     // Prompt construction.
     std::vector<int32_t> prompt_ids;
     std::vector<int64_t> audio_positions;
-    build_prompt_tokens(cm->hparams, cm->chat_tokens, T_enc,
-                        lang_prefix_ptr, prompt_ids, audio_positions);
+    build_prompt_tokens(cm->hparams, cm->chat_tokens, T_enc, lang_prefix_ptr, prompt_ids, audio_positions);
     const int T_prompt   = static_cast<int>(prompt_ids.size());
-    const int prefix_len = audio_positions.empty()
-                         ? 0 : static_cast<int>(audio_positions.front());
+    const int prefix_len = audio_positions.empty() ? 0 : static_cast<int>(audio_positions.front());
     const int suffix_len = T_prompt - prefix_len - T_enc;
-    (void)audio_positions;
+    (void) audio_positions;
 
     // Input-length gate: audio + prompt + generation must fit the decoder
     // context window. Reject an over-length clip here, before prefill/decode.
     const int ceiling = qwen3_context_ceiling(cc->n_ctx, cm->hparams);
     if (T_prompt + k_max_new > ceiling) {
-        transcribe::log_msg(
-            TRANSCRIBE_LOG_LEVEL_ERROR,
-            "qwen3_asr run: input too long — %d audio + %d prompt tokens "
-            "leave no room for output within the %d-token context (need %d). "
-            "Shorten the audio (see transcribe_capabilities.max_audio_ms) or "
-            "split it into segments.",
-            T_enc, prefix_len + suffix_len, ceiling, T_prompt + k_max_new);
+        transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
+                            "qwen3_asr run: input too long — %d audio + %d prompt tokens "
+                            "leave no room for output within the %d-token context (need %d). "
+                            "Shorten the audio (see transcribe_capabilities.max_audio_ms) or "
+                            "split it into segments.",
+                            T_enc, prefix_len + suffix_len, ceiling, T_prompt + k_max_new);
         return TRANSCRIBE_ERR_INPUT_TOO_LONG;
     }
 
@@ -834,27 +749,28 @@ transcribe_status run(
     // graph's flash-attn path wants pow2 attention width). A pre-allocated
     // smaller cache is freed and re-allocated.
     int want_n_ctx = 1024;
-    while (want_n_ctx < T_prompt + k_max_new) want_n_ctx *= 2;
-    if (want_n_ctx > ceiling) want_n_ctx = ceiling;
+    while (want_n_ctx < T_prompt + k_max_new) {
+        want_n_ctx *= 2;
+    }
+    if (want_n_ctx > ceiling) {
+        want_n_ctx = ceiling;
+    }
     if (cc->kv_cache.ctx != nullptr && cc->kv_cache.n_ctx < want_n_ctx) {
         cc->kv_cache.free();
     }
     if (cc->kv_cache.ctx == nullptr) {
         ggml_type kv_type = GGML_TYPE_F16;
-        if (cc->kv_type == TRANSCRIBE_KV_TYPE_F32) kv_type = GGML_TYPE_F32;
-        if (!transcribe::causal_lm::kv_init(cc->kv_cache, cm->plan.primary,
-                                           want_n_ctx,
-                                           cm->hparams.dec_n_kv_heads,
-                                           cm->hparams.dec_head_dim,
-                                           cm->hparams.dec_n_layers,
-                                           kv_type))
-        {
+        if (cc->kv_type == TRANSCRIBE_KV_TYPE_F32) {
+            kv_type = GGML_TYPE_F32;
+        }
+        if (!transcribe::causal_lm::kv_init(cc->kv_cache, cm->plan.primary, want_n_ctx, cm->hparams.dec_n_kv_heads,
+                                            cm->hparams.dec_head_dim, cm->hparams.dec_n_layers, kv_type)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "qwen3_asr run: KV cache allocation failed (n_ctx=%d, "
-                "%d kv-heads x %d head-dim x %d layers) — out of memory. "
-                "Lower transcribe_session_params.n_ctx or shorten the audio.",
-                want_n_ctx, cm->hparams.dec_n_kv_heads,
-                cm->hparams.dec_head_dim, cm->hparams.dec_n_layers);
+                                "qwen3_asr run: KV cache allocation failed (n_ctx=%d, "
+                                "%d kv-heads x %d head-dim x %d layers) — out of memory. "
+                                "Lower transcribe_session_params.n_ctx or shorten the audio.",
+                                want_n_ctx, cm->hparams.dec_n_kv_heads, cm->hparams.dec_head_dim,
+                                cm->hparams.dec_n_layers);
             return TRANSCRIBE_ERR_OOM;
         }
     } else {
@@ -869,12 +785,11 @@ transcribe_status run(
     // Prefill graph. slice_last false: last block's FFN + final norm run on
     // every position (needed for dump parity). true: slice to just the final
     // position before the last FFN (llama.cpp's inp_out_ids trick, ~25 ms).
-    const bool dumps_on  = transcribe::debug::enabled();
-    const bool slice_last = !dumps_on;
-    PrefillBuild pb = build_prefill_graph(
-        cc->compute_ctx, cm->weights, cm->hparams,
-        cc->kv_cache, T_prompt, T_enc, prefix_len, suffix_len,
-        /*use_flash=*/cc->decoder_use_flash, slice_last);
+    const bool   dumps_on   = transcribe::debug::enabled();
+    const bool   slice_last = !dumps_on;
+    PrefillBuild pb = build_prefill_graph(cc->compute_ctx, cm->weights, cm->hparams, cc->kv_cache, T_prompt, T_enc,
+                                          prefix_len, suffix_len,
+                                          /*use_flash=*/cc->decoder_use_flash, slice_last);
     if (pb.graph == nullptr || pb.out == nullptr) {
         return TRANSCRIBE_ERR_GGUF;
     }
@@ -883,50 +798,43 @@ transcribe_status run(
     ggml_backend_sched_reset(cc->sched);
     if (!ggml_backend_sched_alloc_graph(cc->sched, pb.graph)) {
         transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "qwen3_asr run: prefill graph allocation failed (T_prompt=%d) — "
-            "out of memory. Lower transcribe_session_params.n_ctx or shorten "
-            "the audio.", T_prompt);
+                            "qwen3_asr run: prefill graph allocation failed (T_prompt=%d) — "
+                            "out of memory. Lower transcribe_session_params.n_ctx or shorten "
+                            "the audio.",
+                            T_prompt);
         return TRANSCRIBE_ERR_OOM;
     }
 
     // Upload prefill inputs.
-    ggml_backend_tensor_set(pb.input_ids_in, prompt_ids.data(),
-                            0, prompt_ids.size() * sizeof(int32_t));
-    ggml_backend_tensor_set(pb.enc_out_in, cc->enc_host.data(),
-                            0, cc->enc_host.size() * sizeof(float));
+    ggml_backend_tensor_set(pb.input_ids_in, prompt_ids.data(), 0, prompt_ids.size() * sizeof(int32_t));
+    ggml_backend_tensor_set(pb.enc_out_in, cc->enc_host.data(), 0, cc->enc_host.size() * sizeof(float));
 
     {
         std::vector<int32_t> positions(T_prompt);
-        for (int i = 0; i < T_prompt; ++i) positions[i] = i;
-        ggml_backend_tensor_set(pb.positions_in, positions.data(),
-                                0, positions.size() * sizeof(int32_t));
+        for (int i = 0; i < T_prompt; ++i) {
+            positions[i] = i;
+        }
+        ggml_backend_tensor_set(pb.positions_in, positions.data(), 0, positions.size() * sizeof(int32_t));
     }
 
     {
         // Causal mask in F16 (matches pb.mask_in): row r col c is 0 if c <= r,
         // else -inf, row-major. F16 upload avoids a per-layer ggml_cast.
-        const ggml_fp16_t mask_zero    = ggml_fp32_to_fp16(0.0f);
-        const ggml_fp16_t mask_neg_inf = ggml_fp32_to_fp16(-INFINITY);
-        std::vector<ggml_fp16_t> mask(
-            static_cast<size_t>(T_prompt) * T_prompt, mask_neg_inf);
+        const ggml_fp16_t        mask_zero    = ggml_fp32_to_fp16(0.0f);
+        const ggml_fp16_t        mask_neg_inf = ggml_fp32_to_fp16(-INFINITY);
+        std::vector<ggml_fp16_t> mask(static_cast<size_t>(T_prompt) * T_prompt, mask_neg_inf);
         for (int r = 0; r < T_prompt; ++r) {
             for (int c = 0; c <= r; ++c) {
                 mask[static_cast<size_t>(r) * T_prompt + c] = mask_zero;
             }
         }
-        ggml_backend_tensor_set(pb.mask_in, mask.data(),
-                                0, mask.size() * sizeof(ggml_fp16_t));
+        ggml_backend_tensor_set(pb.mask_in, mask.data(), 0, mask.size() * sizeof(ggml_fp16_t));
     }
 
     const int64_t t_prefill_compute_start = ggml_time_us();
-    t_prefill_build_us = t_prefill_compute_start - t_prefill_build_start;
-    if (const ggml_status gs =
-            ggml_backend_sched_graph_compute(cc->sched, pb.graph);
-        gs != GGML_STATUS_SUCCESS)
-    {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "qwen3_asr run: prefill graph compute failed (%d)",
-                     static_cast<int>(gs));
+    t_prefill_build_us                    = t_prefill_compute_start - t_prefill_build_start;
+    if (const ggml_status gs = ggml_backend_sched_graph_compute(cc->sched, pb.graph); gs != GGML_STATUS_SUCCESS) {
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "qwen3_asr run: prefill graph compute failed (%d)", static_cast<int>(gs));
         return TRANSCRIBE_ERR_GGUF;
     }
     t_prefill_compute_us = ggml_time_us() - t_prefill_compute_start;
@@ -935,71 +843,75 @@ transcribe_status run(
     cc->kv_cache.head = T_prompt;
 
     // Dump dec.* intermediates.
-    try_dump("dec.token_emb",       pb.dumps.token_emb,       "dec.token_emb");
-    try_dump("dec.audio_injected",  pb.dumps.audio_injected,  "dec.audio_injected");
-    try_dump("dec.block.0.out",     pb.dumps.block_0_out,     "dec.block.0");
+    try_dump("dec.token_emb", pb.dumps.token_emb, "dec.token_emb");
+    try_dump("dec.audio_injected", pb.dumps.audio_injected, "dec.audio_injected");
+    try_dump("dec.block.0.out", pb.dumps.block_0_out, "dec.block.0");
     {
         char nm[64];
-        std::snprintf(nm, sizeof(nm), "dec.block.%d.out",
-                      cm->hparams.dec_n_layers - 1);
-        try_dump(nm,                pb.dumps.block_last_out,  "dec.block.last");
+        std::snprintf(nm, sizeof(nm), "dec.block.%d.out", cm->hparams.dec_n_layers - 1);
+        try_dump(nm, pb.dumps.block_last_out, "dec.block.last");
     }
     try_dump("dec.out_before_head", pb.dumps.out_before_head, "dec.out_before_head");
-    try_dump("dec.logits_raw",      pb.dumps.logits_raw,      "dec.logits_raw");
+    try_dump("dec.logits_raw", pb.dumps.logits_raw, "dec.logits_raw");
 
     // Read prefill logits + first argmax.
-    const int64_t t_prefill_logits_start = ggml_time_us();
-    const int vocab = cm->hparams.dec_vocab_size;
+    const int64_t      t_prefill_logits_start = ggml_time_us();
+    const int          vocab                  = cm->hparams.dec_vocab_size;
     std::vector<float> logits(vocab);
-    ggml_backend_tensor_get(pb.out, logits.data(), 0,
-                            logits.size() * sizeof(float));
+    ggml_backend_tensor_get(pb.out, logits.data(), 0, logits.size() * sizeof(float));
 
     auto argmax = [&](const std::vector<float> & v) -> int32_t {
-        int32_t best = 0;
+        int32_t best   = 0;
         float   best_v = v[0];
         for (int32_t i = 1; i < static_cast<int32_t>(v.size()); ++i) {
-            if (v[i] > best_v) { best_v = v[i]; best = i; }
+            if (v[i] > best_v) {
+                best_v = v[i];
+                best   = i;
+            }
         }
         return best;
     };
 
     std::vector<int32_t> generated_ids;
-    int32_t next_tok = argmax(logits);
+    int32_t              next_tok = argmax(logits);
     generated_ids.push_back(next_tok);
     t_prefill_logits_us = ggml_time_us() - t_prefill_logits_start;
 
     // Step loop.
-    const int32_t eos_id = cm->hparams.eos_token_id;
-    const int32_t max_new = k_max_new;
-    int cur_past = T_prompt;
+    const int32_t eos_id   = cm->hparams.eos_token_id;
+    const int32_t max_new  = k_max_new;
+    int           cur_past = T_prompt;
 
     // Build the step graph ONCE and reuse every step, sized for the actual
     // workload (T_prompt written + up to max_new generated). Metal's flash-attn
     // kernels dispatch ~30% faster (M4 Max) when K/V ne[1] is a power of 2, so
     // round up; floor of 1024 (smaller just hits the slow-misaligned branch).
     int max_n_kv = 1024;
-    while (max_n_kv < T_prompt + max_new) max_n_kv *= 2;
-    if (max_n_kv > cc->kv_cache.n_ctx) max_n_kv = cc->kv_cache.n_ctx;
+    while (max_n_kv < T_prompt + max_new) {
+        max_n_kv *= 2;
+    }
+    if (max_n_kv > cc->kv_cache.n_ctx) {
+        max_n_kv = cc->kv_cache.n_ctx;
+    }
     const int64_t t_step_build_start = ggml_time_us();
     if (cc->compute_ctx != nullptr) {
         ggml_free(cc->compute_ctx);
         cc->compute_ctx = nullptr;
     }
     {
-        ggml_init_params ip {};
-        ip.mem_size   = 8 * 1024 * 1024;
-        ip.mem_buffer = nullptr;
-        ip.no_alloc   = true;
+        ggml_init_params ip{};
+        ip.mem_size     = 8 * 1024 * 1024;
+        ip.mem_buffer   = nullptr;
+        ip.no_alloc     = true;
         cc->compute_ctx = ggml_init(ip);
         if (cc->compute_ctx == nullptr) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "qwen3_asr step: compute context allocation failed — "
-                "out of memory.");
+                                "qwen3_asr step: compute context allocation failed — "
+                                "out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
     }
-    StepBuild sb = build_step_graph(cc->compute_ctx, cm->weights,
-                                    cm->hparams, cc->kv_cache, max_n_kv,
+    StepBuild sb = build_step_graph(cc->compute_ctx, cm->weights, cm->hparams, cc->kv_cache, max_n_kv,
                                     /*use_flash=*/cc->decoder_use_flash);
     if (sb.graph == nullptr || sb.out == nullptr) {
         return TRANSCRIBE_ERR_GGUF;
@@ -1007,61 +919,47 @@ transcribe_status run(
     ggml_backend_sched_reset(cc->sched);
     if (!ggml_backend_sched_alloc_graph(cc->sched, sb.graph)) {
         transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "qwen3_asr step: decode graph allocation failed — out of memory. "
-            "Lower transcribe_session_params.n_ctx or shorten the audio.");
+                            "qwen3_asr step: decode graph allocation failed — out of memory. "
+                            "Lower transcribe_session_params.n_ctx or shorten the audio.");
         return TRANSCRIBE_ERR_OOM;
     }
     const int64_t t_step_build_once_us = ggml_time_us() - t_step_build_start;
 
     // Mask buffer reused host-side across steps. Starts all -inf; per step we
     // zero positions [0, cur_past] (attend) and leave the rest -inf.
-    const ggml_fp16_t mask_zero    = ggml_fp32_to_fp16(0.0f);
-    const ggml_fp16_t mask_neg_inf = ggml_fp32_to_fp16(-INFINITY);
+    const ggml_fp16_t        mask_zero    = ggml_fp32_to_fp16(0.0f);
+    const ggml_fp16_t        mask_neg_inf = ggml_fp32_to_fp16(-INFINITY);
     std::vector<ggml_fp16_t> step_mask(max_n_kv, mask_neg_inf);
 
     // Per-step timers.
-    int64_t t_step_set_us  = 0;
-    int64_t t_step_comp_us = 0;
-    int64_t t_step_get_us  = 0;
+    int64_t       t_step_set_us     = 0;
+    int64_t       t_step_comp_us    = 0;
+    int64_t       t_step_get_us     = 0;
     const int64_t t_step_loop_start = ggml_time_us();
-    while (next_tok != eos_id &&
-           static_cast<int32_t>(generated_ids.size()) < max_new &&
-           cur_past + 1 <= max_n_kv)
-    {
+    while (next_tok != eos_id && static_cast<int32_t>(generated_ids.size()) < max_new && cur_past + 1 <= max_n_kv) {
         const int64_t t_set0 = ggml_time_us();
 
-        ggml_backend_tensor_set(sb.input_id_in, &next_tok,
-                                0, sizeof(int32_t));
+        ggml_backend_tensor_set(sb.input_id_in, &next_tok, 0, sizeof(int32_t));
         const int32_t pos_val = cur_past;
-        ggml_backend_tensor_set(sb.position_in, &pos_val,
-                                0, sizeof(int32_t));
+        ggml_backend_tensor_set(sb.position_in, &pos_val, 0, sizeof(int32_t));
         const int64_t kv_idx_val = cur_past;
-        ggml_backend_tensor_set(sb.kv_idx_in, &kv_idx_val,
-                                0, sizeof(int64_t));
+        ggml_backend_tensor_set(sb.kv_idx_in, &kv_idx_val, 0, sizeof(int64_t));
 
         // Mask: mark the newly-added position as attendable. Positions
         // [0, cur_past) were zeroed in prior iterations; just set the
         // new one. (On iter 0, zero everything in [0, cur_past].)
         if (cur_past == T_prompt) {
-            std::fill(step_mask.begin(),
-                      step_mask.begin() + cur_past + 1, mask_zero);
+            std::fill(step_mask.begin(), step_mask.begin() + cur_past + 1, mask_zero);
         } else {
             step_mask[cur_past] = mask_zero;
         }
-        ggml_backend_tensor_set(sb.mask_in, step_mask.data(), 0,
-                                static_cast<size_t>(max_n_kv) *
-                                sizeof(ggml_fp16_t));
+        ggml_backend_tensor_set(sb.mask_in, step_mask.data(), 0, static_cast<size_t>(max_n_kv) * sizeof(ggml_fp16_t));
 
         const int64_t t_set1 = ggml_time_us();
         t_step_set_us += t_set1 - t_set0;
 
-        if (const ggml_status gs =
-                ggml_backend_sched_graph_compute(cc->sched, sb.graph);
-            gs != GGML_STATUS_SUCCESS)
-        {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "qwen3_asr step: graph compute failed (%d)",
-                         static_cast<int>(gs));
+        if (const ggml_status gs = ggml_backend_sched_graph_compute(cc->sched, sb.graph); gs != GGML_STATUS_SUCCESS) {
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "qwen3_asr step: graph compute failed (%d)", static_cast<int>(gs));
             return TRANSCRIBE_ERR_GGUF;
         }
         const int64_t t_comp1 = ggml_time_us();
@@ -1077,18 +975,17 @@ transcribe_status run(
         t_step_get_us += ggml_time_us() - t_comp1;
     }
     t_step_loop_us = ggml_time_us() - t_step_loop_start;
-    n_steps = static_cast<int>(generated_ids.size()) - 1;
+    n_steps        = static_cast<int>(generated_ids.size()) - 1;
 
     // Decode stopped at EOS (complete) or the generation budget / context width
     // (truncated). Surface the latter via transcribe_was_truncated() + WARN.
     if (next_tok != eos_id) {
         cc->was_truncated = true;
-        transcribe::log_msg(
-            TRANSCRIBE_LOG_LEVEL_WARN,
-            "qwen3_asr run: output truncated at %d tokens — decode reached the "
-            "generation budget before end-of-stream; the transcript may be "
-            "incomplete.",
-            static_cast<int>(generated_ids.size()));
+        transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_WARN,
+                            "qwen3_asr run: output truncated at %d tokens — decode reached the "
+                            "generation budget before end-of-stream; the transcript may be "
+                            "incomplete.",
+                            static_cast<int>(generated_ids.size()));
     }
 
     // Map granular counters to the debug-print shape. With graph reuse all
@@ -1105,8 +1002,7 @@ transcribe_status run(
 
     // Decode generated ids to text (Tokenizer::decode handles the "gpt2"
     // byte-level inversion natively).
-    std::string raw_text = cm->tok.decode(
-        generated_ids.data(), static_cast<int>(generated_ids.size()));
+    std::string raw_text = cm->tok.decode(generated_ids.data(), static_cast<int>(generated_ids.size()));
 
     // Parse Qwen3-ASR output: auto-detect emits "language X<asr_text>text"
     // (strip prefix); forced emits "text" (we already seeded the prefix). The
@@ -1119,13 +1015,11 @@ transcribe_status run(
         // us, not what we told it).
         if (lang_prefix_ptr == nullptr) {
             constexpr const char k_prefix[] = "language ";
-            const size_t name_start = raw_text.find(k_prefix);
+            const size_t         name_start = raw_text.find(k_prefix);
             if (name_start != std::string::npos && name_start < sep) {
-                const size_t ns = name_start + (sizeof(k_prefix) - 1);
-                std::string name = raw_text.substr(ns, sep - ns);
-                while (!name.empty() && (name.back() == ' ' ||
-                       name.back() == '\t' || name.back() == '\n'))
-                {
+                const size_t ns   = name_start + (sizeof(k_prefix) - 1);
+                std::string  name = raw_text.substr(ns, sep - ns);
+                while (!name.empty() && (name.back() == ' ' || name.back() == '\t' || name.back() == '\n')) {
                     name.pop_back();
                 }
                 for (const auto & e : k_qwen3_asr_language_names) {
@@ -1144,64 +1038,53 @@ transcribe_status run(
 
     // Optional perf breakdown (finer split than the public mel/encode/decode
     // timings), gated on env var.
-    if (transcribe::env::flag("TRANSCRIBE_PERF_DEBUG"))
-    {
-        const double ms = 1.0 / 1000.0;
-        const double sum_ms = (cc->t_mel_us + t_enc_build_us +
-                               cc->t_encode_us + t_enc_d2h_us +
-                               t_prefill_build_us + t_prefill_compute_us +
-                               t_prefill_logits_us + t_step_loop_us) * ms;
-        const double per_step_ms = (n_steps > 0)
-            ? (t_step_loop_us * ms / n_steps) : 0.0;
+    if (transcribe::env::flag("TRANSCRIBE_PERF_DEBUG")) {
+        const double ms     = 1.0 / 1000.0;
+        const double sum_ms = (cc->t_mel_us + t_enc_build_us + cc->t_encode_us + t_enc_d2h_us + t_prefill_build_us +
+                               t_prefill_compute_us + t_prefill_logits_us + t_step_loop_us) *
+                              ms;
+        const double per_step_ms = (n_steps > 0) ? (t_step_loop_us * ms / n_steps) : 0.0;
         log_msg(TRANSCRIBE_LOG_LEVEL_DEBUG,
-            "qwen3_asr perf breakdown:\n"
-            "  mel              %8.2f ms\n"
-            "  enc_build        %8.2f ms  (graph + sched + uploads)\n"
-            "  enc_compute      %8.2f ms\n"
-            "  enc_d2h          %8.2f ms  (%d floats)\n"
-            "  prefill_build    %8.2f ms  (kv_init + prompt + graph + sched + uploads)\n"
-            "  prefill_compute  %8.2f ms  (T_prompt=%d)\n"
-            "  prefill_logits   %8.2f ms  (readback + argmax, vocab=%d)\n"
-            "  step_loop        %8.2f ms  (%d steps, %.2f ms/step)\n"
-            "    ctx_reset    %8.2f ms  (%.3f ms/step)\n"
-            "    graph_build  %8.2f ms  (%.3f ms/step)\n"
-            "    sched_alloc  %8.2f ms  (%.3f ms/step)\n"
-            "    tensor_set   %8.2f ms  (%.3f ms/step)\n"
-            "    compute      %8.2f ms  (%.3f ms/step)\n"
-            "    tensor_get   %8.2f ms  (%.3f ms/step)\n"
-            "  ---\n"
-            "  sum              %8.2f ms",
-            cc->t_mel_us         * ms,
-            t_enc_build_us       * ms,
-            cc->t_encode_us      * ms,
-            t_enc_d2h_us         * ms, static_cast<int>(cc->enc_host.size()),
-            t_prefill_build_us   * ms,
-            t_prefill_compute_us * ms, T_prompt,
-            t_prefill_logits_us  * ms, vocab,
-            t_step_loop_us       * ms, n_steps, per_step_ms,
-            t_step_ctx_us   * ms, (n_steps > 0) ? (t_step_ctx_us   * ms / n_steps) : 0.0,
-            t_step_build_us * ms, (n_steps > 0) ? (t_step_build_us * ms / n_steps) : 0.0,
-            t_step_alloc_us * ms, (n_steps > 0) ? (t_step_alloc_us * ms / n_steps) : 0.0,
-            t_step_set_us   * ms, (n_steps > 0) ? (t_step_set_us   * ms / n_steps) : 0.0,
-            t_step_comp_us  * ms, (n_steps > 0) ? (t_step_comp_us  * ms / n_steps) : 0.0,
-            t_step_get_us   * ms, (n_steps > 0) ? (t_step_get_us   * ms / n_steps) : 0.0,
-            sum_ms);
-    }
-
-    cc->full_text = transcript_text;
+                "qwen3_asr perf breakdown:\n"
+                "  mel              %8.2f ms\n"
+                "  enc_build        %8.2f ms  (graph + sched + uploads)\n"
+                "  enc_compute      %8.2f ms\n"
+                "  enc_d2h          %8.2f ms  (%d floats)\n"
+                "  prefill_build    %8.2f ms  (kv_init + prompt + graph + sched + uploads)\n"
+                "  prefill_compute  %8.2f ms  (T_prompt=%d)\n"
+                "  prefill_logits   %8.2f ms  (readback + argmax, vocab=%d)\n"
+                "  step_loop        %8.2f ms  (%d steps, %.2f ms/step)\n"
+                "    ctx_reset    %8.2f ms  (%.3f ms/step)\n"
+                "    graph_build  %8.2f ms  (%.3f ms/step)\n"
+                "    sched_alloc  %8.2f ms  (%.3f ms/step)\n"
+                "    tensor_set   %8.2f ms  (%.3f ms/step)\n"
+                "    compute      %8.2f ms  (%.3f ms/step)\n"
+                "    tensor_get   %8.2f ms  (%.3f ms/step)\n"
+                "  ---\n"
+                "  sum              %8.2f ms",
+                cc->t_mel_us * ms, t_enc_build_us * ms, cc->t_encode_us * ms, t_enc_d2h_us * ms,
+                static_cast<int>(cc->enc_host.size()), t_prefill_build_us * ms, t_prefill_compute_us * ms, T_prompt,
+                t_prefill_logits_us * ms, vocab, t_step_loop_us * ms, n_steps, per_step_ms, t_step_ctx_us * ms,
+                (n_steps > 0) ? (t_step_ctx_us * ms / n_steps) : 0.0, t_step_build_us * ms,
+                (n_steps > 0) ? (t_step_build_us * ms / n_steps) : 0.0, t_step_alloc_us * ms,
+                (n_steps > 0) ? (t_step_alloc_us * ms / n_steps) : 0.0, t_step_set_us * ms,
+                (n_steps > 0) ? (t_step_set_us * ms / n_steps) : 0.0, t_step_comp_us * ms,
+                (n_steps > 0) ? (t_step_comp_us * ms / n_steps) : 0.0, t_step_get_us * ms,
+                (n_steps > 0) ? (t_step_get_us * ms / n_steps) : 0.0, sum_ms);
+    }
+
+    cc->full_text   = transcript_text;
     cc->result_kind = TRANSCRIBE_TIMESTAMPS_NONE;
     cc->has_result  = true;
-    transcribe_session::SegmentEntry seg {};
+    transcribe_session::SegmentEntry seg{};
     seg.text  = transcript_text;
     seg.t0_ms = 0;
-    seg.t1_ms = static_cast<int64_t>(n_samples) * 1000
-              / static_cast<int64_t>(cm->hparams.fe_sample_rate);
+    seg.t1_ms = static_cast<int64_t>(n_samples) * 1000 / static_cast<int64_t>(cm->hparams.fe_sample_rate);
     cc->segments.push_back(std::move(seg));
 
     // A truncated decode returns OUTPUT_TRUNCATED; the partial transcript above
     // stays readable (like an aborted run).
-    return cc->was_truncated ? TRANSCRIBE_ERR_OUTPUT_TRUNCATED
-                             : TRANSCRIBE_OK;
+    return cc->was_truncated ? TRANSCRIBE_ERR_OUTPUT_TRUNCATED : TRANSCRIBE_OK;
 }
 
 // ===========================================================================
@@ -1228,10 +1111,10 @@ transcribe_status reset_compute_ctx(QwenAsrSession * cc, int mb) {
         ggml_free(cc->compute_ctx);
         cc->compute_ctx = nullptr;
     }
-    ggml_init_params ip {};
-    ip.mem_size   = static_cast<size_t>(mb) * 1024 * 1024;
-    ip.mem_buffer = nullptr;
-    ip.no_alloc   = true;
+    ggml_init_params ip{};
+    ip.mem_size     = static_cast<size_t>(mb) * 1024 * 1024;
+    ip.mem_buffer   = nullptr;
+    ip.no_alloc     = true;
     cc->compute_ctx = ggml_init(ip);
     return cc->compute_ctx != nullptr ? TRANSCRIBE_OK : TRANSCRIBE_ERR_GGUF;
 }
@@ -1239,27 +1122,33 @@ transcribe_status reset_compute_ctx(QwenAsrSession * cc, int mb) {
 // Batched encoder: mel (parallel) + one encoder graph over all B utterances
 // on the batch axis. Fills enc_hosts[b] = [d_enc, T_enc[b]], T_enc[b], valid[b].
 // Real-row outputs are bit-identical to encode_one per utterance.
-transcribe_status encode_all_batched(
-    QwenAsrSession * cc, QwenAsrModel * cm,
-    const float * const * pcm, const int * n_samples, int n,
-    std::vector<char> & valid,
-    std::vector<std::vector<float>> & enc_hosts, std::vector<int> & T_enc_out,
-    int64_t & mel_us, int64_t & enc_us) {
+transcribe_status encode_all_batched(QwenAsrSession *                  cc,
+                                     QwenAsrModel *                    cm,
+                                     const float * const *             pcm,
+                                     const int *                       n_samples,
+                                     int                               n,
+                                     std::vector<char> &               valid,
+                                     std::vector<std::vector<float>> & enc_hosts,
+                                     std::vector<int> &                T_enc_out,
+                                     int64_t &                         mel_us,
+                                     int64_t &                         enc_us) {
     const int n_mels = cm->hparams.enc_num_mel_bins;
 
     // Mel (parallel across utterances).
     std::vector<std::vector<float>> mels(n);
-    std::vector<int> mel_nf(n, 0);
-    int n_threads = cc->n_threads;
+    std::vector<int>                mel_nf(n, 0);
+    int                             n_threads = cc->n_threads;
     if (n_threads <= 0) {
         n_threads = transcribe::default_n_threads();
     }
     const int64_t t_mel0 = ggml_time_us();
     transcribe::parallel_for_all(n, n_threads, [&](int b) {
-        if (pcm[b] == nullptr || n_samples[b] <= 0) return true;  // valid stays 0
+        if (pcm[b] == nullptr || n_samples[b] <= 0) {
+            return true;  // valid stays 0
+        }
         int nm = 0, nf = 0;
-        if (cm->mel->compute(pcm[b], static_cast<size_t>(n_samples[b]),
-                             mels[b], nm, nf, /*n_threads=*/1) != TRANSCRIBE_OK) {
+        if (cm->mel->compute(pcm[b], static_cast<size_t>(n_samples[b]), mels[b], nm, nf, /*n_threads=*/1) !=
+            TRANSCRIBE_OK) {
             return true;  // leave invalid
         }
         mel_nf[b] = nf;
@@ -1270,130 +1159,132 @@ transcribe_status encode_all_batched(
 
     // Per-utterance timing + packing geometry.
     std::vector<EncoderTiming> timings(n);
-    int n_chunks_max = 1;
-    bool any = false;
+    int                        n_chunks_max = 1;
+    bool                       any          = false;
     for (int b = 0; b < n; ++b) {
-        if (!valid[b]) continue;
+        if (!valid[b]) {
+            continue;
+        }
         timings[b] = compute_encoder_timing(mel_nf[b], cm->hparams);
-        if (timings[b].n_chunks <= 0) { valid[b] = 0; continue; }
+        if (timings[b].n_chunks <= 0) {
+            valid[b] = 0;
+            continue;
+        }
         n_chunks_max = std::max(n_chunks_max, timings[b].n_chunks);
         T_enc_out[b] = timings[b].T_enc;
-        any = true;
+        any          = true;
+    }
+    if (!any) {
+        return TRANSCRIBE_OK;  // caller emits per-row errors
     }
-    if (!any) return TRANSCRIBE_OK;  // caller emits per-row errors
 
     // Build batched encoder graph.
-    if (const transcribe_status st = reset_compute_ctx(cc, 16); st != TRANSCRIBE_OK)
+    if (const transcribe_status st = reset_compute_ctx(cc, 16); st != TRANSCRIBE_OK) {
         return st;
-    EncoderBuildBatched eb = build_encoder_graph_batched(
-        cc->compute_ctx, cm->weights, cm->hparams, n_chunks_max, n,
-        cc->encoder_use_flash);
-    if (eb.graph == nullptr || eb.out == nullptr) return TRANSCRIBE_ERR_GGUF;
+    }
+    EncoderBuildBatched eb =
+        build_encoder_graph_batched(cc->compute_ctx, cm->weights, cm->hparams, n_chunks_max, n, cc->encoder_use_flash);
+    if (eb.graph == nullptr || eb.out == nullptr) {
+        return TRANSCRIBE_ERR_GGUF;
+    }
 
     if (cc->sched == nullptr) {
-        cc->sched = ggml_backend_sched_new(
-            cm->plan.scheduler_list.data(), nullptr,
-            static_cast<int>(cm->plan.scheduler_list.size()),
-            16384, false, true);
-        if (cc->sched == nullptr) return TRANSCRIBE_ERR_GGUF;
+        cc->sched = ggml_backend_sched_new(cm->plan.scheduler_list.data(), nullptr,
+                                           static_cast<int>(cm->plan.scheduler_list.size()), 16384, false, true);
+        if (cc->sched == nullptr) {
+            return TRANSCRIBE_ERR_GGUF;
+        }
     }
     ggml_backend_sched_reset(cc->sched);
-    if (!ggml_backend_sched_alloc_graph(cc->sched, eb.graph))
+    if (!ggml_backend_sched_alloc_graph(cc->sched, eb.graph)) {
         return TRANSCRIBE_ERR_GGUF;
+    }
 
-    const int     mel_per_chunk = cm->hparams.enc_n_window * 2;
-    const int     T_per_chunk   = eb.T_per_chunk;
-    const int     T_pad_max     = eb.T_pad_max;
-    const size_t  per_chunk_elems = static_cast<size_t>(mel_per_chunk) * n_mels;
+    const int    mel_per_chunk   = cm->hparams.enc_n_window * 2;
+    const int    T_per_chunk     = eb.T_per_chunk;
+    const int    T_pad_max       = eb.T_pad_max;
+    const size_t per_chunk_elems = static_cast<size_t>(mel_per_chunk) * n_mels;
 
     // Pack mel: [mel_per_chunk, n_mels, 1, n*n_chunks_max]; utterance b's
     // chunk c at N = b*n_chunks_max + c, zero-padded beyond n_chunks[b].
     {
-        std::vector<float> packed(per_chunk_elems *
-                                  static_cast<size_t>(n) * n_chunks_max, 0.0f);
+        std::vector<float> packed(per_chunk_elems * static_cast<size_t>(n) * n_chunks_max, 0.0f);
         for (int b = 0; b < n; ++b) {
-            if (!valid[b]) continue;
+            if (!valid[b]) {
+                continue;
+            }
             const EncoderTiming & t = timings[b];
             for (int c = 0; c < t.n_chunks; ++c) {
-                const int tail = (c == t.n_chunks - 1)
-                               ? t.last_chunk_real_mel : mel_per_chunk;
+                const int    tail = (c == t.n_chunks - 1) ? t.last_chunk_real_mel : mel_per_chunk;
                 const size_t nidx = static_cast<size_t>(b) * n_chunks_max + c;
                 for (int m = 0; m < n_mels; ++m) {
-                    const float * src = mels[b].data()
-                        + static_cast<size_t>(m) * mel_nf[b]
-                        + static_cast<size_t>(c) * mel_per_chunk;
-                    float * dst = packed.data()
-                        + nidx * per_chunk_elems
-                        + static_cast<size_t>(m) * mel_per_chunk;
+                    const float * src =
+                        mels[b].data() + static_cast<size_t>(m) * mel_nf[b] + static_cast<size_t>(c) * mel_per_chunk;
+                    float * dst = packed.data() + nidx * per_chunk_elems + static_cast<size_t>(m) * mel_per_chunk;
                     std::memcpy(dst, src, static_cast<size_t>(tail) * sizeof(float));
                 }
             }
         }
-        ggml_backend_tensor_set(eb.mel_in, packed.data(), 0,
-                                packed.size() * sizeof(float));
+        ggml_backend_tensor_set(eb.mel_in, packed.data(), 0, packed.size() * sizeof(float));
     }
 
     // Positional embedding (shared across chunks/utterances).
     {
-        std::vector<float> pe = build_sinusoid_pe(cm->hparams.enc_d_model,
-                                                  T_per_chunk);
-        ggml_backend_tensor_set(eb.pos_emb_in, pe.data(), 0,
-                                pe.size() * sizeof(float));
+        std::vector<float> pe = build_sinusoid_pe(cm->hparams.enc_d_model, T_per_chunk);
+        ggml_backend_tensor_set(eb.pos_emb_in, pe.data(), 0, pe.size() * sizeof(float));
     }
 
     // Key-pad mask [T_pad_max, T_pad_max, 1, n]: row b attends keys k < T_enc[b].
     {
         const size_t plane = static_cast<size_t>(T_pad_max) * T_pad_max;
         if (cc->encoder_use_flash) {
-            const ggml_fp16_t mz = ggml_fp32_to_fp16(0.0f);
-            const ggml_fp16_t mn = ggml_fp32_to_fp16(-INFINITY);
+            const ggml_fp16_t        mz = ggml_fp32_to_fp16(0.0f);
+            const ggml_fp16_t        mn = ggml_fp32_to_fp16(-INFINITY);
             std::vector<ggml_fp16_t> mask(plane * n, mn);
             for (int b = 0; b < n; ++b) {
-                const int real = valid[b] ? std::max(1, T_enc_out[b]) : 1;
+                const int     real = valid[b] ? std::max(1, T_enc_out[b]) : 1;
                 ggml_fp16_t * base = mask.data() + plane * b;
-                for (int q = 0; q < T_pad_max; ++q)
+                for (int q = 0; q < T_pad_max; ++q) {
                     std::fill(base + static_cast<size_t>(q) * T_pad_max,
                               base + static_cast<size_t>(q) * T_pad_max + real, mz);
+                }
             }
-            ggml_backend_tensor_set(eb.mask_in, mask.data(), 0,
-                                    mask.size() * sizeof(ggml_fp16_t));
+            ggml_backend_tensor_set(eb.mask_in, mask.data(), 0, mask.size() * sizeof(ggml_fp16_t));
         } else {
-            const float mn = -INFINITY;
+            const float        mn = -INFINITY;
             std::vector<float> mask(plane * n, mn);
             for (int b = 0; b < n; ++b) {
                 const int real = valid[b] ? std::max(1, T_enc_out[b]) : 1;
-                float * base = mask.data() + plane * b;
-                for (int q = 0; q < T_pad_max; ++q)
+                float *   base = mask.data() + plane * b;
+                for (int q = 0; q < T_pad_max; ++q) {
                     std::fill(base + static_cast<size_t>(q) * T_pad_max,
                               base + static_cast<size_t>(q) * T_pad_max + real, 0.0f);
+                }
             }
-            ggml_backend_tensor_set(eb.mask_in, mask.data(), 0,
-                                    mask.size() * sizeof(float));
+            ggml_backend_tensor_set(eb.mask_in, mask.data(), 0, mask.size() * sizeof(float));
         }
     }
 
     apply_sched_threads(cc);
 
     const int64_t t_enc0 = ggml_time_us();
-    if (ggml_backend_sched_graph_compute(cc->sched, eb.graph) !=
-        GGML_STATUS_SUCCESS) {
+    if (ggml_backend_sched_graph_compute(cc->sched, eb.graph) != GGML_STATUS_SUCCESS) {
         return TRANSCRIBE_ERR_GGUF;
     }
     enc_us += ggml_time_us() - t_enc0;
 
     // Readback [d_enc, T_pad_max, n]; slice each utterance's first T_enc[b] rows.
-    const int d_enc = static_cast<int>(eb.out->ne[0]);
+    const int          d_enc = static_cast<int>(eb.out->ne[0]);
     std::vector<float> out_all(static_cast<size_t>(d_enc) * T_pad_max * n);
-    ggml_backend_tensor_get(eb.out, out_all.data(), 0,
-                            out_all.size() * sizeof(float));
+    ggml_backend_tensor_get(eb.out, out_all.data(), 0, out_all.size() * sizeof(float));
     for (int b = 0; b < n; ++b) {
-        if (!valid[b]) continue;
+        if (!valid[b]) {
+            continue;
+        }
         const int te = T_enc_out[b];
         enc_hosts[b].resize(static_cast<size_t>(d_enc) * te);
-        const float * src = out_all.data() +
-            static_cast<size_t>(b) * T_pad_max * d_enc;
-        std::memcpy(enc_hosts[b].data(), src,
-                    static_cast<size_t>(d_enc) * te * sizeof(float));
+        const float * src = out_all.data() + static_cast<size_t>(b) * T_pad_max * d_enc;
+        std::memcpy(enc_hosts[b].data(), src, static_cast<size_t>(d_enc) * te * sizeof(float));
     }
     return TRANSCRIBE_OK;
 }
@@ -1403,33 +1294,42 @@ transcribe_status encode_all_batched(
 // caller must have allocated cc->kv_cache_batch with n_ctx >= max T_prompt and
 // computed prompt_ids[b] / T_prompt[b] / prefix_len. Collapses B per-utterance
 // prefill graph-builds + sched-allocs into one.
-transcribe_status prefill_all_batched(
-    QwenAsrSession * cc, QwenAsrModel * cm,
-    const std::vector<char> & valid,
-    const std::vector<std::vector<int32_t>> & prompt_ids,
-    const std::vector<int> & T_prompt, int prefix_len,
-    const std::vector<std::vector<float>> & enc_hosts,
-    const std::vector<int> & T_enc, int n,
-    std::vector<int32_t> & first_tok_out) {
+transcribe_status prefill_all_batched(QwenAsrSession *                          cc,
+                                      QwenAsrModel *                            cm,
+                                      const std::vector<char> &                 valid,
+                                      const std::vector<std::vector<int32_t>> & prompt_ids,
+                                      const std::vector<int> &                  T_prompt,
+                                      int                                       prefix_len,
+                                      const std::vector<std::vector<float>> &   enc_hosts,
+                                      const std::vector<int> &                  T_enc,
+                                      int                                       n,
+                                      std::vector<int32_t> &                    first_tok_out) {
     int T_prompt_max = 0, T_enc_max = 0;
     for (int b = 0; b < n; ++b) {
-        if (!valid[b]) continue;
+        if (!valid[b]) {
+            continue;
+        }
         T_prompt_max = std::max(T_prompt_max, T_prompt[b]);
         T_enc_max    = std::max(T_enc_max, T_enc[b]);
     }
-    if (T_prompt_max == 0) return TRANSCRIBE_OK;
+    if (T_prompt_max == 0) {
+        return TRANSCRIBE_OK;
+    }
     T_enc_max = std::max(1, T_enc_max);
 
-    if (const transcribe_status st = reset_compute_ctx(cc, 32); st != TRANSCRIBE_OK)
+    if (const transcribe_status st = reset_compute_ctx(cc, 32); st != TRANSCRIBE_OK) {
         return st;
-    PrefillBuildBatched pb = build_prefill_graph_batched(
-        cc->compute_ctx, cm->weights, cm->hparams, cc->kv_cache_batch,
-        T_prompt_max, T_enc_max, n, cc->decoder_use_flash);
-    if (pb.graph == nullptr || pb.out == nullptr) return TRANSCRIBE_ERR_GGUF;
+    }
+    PrefillBuildBatched pb = build_prefill_graph_batched(cc->compute_ctx, cm->weights, cm->hparams, cc->kv_cache_batch,
+                                                         T_prompt_max, T_enc_max, n, cc->decoder_use_flash);
+    if (pb.graph == nullptr || pb.out == nullptr) {
+        return TRANSCRIBE_ERR_GGUF;
+    }
 
     ggml_backend_sched_reset(cc->sched);
-    if (!ggml_backend_sched_alloc_graph(cc->sched, pb.graph))
+    if (!ggml_backend_sched_alloc_graph(cc->sched, pb.graph)) {
         return TRANSCRIBE_ERR_GGUF;
+    }
 
     const int d_enc = cm->hparams.enc_output_dim;
 
@@ -1437,86 +1337,82 @@ transcribe_status prefill_all_batched(
     {
         std::vector<int32_t> ids(static_cast<size_t>(T_prompt_max) * n, 0);
         for (int b = 0; b < n; ++b) {
-            if (!valid[b]) continue;
-            std::memcpy(ids.data() + static_cast<size_t>(b) * T_prompt_max,
-                        prompt_ids[b].data(),
+            if (!valid[b]) {
+                continue;
+            }
+            std::memcpy(ids.data() + static_cast<size_t>(b) * T_prompt_max, prompt_ids[b].data(),
                         static_cast<size_t>(T_prompt[b]) * sizeof(int32_t));
         }
-        ggml_backend_tensor_set(pb.input_ids_in, ids.data(), 0,
-                                ids.size() * sizeof(int32_t));
+        ggml_backend_tensor_set(pb.input_ids_in, ids.data(), 0, ids.size() * sizeof(int32_t));
     }
     // Audio injection by elementwise blend (see decoder.h): audio_dense holds
     // each utterance's enc_out embeds scattered into their prompt positions,
     // keep is 0 there and 1 elsewhere. (d_enc == dec_hidden, enforced.)
     {
-        std::vector<float> audio_dense(
-            static_cast<size_t>(d_enc) * T_prompt_max * n, 0.0f);
+        std::vector<float> audio_dense(static_cast<size_t>(d_enc) * T_prompt_max * n, 0.0f);
         std::vector<float> keep(static_cast<size_t>(T_prompt_max) * n, 1.0f);
         for (int b = 0; b < n; ++b) {
             const int te = valid[b] ? T_enc[b] : 0;
             // enc_hosts[b] is [d_enc, te] column-major; audio token j lands at
             // prompt position prefix_len+j, flat column b*T_prompt_max+pos.
             for (int j = 0; j < te; ++j) {
-                const size_t dst_col =
-                    static_cast<size_t>(b) * T_prompt_max + (prefix_len + j);
-                std::memcpy(audio_dense.data() + dst_col * d_enc,
-                            enc_hosts[b].data() + static_cast<size_t>(j) * d_enc,
+                const size_t dst_col = static_cast<size_t>(b) * T_prompt_max + (prefix_len + j);
+                std::memcpy(audio_dense.data() + dst_col * d_enc, enc_hosts[b].data() + static_cast<size_t>(j) * d_enc,
                             static_cast<size_t>(d_enc) * sizeof(float));
                 keep[dst_col] = 0.0f;
             }
         }
-        ggml_backend_tensor_set(pb.audio_dense_in, audio_dense.data(), 0,
-                                audio_dense.size() * sizeof(float));
-        ggml_backend_tensor_set(pb.keep_mask_in, keep.data(), 0,
-                                keep.size() * sizeof(float));
+        ggml_backend_tensor_set(pb.audio_dense_in, audio_dense.data(), 0, audio_dense.size() * sizeof(float));
+        ggml_backend_tensor_set(pb.keep_mask_in, keep.data(), 0, keep.size() * sizeof(float));
     }
     // positions [T_prompt_max] 0..T-1 (shared).
     {
         std::vector<int32_t> pos(T_prompt_max);
-        for (int t = 0; t < T_prompt_max; ++t) pos[t] = t;
-        ggml_backend_tensor_set(pb.positions_in, pos.data(), 0,
-                                pos.size() * sizeof(int32_t));
+        for (int t = 0; t < T_prompt_max; ++t) {
+            pos[t] = t;
+        }
+        ggml_backend_tensor_set(pb.positions_in, pos.data(), 0, pos.size() * sizeof(int32_t));
     }
     // causal mask [T_prompt_max, T_prompt_max] f16 (shared): m[q*T+k]=0 if k<=q.
     {
-        const ggml_fp16_t mz = ggml_fp32_to_fp16(0.0f);
-        const ggml_fp16_t mn = ggml_fp32_to_fp16(-INFINITY);
-        std::vector<ggml_fp16_t> mask(
-            static_cast<size_t>(T_prompt_max) * T_prompt_max, mn);
-        for (int q = 0; q < T_prompt_max; ++q)
+        const ggml_fp16_t        mz = ggml_fp32_to_fp16(0.0f);
+        const ggml_fp16_t        mn = ggml_fp32_to_fp16(-INFINITY);
+        std::vector<ggml_fp16_t> mask(static_cast<size_t>(T_prompt_max) * T_prompt_max, mn);
+        for (int q = 0; q < T_prompt_max; ++q) {
             std::fill(mask.begin() + static_cast<size_t>(q) * T_prompt_max,
-                      mask.begin() + static_cast<size_t>(q) * T_prompt_max + q + 1,
-                      mz);
-        ggml_backend_tensor_set(pb.mask_in, mask.data(), 0,
-                                mask.size() * sizeof(ggml_fp16_t));
+                      mask.begin() + static_cast<size_t>(q) * T_prompt_max + q + 1, mz);
+        }
+        ggml_backend_tensor_set(pb.mask_in, mask.data(), 0, mask.size() * sizeof(ggml_fp16_t));
     }
     // kv_idx [T_prompt_max, n] i64: idx[t,b] = t.
     {
         std::vector<int64_t> kidx(static_cast<size_t>(T_prompt_max) * n);
-        for (int b = 0; b < n; ++b)
-            for (int t = 0; t < T_prompt_max; ++t)
+        for (int b = 0; b < n; ++b) {
+            for (int t = 0; t < T_prompt_max; ++t) {
                 kidx[static_cast<size_t>(b) * T_prompt_max + t] = t;
-        ggml_backend_tensor_set(pb.kv_idx_in, kidx.data(), 0,
-                                kidx.size() * sizeof(int64_t));
+            }
+        }
+        ggml_backend_tensor_set(pb.kv_idx_in, kidx.data(), 0, kidx.size() * sizeof(int64_t));
     }
     // last_idx [1, n] i32: each utterance's last real position.
     {
         std::vector<int32_t> lidx(n, 0);
-        for (int b = 0; b < n; ++b)
+        for (int b = 0; b < n; ++b) {
             lidx[b] = valid[b] ? (T_prompt[b] - 1) : 0;
-        ggml_backend_tensor_set(pb.last_idx_in, lidx.data(), 0,
-                                lidx.size() * sizeof(int32_t));
+        }
+        ggml_backend_tensor_set(pb.last_idx_in, lidx.data(), 0, lidx.size() * sizeof(int32_t));
     }
 
     apply_sched_threads(cc);
-    if (ggml_backend_sched_graph_compute(cc->sched, pb.graph) !=
-        GGML_STATUS_SUCCESS) {
+    if (ggml_backend_sched_graph_compute(cc->sched, pb.graph) != GGML_STATUS_SUCCESS) {
         return TRANSCRIBE_ERR_GGUF;
     }
 
     std::vector<int32_t> amax(n, 0);
     ggml_backend_tensor_get(pb.out, amax.data(), 0, amax.size() * sizeof(int32_t));
-    for (int b = 0; b < n; ++b) first_tok_out[b] = amax[b];
+    for (int b = 0; b < n; ++b) {
+        first_tok_out[b] = amax[b];
+    }
     return TRANSCRIBE_OK;
 }
 
@@ -1524,30 +1420,35 @@ transcribe_status prefill_all_batched(
 // detokenize, parse the Qwen3-ASR "language X<asr_text>…" envelope). Mirrors
 // run()'s output-parsing tail; `lang_prefix_ptr` non-null means the caller
 // forced a language (so we don't surface a detected one).
-transcribe_session::ResultSet finalize_utterance(
-    QwenAsrModel * cm, std::vector<int32_t> generated_ids,
-    const std::vector<int32_t> * lang_prefix_ptr, int n_samples) {
+transcribe_session::ResultSet finalize_utterance(QwenAsrModel *               cm,
+                                                 std::vector<int32_t>         generated_ids,
+                                                 const std::vector<int32_t> * lang_prefix_ptr,
+                                                 int                          n_samples) {
     transcribe_session::ResultSet rs;
-    const int32_t eos_id = cm->hparams.eos_token_id;
-    if (!generated_ids.empty() && generated_ids.back() == eos_id)
+    const int32_t                 eos_id = cm->hparams.eos_token_id;
+    if (!generated_ids.empty() && generated_ids.back() == eos_id) {
         generated_ids.pop_back();
+    }
 
-    std::string raw_text = cm->tok.decode(
-        generated_ids.data(), static_cast<int>(generated_ids.size()));
+    std::string raw_text = cm->tok.decode(generated_ids.data(), static_cast<int>(generated_ids.size()));
 
     std::string transcript_text = raw_text;
     if (auto sep = raw_text.find("<asr_text>"); sep != std::string::npos) {
         if (lang_prefix_ptr == nullptr) {
             constexpr const char k_prefix[] = "language ";
-            const size_t name_start = raw_text.find(k_prefix);
+            const size_t         name_start = raw_text.find(k_prefix);
             if (name_start != std::string::npos && name_start < sep) {
-                const size_t ns = name_start + (sizeof(k_prefix) - 1);
-                std::string name = raw_text.substr(ns, sep - ns);
-                while (!name.empty() && (name.back() == ' ' ||
-                       name.back() == '\t' || name.back() == '\n'))
+                const size_t ns   = name_start + (sizeof(k_prefix) - 1);
+                std::string  name = raw_text.substr(ns, sep - ns);
+                while (!name.empty() && (name.back() == ' ' || name.back() == '\t' || name.back() == '\n')) {
                     name.pop_back();
-                for (const auto & e : k_qwen3_asr_language_names)
-                    if (name == e.pub_name) { rs.detected_language = e.bcp47; break; }
+                }
+                for (const auto & e : k_qwen3_asr_language_names) {
+                    if (name == e.pub_name) {
+                        rs.detected_language = e.bcp47;
+                        break;
+                    }
+                }
             }
         }
         transcript_text = raw_text.substr(sep + std::strlen("<asr_text>"));
@@ -1557,27 +1458,27 @@ transcribe_session::ResultSet finalize_utterance(
     rs.result_kind = TRANSCRIBE_TIMESTAMPS_NONE;
     rs.has_result  = true;
     rs.status      = TRANSCRIBE_OK;
-    transcribe_session::SegmentEntry seg {};
+    transcribe_session::SegmentEntry seg{};
     seg.text  = transcript_text;
     seg.t0_ms = 0;
-    seg.t1_ms = static_cast<int64_t>(n_samples) * 1000
-              / static_cast<int64_t>(cm->hparams.fe_sample_rate);
+    seg.t1_ms = static_cast<int64_t>(n_samples) * 1000 / static_cast<int64_t>(cm->hparams.fe_sample_rate);
     rs.segments.push_back(std::move(seg));
     return rs;
 }
 
 // Serial fallback: run() per utterance, capturing each into batch_results.
 // Used when batched decode is unavailable (flash off) or as the safe path.
-transcribe_status run_batch_serial(QwenAsrSession * cc,
-                                   const float * const * pcm,
-                                   const int * n_samples, int n,
+transcribe_status run_batch_serial(QwenAsrSession *              cc,
+                                   const float * const *         pcm,
+                                   const int *                   n_samples,
+                                   int                           n,
                                    const transcribe_run_params * params) {
     for (int i = 0; i < n; ++i) {
-        if (cc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
-        const transcribe_status st =
-            (pcm[i] == nullptr || n_samples[i] <= 0)
-                ? TRANSCRIBE_ERR_INVALID_ARG
-                : run(cc, pcm[i], n_samples[i], params);
+        if (cc->poll_abort()) {
+            return TRANSCRIBE_ERR_ABORTED;
+        }
+        const transcribe_status st = (pcm[i] == nullptr || n_samples[i] <= 0) ? TRANSCRIBE_ERR_INVALID_ARG :
+                                                                                run(cc, pcm[i], n_samples[i], params);
         if (st == TRANSCRIBE_OK) {
             cc->batch_results.push_back(cc->capture_result(st));
         } else {
@@ -1589,22 +1490,25 @@ transcribe_status run_batch_serial(QwenAsrSession * cc,
     return TRANSCRIBE_OK;
 }
 
-} // namespace
+}  // namespace
 
-transcribe_status run_batch(
-    transcribe_session *          session,
-    const float * const *         pcm,
-    const int *                   n_samples,
-    int                           n,
-    const transcribe_run_params * params) {
-    if (session == nullptr || pcm == nullptr || n_samples == nullptr || n <= 0)
+transcribe_status run_batch(transcribe_session *          session,
+                            const float * const *         pcm,
+                            const int *                   n_samples,
+                            int                           n,
+                            const transcribe_run_params * params) {
+    if (session == nullptr || pcm == nullptr || n_samples == nullptr || n <= 0) {
         return TRANSCRIBE_ERR_INVALID_ARG;
+    }
 
     auto * cc = static_cast<QwenAsrSession *>(session);
     auto * cm = static_cast<QwenAsrModel *>(cc->model);
-    if (cm == nullptr || cm->plan.scheduler_list.empty())
+    if (cm == nullptr || cm->plan.scheduler_list.empty()) {
         return TRANSCRIBE_ERR_INVALID_ARG;
-    if (!cm->mel.has_value()) return TRANSCRIBE_ERR_INVALID_ARG;
+    }
+    if (!cm->mel.has_value()) {
+        return TRANSCRIBE_ERR_INVALID_ARG;
+    }
 
     // Batched decode requires the flash-attention step path and dump-free
     // operation. Fall back to the serial loop otherwise (same results).
@@ -1615,12 +1519,10 @@ transcribe_status run_batch(
     transcribe::debug::init();
 
     // Shared language hint (v1: one run_params across the batch).
-    std::vector<int32_t> lang_prefix_ids;
+    std::vector<int32_t>         lang_prefix_ids;
     const std::vector<int32_t> * lang_prefix_ptr = nullptr;
-    if (params != nullptr && params->language != nullptr &&
-        params->language[0] != '\0') {
-        if (encode_language_prefix(cm->tok, params->language, lang_prefix_ids)
-            != TRANSCRIBE_OK) {
+    if (params != nullptr && params->language != nullptr && params->language[0] != '\0') {
+        if (encode_language_prefix(cm->tok, params->language, lang_prefix_ids) != TRANSCRIBE_OK) {
             return TRANSCRIBE_ERR_UNSUPPORTED_LANGUAGE;
         }
         lang_prefix_ptr = &lang_prefix_ids;
@@ -1628,19 +1530,19 @@ transcribe_status run_batch(
 
     // Pass 1: per-utterance encoder + prefill into KV slabs.
     std::vector<std::vector<int32_t>> generated(n);
-    std::vector<int>     T_prompt(n, 0);
-    std::vector<int32_t> next_tok(n, 0);
-    std::vector<int>     n_past(n, 0);
-    std::vector<char>    valid(n, 0);    // utterance produced a usable prefill
-    int64_t mel_us = 0, enc_us = 0;
+    std::vector<int>                  T_prompt(n, 0);
+    std::vector<int32_t>              next_tok(n, 0);
+    std::vector<int>                  n_past(n, 0);
+    std::vector<char>                 valid(n, 0);  // utterance produced a usable prefill
+    int64_t                           mel_us = 0, enc_us = 0;
 
     // Encode every utterance first so we can size the batched cache to the
     // real max prompt length before allocating it.
     std::vector<std::vector<float>> enc_hosts(n);
-    std::vector<int>  T_enc(n, 0);
-    const int64_t t_encpass0 = ggml_time_us();
-    if (const transcribe_status st = encode_all_batched(
-            cc, cm, pcm, n_samples, n, valid, enc_hosts, T_enc, mel_us, enc_us);
+    std::vector<int>                T_enc(n, 0);
+    const int64_t                   t_encpass0 = ggml_time_us();
+    if (const transcribe_status st =
+            encode_all_batched(cc, cm, pcm, n_samples, n, valid, enc_hosts, T_enc, mel_us, enc_us);
         st != TRANSCRIBE_OK) {
         return st;
     }
@@ -1648,28 +1550,29 @@ transcribe_status run_batch(
 
     // Prompt length bound → max_n_kv and batched-cache n_ctx. Build and keep
     // each utterance's prompt token ids for the batched prefill.
-    const int max_new = 256;
-    int max_T_prompt = 0;
-    int prefix_len   = 0;
+    const int                         max_new      = 256;
+    int                               max_T_prompt = 0;
+    int                               prefix_len   = 0;
     // Per-utterance terminal status for rejected rows. Defaults to INVALID_ARG;
     // over-length rows below are upgraded to INPUT_TOO_LONG.
-    const int ceiling = qwen3_context_ceiling(cc->n_ctx, cm->hparams);
-    std::vector<transcribe_status> fail_status(n, TRANSCRIBE_ERR_INVALID_ARG);
+    const int                         ceiling      = qwen3_context_ceiling(cc->n_ctx, cm->hparams);
+    std::vector<transcribe_status>    fail_status(n, TRANSCRIBE_ERR_INVALID_ARG);
     std::vector<std::vector<int32_t>> prompt_ids(n);
     for (int b = 0; b < n; ++b) {
-        if (!valid[b]) continue;
+        if (!valid[b]) {
+            continue;
+        }
         std::vector<int64_t> ap;
-        build_prompt_tokens(cm->hparams, cm->chat_tokens, T_enc[b],
-                            lang_prefix_ptr, prompt_ids[b], ap);
-        T_prompt[b]  = static_cast<int>(prompt_ids[b].size());
-        prefix_len   = ap.empty() ? 0 : static_cast<int>(ap.front());
+        build_prompt_tokens(cm->hparams, cm->chat_tokens, T_enc[b], lang_prefix_ptr, prompt_ids[b], ap);
+        T_prompt[b] = static_cast<int>(prompt_ids[b].size());
+        prefix_len  = ap.empty() ? 0 : static_cast<int>(ap.front());
         // Same gate as single-shot run(); the rest of the batch still runs.
         if (T_prompt[b] + max_new > ceiling) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "qwen3_asr run_batch: utterance %d input too long — %d audio + "
-                "%d prompt tokens exceed the %d-token context. See "
-                "transcribe_capabilities.max_audio_ms.",
-                b, T_enc[b], T_prompt[b] - T_enc[b], ceiling);
+                                "qwen3_asr run_batch: utterance %d input too long — %d audio + "
+                                "%d prompt tokens exceed the %d-token context. See "
+                                "transcribe_capabilities.max_audio_ms.",
+                                b, T_enc[b], T_prompt[b] - T_enc[b], ceiling);
             valid[b]       = 0;
             fail_status[b] = TRANSCRIBE_ERR_INPUT_TOO_LONG;
             continue;
@@ -1686,26 +1589,27 @@ transcribe_status run_batch(
         return TRANSCRIBE_OK;
     }
     int max_n_kv = 1024;
-    while (max_n_kv < max_T_prompt + max_new) max_n_kv *= 2;
+    while (max_n_kv < max_T_prompt + max_new) {
+        max_n_kv *= 2;
+    }
     // Clamp the pow2 round-up to the ceiling (the per-utterance gate guarantees
     // every valid row still fits).
-    if (max_n_kv > ceiling) max_n_kv = ceiling;
+    if (max_n_kv > ceiling) {
+        max_n_kv = ceiling;
+    }
 
     // Allocate / reuse the batched KV cache (n_ctx == max_n_kv, n slabs).
-    ggml_type kv_type = (cc->kv_type == TRANSCRIBE_KV_TYPE_F32)
-                      ? GGML_TYPE_F32 : GGML_TYPE_F16;
-    if (cc->kv_cache_batch.self_k == nullptr ||
-        cc->kv_batch_cap != n || cc->kv_batch_n_ctx != max_n_kv) {
+    ggml_type kv_type = (cc->kv_type == TRANSCRIBE_KV_TYPE_F32) ? GGML_TYPE_F32 : GGML_TYPE_F16;
+    if (cc->kv_cache_batch.self_k == nullptr || cc->kv_batch_cap != n || cc->kv_batch_n_ctx != max_n_kv) {
         cc->kv_cache_batch.free();
-        if (!transcribe::causal_lm::kv_init_batched(
-                cc->kv_cache_batch, cm->plan.primary, max_n_kv,
-                cm->hparams.dec_n_kv_heads, cm->hparams.dec_head_dim,
-                cm->hparams.dec_n_layers, n, kv_type)) {
+        if (!transcribe::causal_lm::kv_init_batched(cc->kv_cache_batch, cm->plan.primary, max_n_kv,
+                                                    cm->hparams.dec_n_kv_heads, cm->hparams.dec_head_dim,
+                                                    cm->hparams.dec_n_layers, n, kv_type)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "qwen3_asr run_batch: batched KV cache allocation failed "
-                "(n_ctx=%d x %d utterances) — out of memory. Lower "
-                "transcribe_session_params.n_ctx or the batch size.",
-                max_n_kv, n);
+                                "qwen3_asr run_batch: batched KV cache allocation failed "
+                                "(n_ctx=%d x %d utterances) — out of memory. Lower "
+                                "transcribe_session_params.n_ctx or the batch size.",
+                                max_n_kv, n);
             return TRANSCRIBE_ERR_OOM;
         }
         cc->kv_batch_cap   = n;
@@ -1717,13 +1621,15 @@ transcribe_status run_batch(
     const int64_t t_prefpass0 = ggml_time_us();
     {
         std::vector<int32_t> first_tok(n, 0);
-        if (const transcribe_status st = prefill_all_batched(
-                cc, cm, valid, prompt_ids, T_prompt, prefix_len,
-                enc_hosts, T_enc, n, first_tok); st != TRANSCRIBE_OK) {
+        if (const transcribe_status st =
+                prefill_all_batched(cc, cm, valid, prompt_ids, T_prompt, prefix_len, enc_hosts, T_enc, n, first_tok);
+            st != TRANSCRIBE_OK) {
             return st;
         }
         for (int b = 0; b < n; ++b) {
-            if (!valid[b]) continue;
+            if (!valid[b]) {
+                continue;
+            }
             n_past[b]   = T_prompt[b];
             next_tok[b] = first_tok[b];
             generated[b].push_back(first_tok[b]);
@@ -1734,17 +1640,20 @@ transcribe_status run_batch(
     // Pass 2: batched step loop (shared causal_lm driver).
     const int32_t eos_id = cm->hparams.eos_token_id;
 
-    if (const transcribe_status st = reset_compute_ctx(cc, 16); st != TRANSCRIBE_OK)
+    if (const transcribe_status st = reset_compute_ctx(cc, 16); st != TRANSCRIBE_OK) {
         return st;
-    StepBuildBatched sb = build_step_graph_batched(
-        cc->compute_ctx, cm->weights, cm->hparams, cc->kv_cache_batch,
-        max_n_kv, n, cc->decoder_use_flash);
-    if (sb.graph == nullptr || sb.out == nullptr) return TRANSCRIBE_ERR_GGUF;
+    }
+    StepBuildBatched sb = build_step_graph_batched(cc->compute_ctx, cm->weights, cm->hparams, cc->kv_cache_batch,
+                                                   max_n_kv, n, cc->decoder_use_flash);
+    if (sb.graph == nullptr || sb.out == nullptr) {
+        return TRANSCRIBE_ERR_GGUF;
+    }
     ggml_backend_sched_reset(cc->sched);
-    if (!ggml_backend_sched_alloc_graph(cc->sched, sb.graph))
+    if (!ggml_backend_sched_alloc_graph(cc->sched, sb.graph)) {
         return TRANSCRIBE_ERR_GGUF;
+    }
 
-    transcribe::causal_lm::StepBatchedIO io {};
+    transcribe::causal_lm::StepBatchedIO io{};
     io.input_ids = sb.input_ids_in;
     io.positions = sb.position_in;
     io.kv_idx    = sb.kv_idx_in;
@@ -1758,18 +1667,17 @@ transcribe_status run_batch(
     step_state.n_past   = n_past;
 
     transcribe::causal_lm::StepLoopStats step_stats;
-    std::vector<char> truncated;
+    std::vector<char>                    truncated;
     if (const transcribe_status st = transcribe::causal_lm::run_batched_step_loop(
-            cc, cc->sched, io, n, max_n_kv, eos_id, max_new, step_state,
-            generated, &step_stats, &truncated); st != TRANSCRIBE_OK) {
+            cc, cc->sched, io, n, max_n_kv, eos_id, max_new, step_state, generated, &step_stats, &truncated);
+        st != TRANSCRIBE_OK) {
         return st;
     }
     const int64_t step_us = step_stats.step_us;
     const int     n_steps = step_stats.n_steps;
 
     // Capture per-utterance results.
-    const int valid_count = std::max(1, static_cast<int>(
-        std::count(valid.begin(), valid.end(), char(1))));
+    const int valid_count = std::max(1, static_cast<int>(std::count(valid.begin(), valid.end(), char(1))));
     for (int b = 0; b < n; ++b) {
         if (!valid[b]) {
             transcribe_session::ResultSet rs;
@@ -1777,12 +1685,11 @@ transcribe_status run_batch(
             cc->batch_results.push_back(std::move(rs));
             continue;
         }
-        transcribe_session::ResultSet rs =
-            finalize_utterance(cm, generated[b], lang_prefix_ptr, n_samples[b]);
+        transcribe_session::ResultSet rs = finalize_utterance(cm, generated[b], lang_prefix_ptr, n_samples[b]);
         // Per-utterance truncation parity with the single-shot path.
         if (b < static_cast<int>(truncated.size()) && truncated[b]) {
             cc->was_truncated = true;
-            rs.status = TRANSCRIBE_ERR_OUTPUT_TRUNCATED;
+            rs.status         = TRANSCRIBE_ERR_OUTPUT_TRUNCATED;
         }
         rs.t_mel_us    = mel_us / valid_count;
         rs.t_encode_us = enc_us / valid_count;
@@ -1792,21 +1699,18 @@ transcribe_status run_batch(
 
     if (transcribe::env::flag("TRANSCRIBE_PERF_DEBUG")) {
         log_msg(TRANSCRIBE_LOG_LEVEL_DEBUG,
-            "qwen3_asr run_batch: n=%d valid=%d max_n_kv=%d steps=%d (all phases batched x%d)\n"
-            "  enc_pass=%.1fms (mel=%.1f parallel + enc_compute=%.1f, 1 graph)\n"
-            "  prefill_pass=%.1fms (1 batched graph: build/sched/compute/readback)\n"
-            "  step_loop=%.1fms (%.2fms/step)",
-            n, valid_count, max_n_kv, n_steps, valid_count,
-            enc_pass_us / 1000.0, mel_us / 1000.0, enc_us / 1000.0,
-            prefill_pass_us / 1000.0,
-            step_us / 1000.0,
-            n_steps > 0 ? step_us / 1000.0 / n_steps : 0.0);
+                "qwen3_asr run_batch: n=%d valid=%d max_n_kv=%d steps=%d (all phases batched x%d)\n"
+                "  enc_pass=%.1fms (mel=%.1f parallel + enc_compute=%.1f, 1 graph)\n"
+                "  prefill_pass=%.1fms (1 batched graph: build/sched/compute/readback)\n"
+                "  step_loop=%.1fms (%.2fms/step)",
+                n, valid_count, max_n_kv, n_steps, valid_count, enc_pass_us / 1000.0, mel_us / 1000.0, enc_us / 1000.0,
+                prefill_pass_us / 1000.0, step_us / 1000.0, n_steps > 0 ? step_us / 1000.0 / n_steps : 0.0);
     }
 
     return TRANSCRIBE_OK;
 }
 
-} // namespace
+}  // namespace
 
 extern const Arch arch = {
     /* .name             = */ "qwen3_asr",
@@ -1822,4 +1726,4 @@ extern const Arch arch = {
     /* .accepts_ext_kind = */ nullptr,
 };
 
-} // namespace transcribe::qwen3_asr
+}  // namespace transcribe::qwen3_asr
diff --git a/src/arch/qwen3_asr/qwen3_asr.h b/src/arch/qwen3_asr/qwen3_asr.h
index a40974b1..91378235 100644
--- a/src/arch/qwen3_asr/qwen3_asr.h
+++ b/src/arch/qwen3_asr/qwen3_asr.h
@@ -7,16 +7,15 @@
 #pragma once
 
 #include "causal_lm/causal_lm.h"
+#include "ggml-backend.h"
+#include "ggml.h"
 #include "transcribe-backend.h"
-#include "transcribe-session.h"
 #include "transcribe-mel.h"
 #include "transcribe-model.h"
+#include "transcribe-session.h"
 #include "transcribe-tokenizer.h"
 #include "weights.h"
 
-#include "ggml.h"
-#include "ggml-backend.h"
-
 #include <cstdint>
 #include <optional>
 #include <string>
@@ -72,13 +71,13 @@ struct ChatTokens {
 };
 
 struct QwenAsrModel final : public transcribe_model {
-    Tokenizer       tok;
-    QwenAsrHParams  hparams;
-    QwenAsrWeights  weights;
-    ggml_context *  ctx_meta = nullptr;
+    Tokenizer      tok;
+    QwenAsrHParams hparams;
+    QwenAsrWeights weights;
+    ggml_context * ctx_meta = nullptr;
 
-    transcribe::BackendPlan       plan;
-    ggml_backend_buffer_t         backend_buffer = nullptr;
+    transcribe::BackendPlan                    plan;
+    ggml_backend_buffer_t                      backend_buffer = nullptr;
     transcribe::causal_lm::PackedGateUpHandles packed_gate_up;
 
     std::optional<transcribe::MelFrontend> mel;
@@ -104,13 +103,12 @@ struct QwenAsrSession final : public transcribe_session {
     // Batched KV cache for offline transcribe_run_batch (n_batch slabs).
     // Allocated/resized lazily by run_batch; freed in the destructor.
     transcribe::causal_lm::KvCache kv_cache_batch;
-    int                           kv_batch_cap   = 0;  // allocated n_batch
-    int                           kv_batch_n_ctx = 0;  // allocated n_ctx
+    int                            kv_batch_cap   = 0;  // allocated n_batch
+    int                            kv_batch_n_ctx = 0;  // allocated n_ctx
 
     std::vector<float> mel_buf;
     std::vector<float> enc_host;  // audio encoder output, pre-injection
 
-
     bool encoder_use_flash = true;
     bool decoder_use_flash = true;
 
@@ -118,4 +116,4 @@ struct QwenAsrSession final : public transcribe_session {
     ~QwenAsrSession() override;
 };
 
-} // namespace transcribe::qwen3_asr
+}  // namespace transcribe::qwen3_asr
diff --git a/src/arch/qwen3_asr/weights.cpp b/src/arch/qwen3_asr/weights.cpp
index 24f1fdc3..cf27783f 100644
--- a/src/arch/qwen3_asr/weights.cpp
+++ b/src/arch/qwen3_asr/weights.cpp
@@ -12,12 +12,11 @@
 
 #include "weights.h"
 
-#include "transcribe-meta.h"
-#include "transcribe-weights-util.h"
-#include "transcribe-log.h"
-
 #include "ggml.h"
 #include "gguf.h"
+#include "transcribe-log.h"
+#include "transcribe-meta.h"
+#include "transcribe-weights-util.h"
 
 #include <cstdio>
 
@@ -27,66 +26,205 @@ namespace {
 constexpr const char * kFamilyTag = "qwen3_asr";
 }
 
-transcribe_status read_qwen3_asr_hparams(const gguf_context * gguf,
-                                         QwenAsrHParams &     hp)
-{
+transcribe_status read_qwen3_asr_hparams(const gguf_context * gguf, QwenAsrHParams & hp) {
     if (gguf == nullptr) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
 
     // Audio encoder.
-    if (auto st = read_required_u32_kv(gguf, "stt.qwen3_asr.encoder.n_layers", kFamilyTag, hp.enc_n_layers); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.qwen3_asr.encoder.d_model", kFamilyTag, hp.enc_d_model); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.qwen3_asr.encoder.n_heads", kFamilyTag, hp.enc_n_heads); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.qwen3_asr.encoder.ffn_dim", kFamilyTag, hp.enc_ffn_dim); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.qwen3_asr.encoder.num_mel_bins", kFamilyTag, hp.enc_num_mel_bins); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.qwen3_asr.encoder.downsample_hidden", kFamilyTag, hp.enc_downsample_hidden); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.qwen3_asr.encoder.output_dim", kFamilyTag, hp.enc_output_dim); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.qwen3_asr.encoder.max_source_positions", kFamilyTag, hp.enc_max_source_positions); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.qwen3_asr.encoder.n_window", kFamilyTag, hp.enc_n_window); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.qwen3_asr.encoder.n_window_infer", kFamilyTag, hp.enc_n_window_infer); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.qwen3_asr.encoder.conv_chunksize", kFamilyTag, hp.enc_conv_chunksize); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.qwen3_asr.encoder.activation", kFamilyTag, hp.enc_activation); st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_u32_kv(gguf, "stt.qwen3_asr.encoder.n_layers", kFamilyTag, hp.enc_n_layers);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.qwen3_asr.encoder.d_model", kFamilyTag, hp.enc_d_model);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.qwen3_asr.encoder.n_heads", kFamilyTag, hp.enc_n_heads);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.qwen3_asr.encoder.ffn_dim", kFamilyTag, hp.enc_ffn_dim);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.qwen3_asr.encoder.num_mel_bins", kFamilyTag, hp.enc_num_mel_bins);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st =
+            read_required_u32_kv(gguf, "stt.qwen3_asr.encoder.downsample_hidden", kFamilyTag, hp.enc_downsample_hidden);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.qwen3_asr.encoder.output_dim", kFamilyTag, hp.enc_output_dim);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.qwen3_asr.encoder.max_source_positions", kFamilyTag,
+                                       hp.enc_max_source_positions);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.qwen3_asr.encoder.n_window", kFamilyTag, hp.enc_n_window);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.qwen3_asr.encoder.n_window_infer", kFamilyTag, hp.enc_n_window_infer);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.qwen3_asr.encoder.conv_chunksize", kFamilyTag, hp.enc_conv_chunksize);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_string_kv(gguf, "stt.qwen3_asr.encoder.activation", kFamilyTag, hp.enc_activation);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Text LM.
-    if (auto st = read_required_u32_kv(gguf, "stt.qwen3_asr.decoder.n_layers", kFamilyTag, hp.dec_n_layers); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.qwen3_asr.decoder.hidden_size", kFamilyTag, hp.dec_hidden); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.qwen3_asr.decoder.intermediate_size", kFamilyTag, hp.dec_intermediate); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.qwen3_asr.decoder.n_heads", kFamilyTag, hp.dec_n_heads); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.qwen3_asr.decoder.n_kv_heads", kFamilyTag, hp.dec_n_kv_heads); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.qwen3_asr.decoder.head_dim", kFamilyTag, hp.dec_head_dim); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.qwen3_asr.decoder.hidden_act", kFamilyTag, hp.dec_hidden_act); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf, "stt.qwen3_asr.decoder.rms_norm_eps", kFamilyTag, hp.dec_rms_norm_eps); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf, "stt.qwen3_asr.decoder.rope_theta", kFamilyTag, hp.dec_rope_theta); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.qwen3_asr.decoder.rope_mrope_section_t", kFamilyTag, hp.dec_rope_mrope_section_t); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.qwen3_asr.decoder.rope_mrope_section_h", kFamilyTag, hp.dec_rope_mrope_section_h); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.qwen3_asr.decoder.rope_mrope_section_w", kFamilyTag, hp.dec_rope_mrope_section_w); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_bool_kv(gguf, "stt.qwen3_asr.decoder.rope_mrope_interleaved", kFamilyTag, true, hp.dec_rope_mrope_interleaved); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.qwen3_asr.decoder.max_position_embeddings", kFamilyTag, hp.dec_max_position_embeddings); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_bool_kv(gguf, "stt.qwen3_asr.decoder.tie_word_embeddings", kFamilyTag, true, hp.dec_tie_word_embeddings); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.qwen3_asr.decoder.vocab_size", kFamilyTag, hp.dec_vocab_size); st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_u32_kv(gguf, "stt.qwen3_asr.decoder.n_layers", kFamilyTag, hp.dec_n_layers);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.qwen3_asr.decoder.hidden_size", kFamilyTag, hp.dec_hidden);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st =
+            read_required_u32_kv(gguf, "stt.qwen3_asr.decoder.intermediate_size", kFamilyTag, hp.dec_intermediate);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.qwen3_asr.decoder.n_heads", kFamilyTag, hp.dec_n_heads);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.qwen3_asr.decoder.n_kv_heads", kFamilyTag, hp.dec_n_kv_heads);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.qwen3_asr.decoder.head_dim", kFamilyTag, hp.dec_head_dim);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_string_kv(gguf, "stt.qwen3_asr.decoder.hidden_act", kFamilyTag, hp.dec_hidden_act);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.qwen3_asr.decoder.rms_norm_eps", kFamilyTag, hp.dec_rms_norm_eps);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.qwen3_asr.decoder.rope_theta", kFamilyTag, hp.dec_rope_theta);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.qwen3_asr.decoder.rope_mrope_section_t", kFamilyTag,
+                                       hp.dec_rope_mrope_section_t);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.qwen3_asr.decoder.rope_mrope_section_h", kFamilyTag,
+                                       hp.dec_rope_mrope_section_h);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.qwen3_asr.decoder.rope_mrope_section_w", kFamilyTag,
+                                       hp.dec_rope_mrope_section_w);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_bool_kv(gguf, "stt.qwen3_asr.decoder.rope_mrope_interleaved", kFamilyTag, true,
+                                        hp.dec_rope_mrope_interleaved);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.qwen3_asr.decoder.max_position_embeddings", kFamilyTag,
+                                       hp.dec_max_position_embeddings);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_bool_kv(gguf, "stt.qwen3_asr.decoder.tie_word_embeddings", kFamilyTag, true,
+                                        hp.dec_tie_word_embeddings);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.qwen3_asr.decoder.vocab_size", kFamilyTag, hp.dec_vocab_size);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Audio-token injection ids.
-    if (auto st = read_required_u32_kv(gguf, "stt.qwen3_asr.audio_token_id", kFamilyTag, hp.audio_token_id); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.qwen3_asr.audio_start_token_id", kFamilyTag, hp.audio_start_token_id); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.qwen3_asr.audio_end_token_id", kFamilyTag, hp.audio_end_token_id); st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_u32_kv(gguf, "stt.qwen3_asr.audio_token_id", kFamilyTag, hp.audio_token_id);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.qwen3_asr.audio_start_token_id", kFamilyTag, hp.audio_start_token_id);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.qwen3_asr.audio_end_token_id", kFamilyTag, hp.audio_end_token_id);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Frontend.
-    if (auto st = read_required_string_kv(gguf, "stt.frontend.type", kFamilyTag, hp.fe_type); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.frontend.num_mels", kFamilyTag, hp.fe_num_mels); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.frontend.sample_rate", kFamilyTag, hp.fe_sample_rate); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.frontend.n_fft", kFamilyTag, hp.fe_n_fft); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.frontend.win_length", kFamilyTag, hp.fe_win_length); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.frontend.hop_length", kFamilyTag, hp.fe_hop_length); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.frontend.window", kFamilyTag, hp.fe_window); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.frontend.normalize", kFamilyTag, hp.fe_normalize); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf, "stt.frontend.dither", kFamilyTag, hp.fe_dither); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf, "stt.frontend.pre_emphasis", kFamilyTag, hp.fe_pre_emphasis); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf, "stt.frontend.f_min", kFamilyTag, hp.fe_f_min); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf, "stt.frontend.f_max", kFamilyTag, hp.fe_f_max); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_string_kv(gguf, "stt.frontend.pad_mode", kFamilyTag, "reflect", hp.fe_pad_mode); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_string_kv(gguf, "stt.frontend.mel_norm", kFamilyTag, "slaney", hp.fe_mel_norm); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_bool_kv(gguf, "stt.frontend.center", kFamilyTag, true, hp.fe_center); st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_string_kv(gguf, "stt.frontend.type", kFamilyTag, hp.fe_type); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.num_mels", kFamilyTag, hp.fe_num_mels);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.sample_rate", kFamilyTag, hp.fe_sample_rate);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.n_fft", kFamilyTag, hp.fe_n_fft); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.win_length", kFamilyTag, hp.fe_win_length);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.hop_length", kFamilyTag, hp.fe_hop_length);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_string_kv(gguf, "stt.frontend.window", kFamilyTag, hp.fe_window); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_string_kv(gguf, "stt.frontend.normalize", kFamilyTag, hp.fe_normalize);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.frontend.dither", kFamilyTag, hp.fe_dither); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.frontend.pre_emphasis", kFamilyTag, hp.fe_pre_emphasis);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.frontend.f_min", kFamilyTag, hp.fe_f_min); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.frontend.f_max", kFamilyTag, hp.fe_f_max); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_string_kv(gguf, "stt.frontend.pad_mode", kFamilyTag, "reflect", hp.fe_pad_mode);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_string_kv(gguf, "stt.frontend.mel_norm", kFamilyTag, "slaney", hp.fe_mel_norm);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_bool_kv(gguf, "stt.frontend.center", kFamilyTag, true, hp.fe_center);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
     // Whisper-style windowing: chunk_length / n_samples / nb_max_frames
     // describe the reference preprocessor's fixed 30s chunking. Treated
     // as optional because not every future Qwen3-ASR variant will carry
@@ -97,61 +235,65 @@ transcribe_status read_qwen3_asr_hparams(const gguf_context * gguf,
         const auto read_optional = [&](const char * key, int32_t & dst) -> transcribe_status {
             uint32_t tmp = 0;
             switch (read_uint32_kv(gguf, key, tmp)) {
-                case KvResult::Ok:      dst = static_cast<int32_t>(tmp); return TRANSCRIBE_OK;
-                case KvResult::Absent:                                    return TRANSCRIBE_OK;
+                case KvResult::Ok:
+                    dst = static_cast<int32_t>(tmp);
+                    return TRANSCRIBE_OK;
+                case KvResult::Absent:
+                    return TRANSCRIBE_OK;
                 case KvResult::BadType:
-                    log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                                 "qwen3_asr: \"%s\" has wrong type", key);
+                    log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "qwen3_asr: \"%s\" has wrong type", key);
                     return TRANSCRIBE_ERR_GGUF;
             }
             return TRANSCRIBE_ERR_GGUF;  // unreachable
         };
-        if (auto st = read_optional("stt.frontend.chunk_length",  hp.fe_chunk_length ); st != TRANSCRIBE_OK) return st;
-        if (auto st = read_optional("stt.frontend.n_samples",     hp.fe_n_samples    ); st != TRANSCRIBE_OK) return st;
-        if (auto st = read_optional("stt.frontend.nb_max_frames", hp.fe_nb_max_frames); st != TRANSCRIBE_OK) return st;
+        if (auto st = read_optional("stt.frontend.chunk_length", hp.fe_chunk_length); st != TRANSCRIBE_OK) {
+            return st;
+        }
+        if (auto st = read_optional("stt.frontend.n_samples", hp.fe_n_samples); st != TRANSCRIBE_OK) {
+            return st;
+        }
+        if (auto st = read_optional("stt.frontend.nb_max_frames", hp.fe_nb_max_frames); st != TRANSCRIBE_OK) {
+            return st;
+        }
     }
 
     // Cross-field invariants.
-    if (hp.enc_n_layers <= 0 || hp.enc_d_model <= 0 || hp.enc_n_heads <= 0 ||
-        hp.enc_ffn_dim <= 0 || hp.enc_downsample_hidden <= 0 ||
-        hp.enc_output_dim <= 0 || hp.enc_num_mel_bins <= 0)
-    {
+    if (hp.enc_n_layers <= 0 || hp.enc_d_model <= 0 || hp.enc_n_heads <= 0 || hp.enc_ffn_dim <= 0 ||
+        hp.enc_downsample_hidden <= 0 || hp.enc_output_dim <= 0 || hp.enc_num_mel_bins <= 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "qwen3_asr: encoder hparams must be positive");
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.enc_d_model % hp.enc_n_heads != 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "qwen3_asr: encoder d_model (%d) not divisible by n_heads (%d)",
-                     hp.enc_d_model, hp.enc_n_heads);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "qwen3_asr: encoder d_model (%d) not divisible by n_heads (%d)",
+                hp.enc_d_model, hp.enc_n_heads);
         return TRANSCRIBE_ERR_GGUF;
     }
-    if (hp.dec_n_layers <= 0 || hp.dec_hidden <= 0 || hp.dec_n_heads <= 0 ||
-        hp.dec_n_kv_heads <= 0 || hp.dec_head_dim <= 0 || hp.dec_intermediate <= 0)
-    {
+    if (hp.dec_n_layers <= 0 || hp.dec_hidden <= 0 || hp.dec_n_heads <= 0 || hp.dec_n_kv_heads <= 0 ||
+        hp.dec_head_dim <= 0 || hp.dec_intermediate <= 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "qwen3_asr: decoder hparams must be positive");
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.dec_n_heads % hp.dec_n_kv_heads != 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "qwen3_asr: n_heads (%d) not divisible by n_kv_heads (%d)",
-                     hp.dec_n_heads, hp.dec_n_kv_heads);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "qwen3_asr: n_heads (%d) not divisible by n_kv_heads (%d)", hp.dec_n_heads,
+                hp.dec_n_kv_heads);
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.dec_hidden_act != "silu" && hp.dec_hidden_act != "swish") {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "qwen3_asr: unsupported decoder hidden_act \"%s\" "
-                     "(only silu/swish)", hp.dec_hidden_act.c_str());
+                "qwen3_asr: unsupported decoder hidden_act \"%s\" "
+                "(only silu/swish)",
+                hp.dec_hidden_act.c_str());
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.enc_activation != "gelu") {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "qwen3_asr: unsupported encoder activation \"%s\" "
-                     "(only gelu)", hp.enc_activation.c_str());
+                "qwen3_asr: unsupported encoder activation \"%s\" "
+                "(only gelu)",
+                hp.enc_activation.c_str());
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.fe_type != "mel") {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "qwen3_asr: unsupported frontend type \"%s\"",
-                     hp.fe_type.c_str());
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "qwen3_asr: unsupported frontend type \"%s\"", hp.fe_type.c_str());
         return TRANSCRIBE_ERR_GGUF;
     }
     // The graph reuses dec.token_embd.weight as the output projection.
@@ -160,8 +302,8 @@ transcribe_status read_qwen3_asr_hparams(const gguf_context * gguf,
     // fail at load rather than silently run an undefined graph.
     if (!hp.dec_tie_word_embeddings) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "qwen3_asr: decoder.tie_word_embeddings=false is not "
-                     "supported in this port (graph assumes tied lm_head)");
+                "qwen3_asr: decoder.tie_word_embeddings=false is not "
+                "supported in this port (graph assumes tied lm_head)");
         return TRANSCRIBE_ERR_GGUF;
     }
     // Single-modality audio-LLM: the LM at inference processes one
@@ -172,15 +314,14 @@ transcribe_status read_qwen3_asr_hparams(const gguf_context * gguf,
     // that breaks the single-modality assumption fails at load rather
     // than silently mis-rotating Q/K.
     {
-        const int32_t section_sum = hp.dec_rope_mrope_section_t +
-                                    hp.dec_rope_mrope_section_h +
-                                    hp.dec_rope_mrope_section_w;
+        const int32_t section_sum =
+            hp.dec_rope_mrope_section_t + hp.dec_rope_mrope_section_h + hp.dec_rope_mrope_section_w;
         const int32_t half = hp.dec_head_dim / 2;
         if (section_sum != half) {
             log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "qwen3_asr: mrope_section t+h+w (%d) != head_dim/2 (%d); "
-                         "single-modality RoPE reduction no longer valid",
-                         section_sum, half);
+                    "qwen3_asr: mrope_section t+h+w (%d) != head_dim/2 (%d); "
+                    "single-modality RoPE reduction no longer valid",
+                    section_sum, half);
             return TRANSCRIBE_ERR_GGUF;
         }
         // The decoder graph assumes the interleaved MRoPE layout (pairs
@@ -190,9 +331,9 @@ transcribe_status read_qwen3_asr_hparams(const gguf_context * gguf,
         // at load rather than silently produce wrong logits.
         if (!hp.dec_rope_mrope_interleaved) {
             log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "qwen3_asr: dec_rope_mrope_interleaved=false is not "
-                         "supported; the decoder graph assumes the interleaved "
-                         "MRoPE layout");
+                    "qwen3_asr: dec_rope_mrope_interleaved=false is not "
+                    "supported; the decoder graph assumes the interleaved "
+                    "MRoPE layout");
             return TRANSCRIBE_ERR_GGUF;
         }
     }
@@ -203,9 +344,9 @@ transcribe_status read_qwen3_asr_hparams(const gguf_context * gguf,
     // a clearer error and avoids paying encoder cost on every run().
     if (hp.enc_output_dim != hp.dec_hidden) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "qwen3_asr: enc_output_dim (%d) != dec_hidden (%d); "
-                     "audio injection requires matching dims",
-                     hp.enc_output_dim, hp.dec_hidden);
+                "qwen3_asr: enc_output_dim (%d) != dec_hidden (%d); "
+                "audio injection requires matching dims",
+                hp.enc_output_dim, hp.dec_hidden);
         return TRANSCRIBE_ERR_GGUF;
     }
     return TRANSCRIBE_OK;
@@ -220,55 +361,52 @@ namespace {
 using transcribe::weights::lname;
 constexpr const char * kTag = kFamilyTag;
 
-#define GET_F32(slot, name, ...) \
-    do { \
-        ggml_tensor * _t = transcribe::weights::find_tensor( \
-            ctx_meta, (name), \
-            {GGML_TYPE_F32}, {__VA_ARGS__}, kTag); \
-        if (_t == nullptr) return TRANSCRIBE_ERR_GGUF; \
-        (slot) = _t; \
+#define GET_F32(slot, name, ...)                                                                          \
+    do {                                                                                                  \
+        ggml_tensor * _t =                                                                                \
+            transcribe::weights::find_tensor(ctx_meta, (name), { GGML_TYPE_F32 }, { __VA_ARGS__ }, kTag); \
+        if (_t == nullptr)                                                                                \
+            return TRANSCRIBE_ERR_GGUF;                                                                   \
+        (slot) = _t;                                                                                      \
     } while (0)
 
-#define GET_CONV(slot, name, ...) \
-    do { \
-        ggml_tensor * _t = transcribe::weights::find_tensor( \
-            ctx_meta, (name), \
-            {TRANSCRIBE_QUANT_CONV_TYPES}, \
-            {__VA_ARGS__}, kTag); \
-        if (_t == nullptr) return TRANSCRIBE_ERR_GGUF; \
-        (slot) = _t; \
+#define GET_CONV(slot, name, ...)                                                                              \
+    do {                                                                                                       \
+        ggml_tensor * _t = transcribe::weights::find_tensor(ctx_meta, (name), { TRANSCRIBE_QUANT_CONV_TYPES }, \
+                                                            { __VA_ARGS__ }, kTag);                            \
+        if (_t == nullptr)                                                                                     \
+            return TRANSCRIBE_ERR_GGUF;                                                                        \
+        (slot) = _t;                                                                                           \
     } while (0)
 
-#define GET_LIN(slot, name, ...) \
-    do { \
-        ggml_tensor * _t = transcribe::weights::find_tensor( \
-            ctx_meta, (name), \
-            {TRANSCRIBE_QUANT_LINEAR_TYPES}, \
-            {__VA_ARGS__}, kTag); \
-        if (_t == nullptr) return TRANSCRIBE_ERR_GGUF; \
-        (slot) = _t; \
+#define GET_LIN(slot, name, ...)                                                                                 \
+    do {                                                                                                         \
+        ggml_tensor * _t = transcribe::weights::find_tensor(ctx_meta, (name), { TRANSCRIBE_QUANT_LINEAR_TYPES }, \
+                                                            { __VA_ARGS__ }, kTag);                              \
+        if (_t == nullptr)                                                                                       \
+            return TRANSCRIBE_ERR_GGUF;                                                                          \
+        (slot) = _t;                                                                                             \
     } while (0)
 
-} // namespace
+}  // namespace
 
-transcribe_status build_qwen3_asr_weights(ggml_context *          ctx_meta,
-                                          const QwenAsrHParams &  hp,
-                                          QwenAsrWeights &        weights)
-{
+transcribe_status build_qwen3_asr_weights(ggml_context *         ctx_meta,
+                                          const QwenAsrHParams & hp,
+                                          QwenAsrWeights &       weights) {
     if (ctx_meta == nullptr) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
 
-    const int64_t d_model  = hp.enc_d_model;
-    const int64_t ffn_dim  = hp.enc_ffn_dim;
-    const int64_t ds_h     = hp.enc_downsample_hidden;
-    const int64_t n_mels   = hp.enc_num_mel_bins;
-    const int64_t out_dim  = hp.enc_output_dim;
+    const int64_t d_model = hp.enc_d_model;
+    const int64_t ffn_dim = hp.enc_ffn_dim;
+    const int64_t ds_h    = hp.enc_downsample_hidden;
+    const int64_t n_mels  = hp.enc_num_mel_bins;
+    const int64_t out_dim = hp.enc_output_dim;
 
     // Downsampled mel axis: (((n_mels + 1) / 2 + 1) / 2 + 1) / 2.
-    const int64_t mel_ds1 = (n_mels + 1) / 2;
-    const int64_t mel_ds2 = (mel_ds1 + 1) / 2;
-    const int64_t mel_ds3 = (mel_ds2 + 1) / 2;
+    const int64_t mel_ds1     = (n_mels + 1) / 2;
+    const int64_t mel_ds2     = (mel_ds1 + 1) / 2;
+    const int64_t mel_ds3     = (mel_ds2 + 1) / 2;
     const int64_t conv_out_in = ds_h * mel_ds3;
 
     // ----- audio encoder: subsample -----
@@ -277,101 +415,94 @@ transcribe_status build_qwen3_asr_weights(ggml_context *          ctx_meta,
     // the kernel in (kW, kH, in_ch, out_ch) order — same as PyTorch
     // (out, in, kH, kW) after permute/view. find_tensor validates the
     // four dims explicitly.
-    GET_CONV(weights.enc_subsample.conv0_w, "enc.conv.0.weight", 3, 3, 1,    ds_h);
-    GET_F32 (weights.enc_subsample.conv0_b, "enc.conv.0.bias",   ds_h);
+    GET_CONV(weights.enc_subsample.conv0_w, "enc.conv.0.weight", 3, 3, 1, ds_h);
+    GET_F32(weights.enc_subsample.conv0_b, "enc.conv.0.bias", ds_h);
     GET_CONV(weights.enc_subsample.conv1_w, "enc.conv.1.weight", 3, 3, ds_h, ds_h);
-    GET_F32 (weights.enc_subsample.conv1_b, "enc.conv.1.bias",   ds_h);
+    GET_F32(weights.enc_subsample.conv1_b, "enc.conv.1.bias", ds_h);
     GET_CONV(weights.enc_subsample.conv2_w, "enc.conv.2.weight", 3, 3, ds_h, ds_h);
-    GET_F32 (weights.enc_subsample.conv2_b, "enc.conv.2.bias",   ds_h);
+    GET_F32(weights.enc_subsample.conv2_b, "enc.conv.2.bias", ds_h);
     // conv_out is a Linear (bias=False) mapping (ds_h * mel_ds3) -> d_model.
-    GET_LIN(weights.enc_subsample.conv_out, "enc.conv_out.weight",
-            conv_out_in, d_model);
+    GET_LIN(weights.enc_subsample.conv_out, "enc.conv_out.weight", conv_out_in, d_model);
 
     // ----- audio encoder: blocks -----
     weights.enc_blocks.assign(hp.enc_n_layers, QwenAsrEncBlock{});
     for (int i = 0; i < hp.enc_n_layers; ++i) {
         auto & b = weights.enc_blocks[i];
         GET_F32(b.norm_attn_w, lname("enc.blocks.%d.norm_attn.weight", i), d_model);
-        GET_F32(b.norm_attn_b, lname("enc.blocks.%d.norm_attn.bias",   i), d_model);
-        GET_LIN(b.attn_q_w,    lname("enc.blocks.%d.attn.q.weight",    i), d_model, d_model);
-        GET_F32(b.attn_q_b,    lname("enc.blocks.%d.attn.q.bias",      i), d_model);
-        GET_LIN(b.attn_k_w,    lname("enc.blocks.%d.attn.k.weight",    i), d_model, d_model);
-        GET_F32(b.attn_k_b,    lname("enc.blocks.%d.attn.k.bias",      i), d_model);
-        GET_LIN(b.attn_v_w,    lname("enc.blocks.%d.attn.v.weight",    i), d_model, d_model);
-        GET_F32(b.attn_v_b,    lname("enc.blocks.%d.attn.v.bias",      i), d_model);
-        GET_LIN(b.attn_out_w,  lname("enc.blocks.%d.attn.out.weight",  i), d_model, d_model);
-        GET_F32(b.attn_out_b,  lname("enc.blocks.%d.attn.out.bias",    i), d_model);
-        GET_F32(b.norm_ffn_w,  lname("enc.blocks.%d.norm_ffn.weight",  i), d_model);
-        GET_F32(b.norm_ffn_b,  lname("enc.blocks.%d.norm_ffn.bias",    i), d_model);
-        GET_LIN(b.fc1_w,       lname("enc.blocks.%d.ffn.fc1.weight",   i), d_model, ffn_dim);
-        GET_F32(b.fc1_b,       lname("enc.blocks.%d.ffn.fc1.bias",     i), ffn_dim);
-        GET_LIN(b.fc2_w,       lname("enc.blocks.%d.ffn.fc2.weight",   i), ffn_dim, d_model);
-        GET_F32(b.fc2_b,       lname("enc.blocks.%d.ffn.fc2.bias",     i), d_model);
+        GET_F32(b.norm_attn_b, lname("enc.blocks.%d.norm_attn.bias", i), d_model);
+        GET_LIN(b.attn_q_w, lname("enc.blocks.%d.attn.q.weight", i), d_model, d_model);
+        GET_F32(b.attn_q_b, lname("enc.blocks.%d.attn.q.bias", i), d_model);
+        GET_LIN(b.attn_k_w, lname("enc.blocks.%d.attn.k.weight", i), d_model, d_model);
+        GET_F32(b.attn_k_b, lname("enc.blocks.%d.attn.k.bias", i), d_model);
+        GET_LIN(b.attn_v_w, lname("enc.blocks.%d.attn.v.weight", i), d_model, d_model);
+        GET_F32(b.attn_v_b, lname("enc.blocks.%d.attn.v.bias", i), d_model);
+        GET_LIN(b.attn_out_w, lname("enc.blocks.%d.attn.out.weight", i), d_model, d_model);
+        GET_F32(b.attn_out_b, lname("enc.blocks.%d.attn.out.bias", i), d_model);
+        GET_F32(b.norm_ffn_w, lname("enc.blocks.%d.norm_ffn.weight", i), d_model);
+        GET_F32(b.norm_ffn_b, lname("enc.blocks.%d.norm_ffn.bias", i), d_model);
+        GET_LIN(b.fc1_w, lname("enc.blocks.%d.ffn.fc1.weight", i), d_model, ffn_dim);
+        GET_F32(b.fc1_b, lname("enc.blocks.%d.ffn.fc1.bias", i), ffn_dim);
+        GET_LIN(b.fc2_w, lname("enc.blocks.%d.ffn.fc2.weight", i), ffn_dim, d_model);
+        GET_F32(b.fc2_b, lname("enc.blocks.%d.ffn.fc2.bias", i), d_model);
     }
 
     // ----- audio encoder: head (LN + proj1 + GELU + proj2) -----
     GET_F32(weights.enc_head.ln_post_w, "enc.ln_post.weight", d_model);
-    GET_F32(weights.enc_head.ln_post_b, "enc.ln_post.bias",   d_model);
-    GET_LIN(weights.enc_head.proj1_w,   "enc.proj1.weight",   d_model, d_model);
-    GET_F32(weights.enc_head.proj1_b,   "enc.proj1.bias",     d_model);
-    GET_LIN(weights.enc_head.proj2_w,   "enc.proj2.weight",   d_model, out_dim);
-    GET_F32(weights.enc_head.proj2_b,   "enc.proj2.bias",     out_dim);
+    GET_F32(weights.enc_head.ln_post_b, "enc.ln_post.bias", d_model);
+    GET_LIN(weights.enc_head.proj1_w, "enc.proj1.weight", d_model, d_model);
+    GET_F32(weights.enc_head.proj1_b, "enc.proj1.bias", d_model);
+    GET_LIN(weights.enc_head.proj2_w, "enc.proj2.weight", d_model, out_dim);
+    GET_F32(weights.enc_head.proj2_b, "enc.proj2.bias", out_dim);
 
     // ----- text LM: embedding (tied output) -----
     {
         ggml_tensor * tw = ggml_get_tensor(ctx_meta, "dec.token_embd.weight");
         if (tw == nullptr) {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "qwen3_asr: missing tensor \"dec.token_embd.weight\"");
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "qwen3_asr: missing tensor \"dec.token_embd.weight\"");
             return TRANSCRIBE_ERR_GGUF;
         }
         if (tw->ne[0] != hp.dec_hidden) {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "qwen3_asr: dec.token_embd.weight ne[0]=%lld, expected %lld",
-                         static_cast<long long>(tw->ne[0]),
-                         static_cast<long long>(hp.dec_hidden));
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "qwen3_asr: dec.token_embd.weight ne[0]=%lld, expected %lld",
+                    static_cast<long long>(tw->ne[0]), static_cast<long long>(hp.dec_hidden));
             return TRANSCRIBE_ERR_GGUF;
         }
         if (tw->ne[1] != hp.dec_vocab_size) {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "qwen3_asr: dec.token_embd.weight ne[1]=%lld, expected %lld",
-                         static_cast<long long>(tw->ne[1]),
-                         static_cast<long long>(hp.dec_vocab_size));
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "qwen3_asr: dec.token_embd.weight ne[1]=%lld, expected %lld",
+                    static_cast<long long>(tw->ne[1]), static_cast<long long>(hp.dec_vocab_size));
             return TRANSCRIBE_ERR_GGUF;
         }
         weights.dec_embed.token_w = tw;
     }
 
     // ----- text LM: blocks -----
-    const int64_t dec_h = hp.dec_hidden;
-    const int64_t dec_nh = hp.dec_n_heads;
+    const int64_t dec_h   = hp.dec_hidden;
+    const int64_t dec_nh  = hp.dec_n_heads;
     const int64_t dec_nkv = hp.dec_n_kv_heads;
-    const int64_t dec_hd = hp.dec_head_dim;
-    const int64_t dec_im = hp.dec_intermediate;
-    const int64_t q_out = dec_nh  * dec_hd;
-    const int64_t kv_out = dec_nkv * dec_hd;
+    const int64_t dec_hd  = hp.dec_head_dim;
+    const int64_t dec_im  = hp.dec_intermediate;
+    const int64_t q_out   = dec_nh * dec_hd;
+    const int64_t kv_out  = dec_nkv * dec_hd;
 
     weights.dec_blocks.assign(hp.dec_n_layers, QwenAsrDecBlock{});
     for (int i = 0; i < hp.dec_n_layers; ++i) {
         auto & b = weights.dec_blocks[i];
         GET_F32(b.norm_attn_w, lname("dec.blocks.%d.norm_attn.weight", i), dec_h);
-        GET_F32(b.norm_ffn_w,  lname("dec.blocks.%d.norm_ffn.weight",  i), dec_h);
-        GET_LIN(b.attn_q_w,    lname("dec.blocks.%d.attn.q.weight", i), dec_h, q_out);
-        GET_LIN(b.attn_k_w,    lname("dec.blocks.%d.attn.k.weight", i), dec_h, kv_out);
-        GET_LIN(b.attn_v_w,    lname("dec.blocks.%d.attn.v.weight", i), dec_h, kv_out);
-        GET_LIN(b.attn_o_w,    lname("dec.blocks.%d.attn.o.weight", i), q_out, dec_h);
+        GET_F32(b.norm_ffn_w, lname("dec.blocks.%d.norm_ffn.weight", i), dec_h);
+        GET_LIN(b.attn_q_w, lname("dec.blocks.%d.attn.q.weight", i), dec_h, q_out);
+        GET_LIN(b.attn_k_w, lname("dec.blocks.%d.attn.k.weight", i), dec_h, kv_out);
+        GET_LIN(b.attn_v_w, lname("dec.blocks.%d.attn.v.weight", i), dec_h, kv_out);
+        GET_LIN(b.attn_o_w, lname("dec.blocks.%d.attn.o.weight", i), q_out, dec_h);
         GET_F32(b.attn_q_norm, lname("dec.blocks.%d.attn.q_norm.weight", i), dec_hd);
         GET_F32(b.attn_k_norm, lname("dec.blocks.%d.attn.k_norm.weight", i), dec_hd);
-        GET_LIN(b.ffn_gate_w,  lname("dec.blocks.%d.ffn.gate.weight", i), dec_h, dec_im);
-        GET_LIN(b.ffn_up_w,    lname("dec.blocks.%d.ffn.up.weight",   i), dec_h, dec_im);
-        GET_LIN(b.ffn_down_w,  lname("dec.blocks.%d.ffn.down.weight", i), dec_im, dec_h);
+        GET_LIN(b.ffn_gate_w, lname("dec.blocks.%d.ffn.gate.weight", i), dec_h, dec_im);
+        GET_LIN(b.ffn_up_w, lname("dec.blocks.%d.ffn.up.weight", i), dec_h, dec_im);
+        GET_LIN(b.ffn_down_w, lname("dec.blocks.%d.ffn.down.weight", i), dec_im, dec_h);
 
         if (b.ffn_gate_w->type != b.ffn_up_w->type) {
             log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "qwen3_asr: ffn gate/up dtype mismatch at layer %d "
-                         "(%d vs %d)", i,
-                         static_cast<int>(b.ffn_gate_w->type),
-                         static_cast<int>(b.ffn_up_w->type));
+                    "qwen3_asr: ffn gate/up dtype mismatch at layer %d "
+                    "(%d vs %d)",
+                    i, static_cast<int>(b.ffn_gate_w->type), static_cast<int>(b.ffn_up_w->type));
             return TRANSCRIBE_ERR_GGUF;
         }
         // ffn_gate_up_w is allocated by causal_lm::pack_gate_up (see
@@ -385,4 +516,4 @@ transcribe_status build_qwen3_asr_weights(ggml_context *          ctx_meta,
     return TRANSCRIBE_OK;
 }
 
-} // namespace transcribe::qwen3_asr
+}  // namespace transcribe::qwen3_asr
diff --git a/src/arch/qwen3_asr/weights.h b/src/arch/qwen3_asr/weights.h
index 9056c901..e26889f5 100644
--- a/src/arch/qwen3_asr/weights.h
+++ b/src/arch/qwen3_asr/weights.h
@@ -43,38 +43,38 @@ namespace transcribe::qwen3_asr {
 
 struct QwenAsrHParams {
     // Audio encoder (thinker.audio_tower).
-    int32_t enc_n_layers         = 0;
-    int32_t enc_d_model          = 0;
-    int32_t enc_n_heads          = 0;
-    int32_t enc_ffn_dim          = 0;
-    int32_t enc_num_mel_bins     = 0;
-    int32_t enc_downsample_hidden = 0;
-    int32_t enc_output_dim       = 0;
-    int32_t enc_max_source_positions = 0;
-    int32_t enc_n_window         = 0;
-    int32_t enc_n_window_infer   = 0;
-    int32_t enc_conv_chunksize   = 0;
+    int32_t     enc_n_layers             = 0;
+    int32_t     enc_d_model              = 0;
+    int32_t     enc_n_heads              = 0;
+    int32_t     enc_ffn_dim              = 0;
+    int32_t     enc_num_mel_bins         = 0;
+    int32_t     enc_downsample_hidden    = 0;
+    int32_t     enc_output_dim           = 0;
+    int32_t     enc_max_source_positions = 0;
+    int32_t     enc_n_window             = 0;
+    int32_t     enc_n_window_infer       = 0;
+    int32_t     enc_conv_chunksize       = 0;
     std::string enc_activation;  // "gelu"
 
     // Text LM (thinker.model — Qwen3 causal LM).
-    int32_t dec_n_layers         = 0;
-    int32_t dec_hidden           = 0;
-    int32_t dec_intermediate     = 0;
-    int32_t dec_n_heads          = 0;
-    int32_t dec_n_kv_heads       = 0;
-    int32_t dec_head_dim         = 0;
+    int32_t     dec_n_layers     = 0;
+    int32_t     dec_hidden       = 0;
+    int32_t     dec_intermediate = 0;
+    int32_t     dec_n_heads      = 0;
+    int32_t     dec_n_kv_heads   = 0;
+    int32_t     dec_head_dim     = 0;
     std::string dec_hidden_act;  // "silu"
-    float   dec_rms_norm_eps     = 0.0f;
-    float   dec_rope_theta       = 0.0f;
+    float       dec_rms_norm_eps = 0.0f;
+    float       dec_rope_theta   = 0.0f;
 
     // Interleaved multimodal RoPE. The Qwen3 text-only ASR path uses
     // a single-modality position stream, so the [t,h,w] section split
     // collapses to flat rotation, but the cos/sin table shape is still
     // derived from these numbers. Kept explicit for fidelity to the
     // reference.
-    int32_t dec_rope_mrope_section_t = 0;
-    int32_t dec_rope_mrope_section_h = 0;
-    int32_t dec_rope_mrope_section_w = 0;
+    int32_t dec_rope_mrope_section_t   = 0;
+    int32_t dec_rope_mrope_section_h   = 0;
+    int32_t dec_rope_mrope_section_w   = 0;
     bool    dec_rope_mrope_interleaved = true;
 
     int32_t dec_max_position_embeddings = 0;
@@ -94,27 +94,26 @@ struct QwenAsrHParams {
 
     // Frontend (Whisper feature extractor).
     std::string fe_type;
-    int32_t     fe_num_mels      = 0;
-    int32_t     fe_sample_rate   = 0;
-    int32_t     fe_n_fft         = 0;
-    int32_t     fe_win_length    = 0;
-    int32_t     fe_hop_length    = 0;
+    int32_t     fe_num_mels    = 0;
+    int32_t     fe_sample_rate = 0;
+    int32_t     fe_n_fft       = 0;
+    int32_t     fe_win_length  = 0;
+    int32_t     fe_hop_length  = 0;
     std::string fe_window;
     std::string fe_normalize;
-    float       fe_dither        = 0.0f;
-    float       fe_pre_emphasis  = 0.0f;
-    float       fe_f_min         = 0.0f;
-    float       fe_f_max         = 0.0f;
+    float       fe_dither       = 0.0f;
+    float       fe_pre_emphasis = 0.0f;
+    float       fe_f_min        = 0.0f;
+    float       fe_f_max        = 0.0f;
     std::string fe_pad_mode;
-    bool        fe_center        = true;
+    bool        fe_center = true;
     std::string fe_mel_norm;
     int32_t     fe_chunk_length  = 0;
     int32_t     fe_n_samples     = 0;
     int32_t     fe_nb_max_frames = 0;
 };
 
-transcribe_status read_qwen3_asr_hparams(const gguf_context * gguf,
-                                         QwenAsrHParams &     hp);
+transcribe_status read_qwen3_asr_hparams(const gguf_context * gguf, QwenAsrHParams & hp);
 
 // ---------------------------------------------------------------------------
 // Weight slots - audio encoder
@@ -172,19 +171,19 @@ struct QwenAsrDecEmbed {
 };
 
 struct QwenAsrDecBlock {
-    ggml_tensor * norm_attn_w = nullptr;  // input_layernorm (RMSNorm, no bias)
-    ggml_tensor * norm_ffn_w  = nullptr;  // post_attention_layernorm
+    ggml_tensor * norm_attn_w   = nullptr;  // input_layernorm (RMSNorm, no bias)
+    ggml_tensor * norm_ffn_w    = nullptr;  // post_attention_layernorm
     // GQA projections; no biases on Qwen3. We experimented with packing
     // Q/K/V into one mul_mat but it consistently regressed on Metal —
     // the 3 small matvecs already run concurrently there and a combined
     // output's strided views trip downstream kernels. Left separate.
-    ggml_tensor * attn_q_w    = nullptr;  // [hidden, n_heads * head_dim]
-    ggml_tensor * attn_k_w    = nullptr;  // [hidden, n_kv_heads * head_dim]
-    ggml_tensor * attn_v_w    = nullptr;  // [hidden, n_kv_heads * head_dim]
-    ggml_tensor * attn_o_w    = nullptr;  // [n_heads * head_dim, hidden]
+    ggml_tensor * attn_q_w      = nullptr;  // [hidden, n_heads * head_dim]
+    ggml_tensor * attn_k_w      = nullptr;  // [hidden, n_kv_heads * head_dim]
+    ggml_tensor * attn_v_w      = nullptr;  // [hidden, n_kv_heads * head_dim]
+    ggml_tensor * attn_o_w      = nullptr;  // [n_heads * head_dim, hidden]
     // Per-head Q/K RMSNorm applied on head_dim (Qwen3 innovation).
-    ggml_tensor * attn_q_norm = nullptr;  // [head_dim]
-    ggml_tensor * attn_k_norm = nullptr;  // [head_dim]
+    ggml_tensor * attn_q_norm   = nullptr;  // [head_dim]
+    ggml_tensor * attn_k_norm   = nullptr;  // [head_dim]
     // SwiGLU MLP.
     ggml_tensor * ffn_gate_w    = nullptr;  // [hidden, intermediate]
     ggml_tensor * ffn_up_w      = nullptr;  // [hidden, intermediate]
@@ -196,23 +195,21 @@ struct QwenAsrDecBlock {
 };
 
 struct QwenAsrDecFinal {
-    ggml_tensor * norm_w = nullptr;   // RMSNorm before lm_head
+    ggml_tensor * norm_w = nullptr;  // RMSNorm before lm_head
 };
 
 struct QwenAsrWeights {
-    QwenAsrEncSubsample             enc_subsample;
-    std::vector<QwenAsrEncBlock>    enc_blocks;
-    QwenAsrEncHead                  enc_head;
+    QwenAsrEncSubsample          enc_subsample;
+    std::vector<QwenAsrEncBlock> enc_blocks;
+    QwenAsrEncHead               enc_head;
 
-    QwenAsrDecEmbed                 dec_embed;
-    std::vector<QwenAsrDecBlock>    dec_blocks;
-    QwenAsrDecFinal                 dec_final;
+    QwenAsrDecEmbed              dec_embed;
+    std::vector<QwenAsrDecBlock> dec_blocks;
+    QwenAsrDecFinal              dec_final;
     // No lm_head weight slot: tied to dec_embed.token_w. The graph
     // builder reuses token_w for the output projection.
 };
 
-transcribe_status build_qwen3_asr_weights(ggml_context *          ctx_meta,
-                                          const QwenAsrHParams &  hp,
-                                          QwenAsrWeights &        weights);
+transcribe_status build_qwen3_asr_weights(ggml_context * ctx_meta, const QwenAsrHParams & hp, QwenAsrWeights & weights);
 
-} // namespace transcribe::qwen3_asr
+}  // namespace transcribe::qwen3_asr
diff --git a/src/arch/sensevoice/capabilities.cpp b/src/arch/sensevoice/capabilities.cpp
index 316eb02e..afeeabff 100644
--- a/src/arch/sensevoice/capabilities.cpp
+++ b/src/arch/sensevoice/capabilities.cpp
@@ -30,7 +30,7 @@ void apply_family_invariants(transcribe_model & model) {
     // (`woitn` / `withitn`); the generic transcribe_run_params::itn enum
     // routes here. No PNC runtime toggle.
     transcribe::set_feature(&model, TRANSCRIBE_FEATURE_CANCELLATION, true);
-    transcribe::set_feature(&model, TRANSCRIBE_FEATURE_ITN,          true);
+    transcribe::set_feature(&model, TRANSCRIBE_FEATURE_ITN, true);
 }
 
-} // namespace transcribe::sensevoice
+}  // namespace transcribe::sensevoice
diff --git a/src/arch/sensevoice/encoder.cpp b/src/arch/sensevoice/encoder.cpp
index 2fe58946..0715ff49 100644
--- a/src/arch/sensevoice/encoder.cpp
+++ b/src/arch/sensevoice/encoder.cpp
@@ -15,14 +15,12 @@
 
 #include "encoder.h"
 
-#include "weights.h"
-
 #include "conformer/conformer.h"
+#include "ggml.h"
 #include "sanm/sanm.h"
 #include "transcribe-debug.h"
 #include "transcribe-log.h"
-
-#include "ggml.h"
+#include "weights.h"
 
 #include <cmath>
 #include <cstdio>
@@ -62,33 +60,32 @@ void mark_dump(ggml_tensor *& slot, ggml_tensor * t, const char * name) {
     slot = t;
 }
 
-} // namespace
+}  // namespace
 
 EncoderBuild build_encoder_graph(ggml_context *            ctx,
                                  const SenseVoiceWeights & w,
                                  const SenseVoiceHParams & hp,
                                  int                       n_lfr_frames,
                                  int                       n_batch,
-                                 bool                      batch_var_len)
-{
-    EncoderBuild eb {};
+                                 bool                      batch_var_len) {
+    EncoderBuild eb{};
 
     if (ctx == nullptr || n_lfr_frames <= 0 || n_batch <= 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "sensevoice encoder: invalid arg "
-                     "(ctx=%p, n_lfr_frames=%d, n_batch=%d)",
-                     static_cast<void *>(ctx), n_lfr_frames, n_batch);
+                "sensevoice encoder: invalid arg "
+                "(ctx=%p, n_lfr_frames=%d, n_batch=%d)",
+                static_cast<void *>(ctx), n_lfr_frames, n_batch);
         return eb;
     }
 
-    const int d_input = hp.enc_d_input;
-    const int d_model = hp.enc_d_model;
-    const int T_in    = n_lfr_frames;
-    const int T       = T_in + 4;          // post-prefix length
-    const int B       = n_batch;
+    const int  d_input = hp.enc_d_input;
+    const int  d_model = hp.enc_d_model;
+    const int  T_in    = n_lfr_frames;
+    const int  T       = T_in + 4;  // post-prefix length
+    const int  B       = n_batch;
     const bool var_len = batch_var_len && B > 1;
 
-    sanm::SanmBlockParams block_params {
+    sanm::SanmBlockParams block_params{
         /*n_heads=*/hp.enc_n_heads,
         /*d_model=*/d_model,
         /*kernel=*/hp.enc_kernel,
@@ -120,7 +117,7 @@ EncoderBuild build_encoder_graph(ggml_context *            ctx,
         block_params.use_flash     = false;
     }
 
-    eb.lid_idx       = ggml_new_tensor_1d(ctx, GGML_TYPE_I32, 1);
+    eb.lid_idx = ggml_new_tensor_1d(ctx, GGML_TYPE_I32, 1);
     named(eb.lid_idx, "prefix.lid_idx");
     ggml_set_input(eb.lid_idx);
 
@@ -128,7 +125,7 @@ EncoderBuild build_encoder_graph(ggml_context *            ctx,
     named(eb.event_emo_idx, "prefix.event_emo_idx");
     ggml_set_input(eb.event_emo_idx);
 
-    eb.textnorm_idx  = ggml_new_tensor_1d(ctx, GGML_TYPE_I32, 1);
+    eb.textnorm_idx = ggml_new_tensor_1d(ctx, GGML_TYPE_I32, 1);
     named(eb.textnorm_idx, "prefix.textnorm_idx");
     ggml_set_input(eb.textnorm_idx);
 
@@ -140,13 +137,13 @@ EncoderBuild build_encoder_graph(ggml_context *            ctx,
     eb.pe_in = pe_in;
 
     // ----- prefix prepend --------------------------------------------
-    ggml_tensor * lid_emb       = ggml_get_rows(ctx, w.embed, eb.lid_idx);       // [d_in, 1]
-    ggml_tensor * event_emo_emb = ggml_get_rows(ctx, w.embed, eb.event_emo_idx); // [d_in, 2]
-    ggml_tensor * textnorm_emb  = ggml_get_rows(ctx, w.embed, eb.textnorm_idx);  // [d_in, 1]
+    ggml_tensor * lid_emb       = ggml_get_rows(ctx, w.embed, eb.lid_idx);        // [d_in, 1]
+    ggml_tensor * event_emo_emb = ggml_get_rows(ctx, w.embed, eb.event_emo_idx);  // [d_in, 2]
+    ggml_tensor * textnorm_emb  = ggml_get_rows(ctx, w.embed, eb.textnorm_idx);   // [d_in, 1]
 
-    mark_dump(eb.dumps.prefix_lid,       lid_emb,       "enc.prefix.lid_emb");
+    mark_dump(eb.dumps.prefix_lid, lid_emb, "enc.prefix.lid_emb");
     mark_dump(eb.dumps.prefix_event_emo, event_emo_emb, "enc.prefix.event_emo_emb");
-    mark_dump(eb.dumps.prefix_textnorm,  textnorm_emb,  "enc.prefix.textnorm_emb");
+    mark_dump(eb.dumps.prefix_textnorm, textnorm_emb, "enc.prefix.textnorm_emb");
 
     // Reference order:
     //   speech = cat(textnorm,     speech)
@@ -162,8 +159,8 @@ EncoderBuild build_encoder_graph(ggml_context *            ctx,
         // Batched: the 4-token prefix is identical across utterances (one
         // run_params per batch), so build it once at ne[2] == 1 and broadcast
         // it over the batch before prepending to each utterance's speech.
-        ggml_tensor * lid_evev = ggml_concat(ctx, lid_emb, event_emo_emb, /*dim=*/1); // [d_in,3,1]
-        ggml_tensor * prefix   = ggml_concat(ctx, lid_evev, textnorm_emb, /*dim=*/1); // [d_in,4,1]
+        ggml_tensor * lid_evev = ggml_concat(ctx, lid_emb, event_emo_emb, /*dim=*/1);  // [d_in,3,1]
+        ggml_tensor * prefix   = ggml_concat(ctx, lid_evev, textnorm_emb, /*dim=*/1);  // [d_in,4,1]
         ggml_tensor * tmpl     = ggml_new_tensor_3d(ctx, GGML_TYPE_F32, d_input, 4, B);
         prefix                 = ggml_repeat(ctx, prefix, tmpl);                       // [d_in,4,B]
         x                      = ggml_concat(ctx, prefix, eb.frontend_in, /*dim=*/1);  // [d_in,T,B]
@@ -174,8 +171,8 @@ EncoderBuild build_encoder_graph(ggml_context *            ctx,
     // Scale by sqrt(d_model). NOTE: x is still 560-d here, but the
     // scale is sqrt(d_model=512), per the reference's encoder.forward().
     const float embed_scale = std::sqrt(static_cast<float>(d_model));
-    x = ggml_scale(ctx, x, embed_scale);
-    x = ggml_add(ctx, x, pe_in);
+    x                       = ggml_scale(ctx, x, embed_scale);
+    x                       = ggml_add(ctx, x, pe_in);
     mark_dump(eb.dumps.embed_out, x, "enc.embed.out");
 
     // ----- encoders0[0] (560 -> 512 projection) ----------------------
@@ -188,9 +185,7 @@ EncoderBuild build_encoder_graph(ggml_context *            ctx,
         const int last_idx = n_main - 1;
         const int mid_idx  = n_main / 2;
         for (int i = 0; i < n_main; ++i) {
-            x = sanm::sanm_block_residual(
-                ctx, x, to_sanm_view(w.encoders[static_cast<size_t>(i)]),
-                block_params);
+            x = sanm::sanm_block_residual(ctx, x, to_sanm_view(w.encoders[static_cast<size_t>(i)]), block_params);
             if (i == 0) {
                 mark_dump(eb.dumps.encoders_first, x, "enc.encoders.0.out");
             } else if (i == mid_idx) {
@@ -215,9 +210,7 @@ EncoderBuild build_encoder_graph(ggml_context *            ctx,
         const int last_idx = n_tp - 1;
         const int mid_idx  = n_tp / 2;
         for (int i = 0; i < n_tp; ++i) {
-            x = sanm::sanm_block_residual(
-                ctx, x, to_sanm_view(w.tp_encoders[static_cast<size_t>(i)]),
-                block_params);
+            x = sanm::sanm_block_residual(ctx, x, to_sanm_view(w.tp_encoders[static_cast<size_t>(i)]), block_params);
             if (i == 0) {
                 mark_dump(eb.dumps.tp_encoders_first, x, "enc.tp_encoders.0.out");
             } else if (i == mid_idx) {
@@ -238,7 +231,7 @@ EncoderBuild build_encoder_graph(ggml_context *            ctx,
 
     // ----- CTC head --------------------------------------------------
     ggml_tensor * logits = ggml_mul_mat(ctx, w.ctc_head_w, x);
-    logits = ggml_add(ctx, logits, w.ctc_head_b);
+    logits               = ggml_add(ctx, logits, w.ctc_head_b);
     mark_dump(eb.dumps.ctc_logits, logits, "ctc.logits.raw");
 
     // log_softmax over the vocab axis (ne[0]).
@@ -253,8 +246,7 @@ EncoderBuild build_encoder_graph(ggml_context *            ctx,
     // 8192 leaves ample headroom.
     eb.graph = ggml_new_graph_custom(ctx, /*size=*/8192, /*grads=*/false);
     if (eb.graph == nullptr) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "sensevoice encoder: ggml_new_graph_custom failed");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "sensevoice encoder: ggml_new_graph_custom failed");
         return eb;
     }
     ggml_build_forward_expand(eb.graph, eb.out);
@@ -262,4 +254,4 @@ EncoderBuild build_encoder_graph(ggml_context *            ctx,
     return eb;
 }
 
-} // namespace transcribe::sensevoice
+}  // namespace transcribe::sensevoice
diff --git a/src/arch/sensevoice/encoder.h b/src/arch/sensevoice/encoder.h
index 0cd1dc35..26a32413 100644
--- a/src/arch/sensevoice/encoder.h
+++ b/src/arch/sensevoice/encoder.h
@@ -51,7 +51,7 @@ struct EncoderDumps {
     ggml_tensor * tp_norm_out       = nullptr;
 
     // CTC head outputs. ne=[vocab, T, 1, 1].
-    ggml_tensor * ctc_logits   = nullptr;
+    ggml_tensor * ctc_logits    = nullptr;
     ggml_tensor * ctc_log_probs = nullptr;
 };
 
@@ -88,7 +88,7 @@ struct EncoderBuild {
     // CTC log-probabilities. ne=[vocab, T, n_batch, 1].
     ggml_tensor * out = nullptr;
 
-    EncoderDumps dumps {};
+    EncoderDumps dumps{};
 
     ggml_cgraph * graph = nullptr;
 };
@@ -103,7 +103,7 @@ EncoderBuild build_encoder_graph(ggml_context *            compute_ctx,
                                  const SenseVoiceWeights & weights,
                                  const SenseVoiceHParams & hp,
                                  int                       n_lfr_frames,
-                                 int                       n_batch = 1,
+                                 int                       n_batch       = 1,
                                  bool                      batch_var_len = false);
 
-} // namespace transcribe::sensevoice
+}  // namespace transcribe::sensevoice
diff --git a/src/arch/sensevoice/model.cpp b/src/arch/sensevoice/model.cpp
index 03a6eec0..6826029a 100644
--- a/src/arch/sensevoice/model.cpp
+++ b/src/arch/sensevoice/model.cpp
@@ -6,12 +6,13 @@
 // unique_consecutive → drop-blank → SP detokenize) to populate the
 // public result hierarchy.
 
-#include "sensevoice.h"
-
 #include "encoder.h"
-#include "weights.h"
-
+#include "ggml-alloc.h"
+#include "ggml-backend.h"
+#include "ggml.h"
+#include "gguf.h"
 #include "sanm/sanm.h"
+#include "sensevoice.h"
 #include "transcribe-arch.h"
 #include "transcribe-batch-util.h"
 #include "transcribe-debug.h"
@@ -20,11 +21,7 @@
 #include "transcribe-loader.h"
 #include "transcribe-log.h"
 #include "transcribe-meta.h"
-
-#include "ggml.h"
-#include "ggml-alloc.h"
-#include "ggml-backend.h"
-#include "gguf.h"
+#include "weights.h"
 
 #include <algorithm>
 #include <cmath>
@@ -42,7 +39,7 @@ namespace transcribe::sensevoice {
 
 extern const Arch arch;
 
-static_assert(std::is_base_of_v<transcribe_model,   SenseVoiceModel>);
+static_assert(std::is_base_of_v<transcribe_model, SenseVoiceModel>);
 static_assert(std::is_base_of_v<transcribe_session, SenseVoiceSession>);
 
 SenseVoiceSession::~SenseVoiceSession() {
@@ -65,9 +62,7 @@ SenseVoiceModel::~SenseVoiceModel() {
         ggml_backend_buffer_free(backend_buffer);
         backend_buffer = nullptr;
     }
-    for (auto it = plan.scheduler_list.rbegin();
-         it != plan.scheduler_list.rend(); ++it)
-    {
+    for (auto it = plan.scheduler_list.rbegin(); it != plan.scheduler_list.rend(); ++it) {
         ggml_backend_free(*it);
     }
     plan.scheduler_list.clear();
@@ -95,37 +90,37 @@ constexpr const char k_default_variant[] = "sensevoice-small";
 // WARN and for transcribe_capabilities::max_audio_ms.
 constexpr int k_safe_audio_ms = 30000;
 
-extern transcribe_status load        (Loader &, const transcribe_model_load_params *,
-                                      transcribe_model **);
-extern transcribe_status init_context(transcribe_model *, const transcribe_session_params *,
-                                      transcribe_session **);
-extern transcribe_status run         (transcribe_session *, const float *, int,
-                                      const transcribe_run_params *);
-
-transcribe_status load(
-    Loader &                          loader,
-    const transcribe_model_load_params *   params,
-    transcribe_model **               out_model)
-{
+extern transcribe_status load(Loader &, const transcribe_model_load_params *, transcribe_model **);
+extern transcribe_status init_context(transcribe_model *, const transcribe_session_params *, transcribe_session **);
+extern transcribe_status run(transcribe_session *, const float *, int, const transcribe_run_params *);
+
+transcribe_status load(Loader & loader, const transcribe_model_load_params * params, transcribe_model ** out_model) {
     const int64_t t_load_start = ggml_time_us();
 
-    auto m = std::make_unique<SenseVoiceModel>();
+    auto m       = std::make_unique<SenseVoiceModel>();
     m->arch      = &arch;
     m->t_load_us = 0;
 
-    m->variant = loader.variant().empty() ? k_default_variant
-                                          : loader.variant();
+    m->variant = loader.variant().empty() ? k_default_variant : loader.variant();
     m->backend.clear();
 
     apply_family_invariants(*m);
     m->caps.n_languages = 0;
     m->caps.languages   = nullptr;
 
-    if (auto st = read_capability_kv(loader.gguf(), m->caps); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_languages_kv (loader.gguf(), *m);       st != TRANSCRIBE_OK) return st;
+    if (auto st = read_capability_kv(loader.gguf(), m->caps); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_languages_kv(loader.gguf(), *m); st != TRANSCRIBE_OK) {
+        return st;
+    }
 
-    if (auto st = m->tok.load(loader.gguf());                  st != TRANSCRIBE_OK) return st;
-    if (auto st = read_sensevoice_hparams(loader.gguf(), m->hparams); st != TRANSCRIBE_OK) return st;
+    if (auto st = m->tok.load(loader.gguf()); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_sensevoice_hparams(loader.gguf(), m->hparams); st != TRANSCRIBE_OK) {
+        return st;
+    }
     m->hparams.vocab_size = static_cast<int32_t>(m->tok.n_tokens());
 
     // Publish the soft-window advisory now that the frontend sample rate is
@@ -135,48 +130,40 @@ transcribe_status load(
     // WARNs and proceeds past it rather than rejecting. See docs/input-limits.md.
     m->caps.max_audio_ms = k_safe_audio_ms;
 
-    gguf_init_params init_params {};
-    init_params.no_alloc = true;
-    init_params.ctx      = &m->ctx_meta;
+    gguf_init_params init_params{};
+    init_params.no_alloc     = true;
+    init_params.ctx          = &m->ctx_meta;
     gguf_context * gguf_data = gguf_init_from_file(loader.path().c_str(), init_params);
     if (gguf_data == nullptr) {
         return TRANSCRIBE_ERR_GGUF;
     }
 
-    if (auto st = build_sensevoice_weights(m->ctx_meta, m->hparams, m->weights);
-        st != TRANSCRIBE_OK)
-    {
+    if (auto st = build_sensevoice_weights(m->ctx_meta, m->hparams, m->weights); st != TRANSCRIBE_OK) {
         gguf_free(gguf_data);
         return st;
     }
 
-    const transcribe_backend_request backend_req =
-        (params != nullptr) ? params->backend : TRANSCRIBE_BACKEND_AUTO;
-    if (auto st = transcribe::load_common::init_backends(
-            backend_req, (params != nullptr) ? params->gpu_device : 0, "sensevoice", m->plan); st != TRANSCRIBE_OK)
-    {
+    const transcribe_backend_request backend_req = (params != nullptr) ? params->backend : TRANSCRIBE_BACKEND_AUTO;
+    if (auto st = transcribe::load_common::init_backends(backend_req, (params != nullptr) ? params->gpu_device : 0,
+                                                         "sensevoice", m->plan);
+        st != TRANSCRIBE_OK) {
         gguf_free(gguf_data);
         return st;
     }
-    m->backend = ggml_backend_name(m->plan.primary);
+    m->backend         = ggml_backend_name(m->plan.primary);
     m->primary_backend = m->plan.primary;
 
-    ggml_backend_buffer_t weights_buffer =
-        ggml_backend_alloc_ctx_tensors(m->ctx_meta, m->plan.primary);
+    ggml_backend_buffer_t weights_buffer = ggml_backend_alloc_ctx_tensors(m->ctx_meta, m->plan.primary);
     if (weights_buffer == nullptr) {
         gguf_free(gguf_data);
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "sensevoice: ggml_backend_alloc_ctx_tensors failed");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "sensevoice: ggml_backend_alloc_ctx_tensors failed");
         return TRANSCRIBE_ERR_GGUF;
     }
     m->backend_buffer = weights_buffer;
-    ggml_backend_buffer_set_usage(weights_buffer,
-                                  GGML_BACKEND_BUFFER_USAGE_WEIGHTS);
+    ggml_backend_buffer_set_usage(weights_buffer, GGML_BACKEND_BUFFER_USAGE_WEIGHTS);
 
-    if (auto st = transcribe::load_common::stream_tensor_data(
-            loader.path(), gguf_data, m->ctx_meta, "sensevoice");
-        st != TRANSCRIBE_OK)
-    {
+    if (auto st = transcribe::load_common::stream_tensor_data(loader.path(), gguf_data, m->ctx_meta, "sensevoice");
+        st != TRANSCRIBE_OK) {
         gguf_free(gguf_data);
         return st;
     }
@@ -187,7 +174,7 @@ transcribe_status load(
     // host-side frontend with apply_cmvn=true; pull the CMVN tensors
     // off backend storage into host buffers first.
     {
-        const auto & hp_ = m->hparams;
+        const auto &                 hp_ = m->hparams;
         transcribe::KaldiFbankParams fe_params;
         fe_params.n_mels          = hp_.fe_num_mels;
         fe_params.sample_rate     = hp_.fe_sample_rate;
@@ -200,30 +187,24 @@ transcribe_status load(
         fe_params.apply_cmvn      = true;
         fe_params.cmvn_shift.resize(static_cast<size_t>(hp_.enc_d_input));
         fe_params.cmvn_scale.resize(static_cast<size_t>(hp_.enc_d_input));
-        const size_t cmvn_bytes =
-            static_cast<size_t>(hp_.enc_d_input) * sizeof(float);
-        ggml_backend_tensor_get(m->weights.cmvn_shift,
-                                fe_params.cmvn_shift.data(), 0, cmvn_bytes);
-        ggml_backend_tensor_get(m->weights.cmvn_scale,
-                                fe_params.cmvn_scale.data(), 0, cmvn_bytes);
-        m->frontend = std::make_unique<transcribe::KaldiFbankFrontend>(
-            std::move(fe_params));
+        const size_t cmvn_bytes = static_cast<size_t>(hp_.enc_d_input) * sizeof(float);
+        ggml_backend_tensor_get(m->weights.cmvn_shift, fe_params.cmvn_shift.data(), 0, cmvn_bytes);
+        ggml_backend_tensor_get(m->weights.cmvn_scale, fe_params.cmvn_scale.data(), 0, cmvn_bytes);
+        m->frontend = std::make_unique<transcribe::KaldiFbankFrontend>(std::move(fe_params));
     }
 
     m->t_load_us = ggml_time_us() - t_load_start;
-    *out_model = m.release();
+    *out_model   = m.release();
     return TRANSCRIBE_OK;
 }
 
-transcribe_status init_context(
-    transcribe_model *                model,
-    const transcribe_session_params * params,
-    transcribe_session **             out_ctx)
-{
+transcribe_status init_context(transcribe_model *                model,
+                               const transcribe_session_params * params,
+                               transcribe_session **             out_ctx) {
     if (model->arch != &arch) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
-    auto cc = std::make_unique<SenseVoiceSession>();
+    auto cc       = std::make_unique<SenseVoiceSession>();
     cc->model     = model;
     cc->n_threads = params->n_threads;
     cc->kv_type   = params->kv_type;
@@ -238,13 +219,27 @@ int resolve_lid_idx(const SenseVoiceHParams & hp, const char * lang_or_null) {
     if (lang_or_null == nullptr || lang_or_null[0] == '\0') {
         return hp.prefix_lang_auto;
     }
-    if (std::strcmp(lang_or_null, "auto") == 0) return hp.prefix_lang_auto;
-    if (std::strcmp(lang_or_null, "zh")   == 0) return hp.prefix_lang_zh;
-    if (std::strcmp(lang_or_null, "en")   == 0) return hp.prefix_lang_en;
-    if (std::strcmp(lang_or_null, "yue")  == 0) return hp.prefix_lang_yue;
-    if (std::strcmp(lang_or_null, "ja")   == 0) return hp.prefix_lang_ja;
-    if (std::strcmp(lang_or_null, "ko")   == 0) return hp.prefix_lang_ko;
-    if (std::strcmp(lang_or_null, "nospeech") == 0) return hp.prefix_lang_nospeech;
+    if (std::strcmp(lang_or_null, "auto") == 0) {
+        return hp.prefix_lang_auto;
+    }
+    if (std::strcmp(lang_or_null, "zh") == 0) {
+        return hp.prefix_lang_zh;
+    }
+    if (std::strcmp(lang_or_null, "en") == 0) {
+        return hp.prefix_lang_en;
+    }
+    if (std::strcmp(lang_or_null, "yue") == 0) {
+        return hp.prefix_lang_yue;
+    }
+    if (std::strcmp(lang_or_null, "ja") == 0) {
+        return hp.prefix_lang_ja;
+    }
+    if (std::strcmp(lang_or_null, "ko") == 0) {
+        return hp.prefix_lang_ko;
+    }
+    if (std::strcmp(lang_or_null, "nospeech") == 0) {
+        return hp.prefix_lang_nospeech;
+    }
     return hp.prefix_lang_auto;
 }
 
@@ -260,17 +255,15 @@ void apply_thread_policy(SenseVoiceSession * cc) {
 // duration. Writes the session scratch result slot (token_ids / tokens /
 // segments / full_text / detected_language / result_kind / has_result) and
 // records cc->t_decode_us.
-static transcribe_status decode_and_populate(
-    SenseVoiceSession *           cc,
-    SenseVoiceModel *             cm,
-    const transcribe_run_params * params,
-    const float *                 log_probs,
-    int                           T_full,
-    int                           vocab,
-    const char *                  lang,
-    int                           n_samples)
-{
-    const auto & hp = cm->hparams;
+static transcribe_status decode_and_populate(SenseVoiceSession *           cc,
+                                             SenseVoiceModel *             cm,
+                                             const transcribe_run_params * params,
+                                             const float *                 log_probs,
+                                             int                           T_full,
+                                             int                           vocab,
+                                             const char *                  lang,
+                                             int                           n_samples) {
+    const auto &  hp          = cm->hparams;
     const int64_t t_dec_start = ggml_time_us();
 
     // ---------- Greedy CTC decode -------------------------------------
@@ -279,9 +272,9 @@ static transcribe_status decode_and_populate(
     cc->token_ids.reserve(static_cast<size_t>(T_full));
     int prev_id = -1;
     for (int t = 0; t < T_full; ++t) {
-        const float * row = log_probs + static_cast<size_t>(t) * vocab;
-        int   best_id = 0;
-        float best    = row[0];
+        const float * row     = log_probs + static_cast<size_t>(t) * vocab;
+        int           best_id = 0;
+        float         best    = row[0];
         for (int v = 1; v < vocab; ++v) {
             if (row[v] > best) {
                 best    = row[v];
@@ -306,21 +299,17 @@ static transcribe_status decode_and_populate(
         // did NOT pass an explicit hint — the public field's contract
         // is "what the model told us," not "what we told the model."
         // <|nospeech|> and <|auto|> are intentionally not surfaced.
-        const bool user_supplied_lang =
-            lang != nullptr && lang[0] != '\0' &&
-            std::strcmp(lang, "auto") != 0;
+        const bool user_supplied_lang = lang != nullptr && lang[0] != '\0' && std::strcmp(lang, "auto") != 0;
         if (!user_supplied_lang) {
             const int first_id = cc->token_ids.front();
             if (tok.is_control(first_id)) {
                 std::string s = tok.decode(&first_id, 1);
-                if (!s.empty() && s.front() == ' ') s.erase(s.begin());
-                if (s.size() >= 5 && s.front() == '<' && s.back() == '>' &&
-                    s[1] == '|' && s[s.size() - 2] == '|')
-                {
+                if (!s.empty() && s.front() == ' ') {
+                    s.erase(s.begin());
+                }
+                if (s.size() >= 5 && s.front() == '<' && s.back() == '>' && s[1] == '|' && s[s.size() - 2] == '|') {
                     const std::string code = s.substr(2, s.size() - 4);
-                    if (code == "zh" || code == "en" || code == "yue" ||
-                        code == "ja" || code == "ko")
-                    {
+                    if (code == "zh" || code == "en" || code == "yue" || code == "ja" || code == "ko") {
                         cc->detected_language = code;
                     }
                 }
@@ -346,7 +335,7 @@ static transcribe_status decode_and_populate(
         // The decode here may filter out CONTROL-typed tokens depending
         // on keep_special_tags so the user-facing text is clean by
         // default but the raw stream stays accessible above.
-        const bool strip = (params == nullptr) ? true : !params->keep_special_tags;
+        const bool       strip = (params == nullptr) ? true : !params->keep_special_tags;
         std::vector<int> ids_for_text;
         if (strip) {
             ids_for_text.reserve(cc->token_ids.size());
@@ -358,10 +347,9 @@ static transcribe_status decode_and_populate(
         } else {
             ids_for_text.assign(cc->token_ids.begin(), cc->token_ids.end());
         }
-        std::string full = ids_for_text.empty()
-            ? std::string()
-            : tok.decode(ids_for_text.data(),
-                         static_cast<int>(ids_for_text.size()));
+        std::string full = ids_for_text.empty() ?
+                               std::string() :
+                               tok.decode(ids_for_text.data(), static_cast<int>(ids_for_text.size()));
         if (!full.empty() && full.front() == ' ') {
             full.erase(full.begin());
         }
@@ -369,15 +357,14 @@ static transcribe_status decode_and_populate(
         transcribe_session::SegmentEntry seg;
         seg.t0_ms = 0;
         seg.t1_ms = static_cast<int64_t>(
-            std::llround(1000.0 * static_cast<double>(n_samples) /
-                         static_cast<double>(hp.fe_sample_rate)));
+            std::llround(1000.0 * static_cast<double>(n_samples) / static_cast<double>(hp.fe_sample_rate)));
         seg.first_token = 0;
         seg.n_tokens    = static_cast<int>(cc->tokens.size());
         seg.first_word  = 0;
         seg.n_words     = 0;
         seg.text        = full;
 
-        cc->full_text  = std::move(full);
+        cc->full_text = std::move(full);
         cc->segments.push_back(std::move(seg));
 
         // Family default: NONE. Caller-requested kinds finer than NONE
@@ -390,24 +377,22 @@ static transcribe_status decode_and_populate(
     return TRANSCRIBE_OK;
 }
 
-transcribe_status run(
-    transcribe_session *      session,
-    const float *             pcm,
-    int                       n_samples,
-    const transcribe_run_params * params)
-{
+transcribe_status run(transcribe_session *          session,
+                      const float *                 pcm,
+                      int                           n_samples,
+                      const transcribe_run_params * params) {
     if (session == nullptr || pcm == nullptr || n_samples <= 0) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
     auto * cc = static_cast<SenseVoiceSession *>(session);
     auto * cm = static_cast<SenseVoiceModel *>(cc->model);
-    if (cm == nullptr || cm->plan.scheduler_list.empty() ||
-        cm->frontend == nullptr)
-    {
+    if (cm == nullptr || cm->plan.scheduler_list.empty() || cm->frontend == nullptr) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
 
-    if (cc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
+    if (cc->poll_abort()) {
+        return TRANSCRIBE_ERR_ABORTED;
+    }
 
     transcribe::debug::init();
     cc->clear_result();
@@ -425,30 +410,27 @@ transcribe_status run(
     // change numerics) so the degradation is never silent. The shorter-than-
     // a-frame case is handled separately by the T_lfr <= 0 guard below.
     {
-        const int64_t audio_ms =
-            static_cast<int64_t>(n_samples) * 1000 / hp.fe_sample_rate;
+        const int64_t audio_ms = static_cast<int64_t>(n_samples) * 1000 / hp.fe_sample_rate;
         if (audio_ms > k_safe_audio_ms) {
-            transcribe::log_msg(
-                TRANSCRIBE_LOG_LEVEL_WARN,
-                "sensevoice run: audio is %.1f s, beyond the ~%d s window this "
-                "model was trained on; accuracy may degrade and memory use "
-                "grows quadratically. Split long audio into <=%d s segments "
-                "(e.g. with VAD). See transcribe_capabilities.max_audio_ms.",
-                static_cast<double>(audio_ms) / 1000.0,
-                k_safe_audio_ms / 1000, k_safe_audio_ms / 1000);
+            transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_WARN,
+                                "sensevoice run: audio is %.1f s, beyond the ~%d s window this "
+                                "model was trained on; accuracy may degrade and memory use "
+                                "grows quadratically. Split long audio into <=%d s segments "
+                                "(e.g. with VAD). See transcribe_capabilities.max_audio_ms.",
+                                static_cast<double>(audio_ms) / 1000.0, k_safe_audio_ms / 1000, k_safe_audio_ms / 1000);
         }
     }
 
     // ---------- Frontend (host-side) ----------------------------------
     const int64_t t_mel_start = ggml_time_us();
-    const int T_lfr = cm->frontend->compute(
-        pcm, static_cast<size_t>(n_samples), cc->frontend_buf);
-    cc->t_mel_us = ggml_time_us() - t_mel_start;
+    const int     T_lfr       = cm->frontend->compute(pcm, static_cast<size_t>(n_samples), cc->frontend_buf);
+    cc->t_mel_us              = ggml_time_us() - t_mel_start;
 
     if (T_lfr <= 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "sensevoice run: input too short for kaldi fbank "
-                     "(n_samples=%d → T_lfr=0)", n_samples);
+                "sensevoice run: input too short for kaldi fbank "
+                "(n_samples=%d → T_lfr=0)",
+                n_samples);
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
 
@@ -459,61 +441,58 @@ transcribe_status run(
         cc->compute_ctx = nullptr;
     }
     {
-        ggml_init_params init_params {};
+        ggml_init_params init_params{};
         // 70 SAN-M blocks * ~30 ops + a few hundred frontend / PE / CTC
         // ops easily fits in 8 MB of metadata arena.
         init_params.mem_size   = 8 * 1024 * 1024;
         init_params.mem_buffer = nullptr;
         init_params.no_alloc   = true;
-        cc->compute_ctx = ggml_init(init_params);
+        cc->compute_ctx        = ggml_init(init_params);
         if (cc->compute_ctx == nullptr) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "sensevoice run: compute context allocation failed — out of "
-                "memory. Split long audio into shorter segments (see "
-                "transcribe_capabilities.max_audio_ms).");
+                                "sensevoice run: compute context allocation failed — out of "
+                                "memory. Split long audio into shorter segments (see "
+                                "transcribe_capabilities.max_audio_ms).");
             return TRANSCRIBE_ERR_OOM;
         }
     }
 
     // ---------- Build the encoder graph -------------------------------
-    EncoderBuild eb = build_encoder_graph(cc->compute_ctx,
-                                          cm->weights, hp, T_lfr);
+    EncoderBuild eb = build_encoder_graph(cc->compute_ctx, cm->weights, hp, T_lfr);
     if (eb.out == nullptr || eb.graph == nullptr) {
         return TRANSCRIBE_ERR_GGUF;
     }
 
     // ---------- Allocate compute tensors via scheduler ---------------
     if (cc->sched == nullptr) {
-        cc->sched = ggml_backend_sched_new(
-            cm->plan.scheduler_list.data(), nullptr,
-            static_cast<int>(cm->plan.scheduler_list.size()),
-            /*graph_size=*/8192, /*parallel=*/false, /*op_offload=*/true);
+        cc->sched = ggml_backend_sched_new(cm->plan.scheduler_list.data(), nullptr,
+                                           static_cast<int>(cm->plan.scheduler_list.size()),
+                                           /*graph_size=*/8192, /*parallel=*/false, /*op_offload=*/true);
         if (cc->sched == nullptr) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "sensevoice run: scheduler allocation failed — out of memory. "
-                "Split long audio into shorter segments (see "
-                "transcribe_capabilities.max_audio_ms).");
+                                "sensevoice run: scheduler allocation failed — out of memory. "
+                                "Split long audio into shorter segments (see "
+                                "transcribe_capabilities.max_audio_ms).");
             return TRANSCRIBE_ERR_OOM;
         }
     }
     ggml_backend_sched_reset(cc->sched);
     if (!ggml_backend_sched_alloc_graph(cc->sched, eb.graph)) {
         transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "sensevoice run: encoder graph allocation failed — out of memory. "
-            "Split long audio into shorter segments (see "
-            "transcribe_capabilities.max_audio_ms).");
+                            "sensevoice run: encoder graph allocation failed — out of memory. "
+                            "Split long audio into shorter segments (see "
+                            "transcribe_capabilities.max_audio_ms).");
         return TRANSCRIBE_ERR_OOM;
     }
 
     // ---------- Upload inputs ----------------------------------------
     // Frontend output tensor: row-major [T_lfr, d_input], byte-identical
     // to ggml ne=[d_input, T_lfr] (d_input is innermost).
-    ggml_backend_tensor_set(eb.frontend_in, cc->frontend_buf.data(),
-                            0, cc->frontend_buf.size() * sizeof(float));
+    ggml_backend_tensor_set(eb.frontend_in, cc->frontend_buf.data(), 0, cc->frontend_buf.size() * sizeof(float));
 
     // Prefix indices.
-    const char * lang = (params != nullptr) ? params->language : nullptr;
-    const int32_t lid_idx = resolve_lid_idx(hp, lang);
+    const char *  lang         = (params != nullptr) ? params->language : nullptr;
+    const int32_t lid_idx      = resolve_lid_idx(hp, lang);
     const int32_t event_emo[2] = { 1, 2 };  // literal indices in the embed table
 
     // ITN slot. Generic transcribe_run_params::itn routes here. DEFAULT maps
@@ -525,16 +504,22 @@ transcribe_status run(
     bool use_itn = false;
     if (params != nullptr) {
         switch (params->itn) {
-            case TRANSCRIBE_ITN_MODE_DEFAULT: use_itn = false; break;
-            case TRANSCRIBE_ITN_MODE_OFF:     use_itn = false; break;
-            case TRANSCRIBE_ITN_MODE_ON:      use_itn = true;  break;
+            case TRANSCRIBE_ITN_MODE_DEFAULT:
+                use_itn = false;
+                break;
+            case TRANSCRIBE_ITN_MODE_OFF:
+                use_itn = false;
+                break;
+            case TRANSCRIBE_ITN_MODE_ON:
+                use_itn = true;
+                break;
         }
     }
     const int32_t textnorm_idx = use_itn ? hp.prefix_withitn : hp.prefix_woitn;
 
-    ggml_backend_tensor_set(eb.lid_idx,       &lid_idx,       0, sizeof(int32_t));
-    ggml_backend_tensor_set(eb.event_emo_idx, event_emo,      0, 2 * sizeof(int32_t));
-    ggml_backend_tensor_set(eb.textnorm_idx,  &textnorm_idx,  0, sizeof(int32_t));
+    ggml_backend_tensor_set(eb.lid_idx, &lid_idx, 0, sizeof(int32_t));
+    ggml_backend_tensor_set(eb.event_emo_idx, event_emo, 0, 2 * sizeof(int32_t));
+    ggml_backend_tensor_set(eb.textnorm_idx, &textnorm_idx, 0, sizeof(int32_t));
 
     // Sinusoidal PE: depth = current width = d_input (NOT d_model).
     transcribe::sanm::build_sinusoidal_pe(cc->pe_buf, hp.enc_d_input, T_full);
@@ -542,43 +527,36 @@ transcribe_status run(
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "sensevoice run: pe.in not found in graph");
         return TRANSCRIBE_ERR_GGUF;
     }
-    ggml_backend_tensor_set(eb.pe_in, cc->pe_buf.data(),
-                            0, cc->pe_buf.size() * sizeof(float));
+    ggml_backend_tensor_set(eb.pe_in, cc->pe_buf.data(), 0, cc->pe_buf.size() * sizeof(float));
 
     // Optional dump of the input (matches reference's frontend dump).
-    transcribe::debug::dump_tensor("frontend.in", eb.frontend_in,
-                                   "frontend.in");
+    transcribe::debug::dump_tensor("frontend.in", eb.frontend_in, "frontend.in");
 
     apply_thread_policy(cc);
 
     // ---------- Compute -----------------------------------------------
     const int64_t t_enc_start = ggml_time_us();
-    if (const ggml_status gs =
-            ggml_backend_sched_graph_compute(cc->sched, eb.graph);
-        gs != GGML_STATUS_SUCCESS)
-    {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "sensevoice run: graph compute failed (%d)",
-                     static_cast<int>(gs));
+    if (const ggml_status gs = ggml_backend_sched_graph_compute(cc->sched, eb.graph); gs != GGML_STATUS_SUCCESS) {
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "sensevoice run: graph compute failed (%d)", static_cast<int>(gs));
         return TRANSCRIBE_ERR_GGUF;
     }
     cc->t_encode_us = ggml_time_us() - t_enc_start;
 
     // ---------- Dump intermediates -----------------------------------
-    auto try_dump = [](const char * name, ggml_tensor * t,
-                       const char * stage)
-    {
-        if (t != nullptr) transcribe::debug::dump_tensor(name, t, stage);
+    auto try_dump = [](const char * name, ggml_tensor * t, const char * stage) {
+        if (t != nullptr) {
+            transcribe::debug::dump_tensor(name, t, stage);
+        }
     };
-    try_dump("frontend.fbank.lfr.cmvn.out", eb.dumps.frontend_out,    "frontend.lfr.cmvn");
-    try_dump("enc.prefix.lid_emb",          eb.dumps.prefix_lid,      "encoder.prefix.lid");
-    try_dump("enc.prefix.event_emo_emb",    eb.dumps.prefix_event_emo, "encoder.prefix.event_emo");
-    try_dump("enc.prefix.textnorm_emb",     eb.dumps.prefix_textnorm, "encoder.prefix.textnorm");
-    try_dump("enc.input.with_prefix",       eb.dumps.input_with_prefix, "encoder.input.with_prefix");
-    try_dump("enc.embed.out",               eb.dumps.embed_out,       "encoder.embed.pos_added");
-    try_dump("enc.encoders0.0.out",         eb.dumps.encoders0_0_out, "encoder.encoders0.0");
+    try_dump("frontend.fbank.lfr.cmvn.out", eb.dumps.frontend_out, "frontend.lfr.cmvn");
+    try_dump("enc.prefix.lid_emb", eb.dumps.prefix_lid, "encoder.prefix.lid");
+    try_dump("enc.prefix.event_emo_emb", eb.dumps.prefix_event_emo, "encoder.prefix.event_emo");
+    try_dump("enc.prefix.textnorm_emb", eb.dumps.prefix_textnorm, "encoder.prefix.textnorm");
+    try_dump("enc.input.with_prefix", eb.dumps.input_with_prefix, "encoder.input.with_prefix");
+    try_dump("enc.embed.out", eb.dumps.embed_out, "encoder.embed.pos_added");
+    try_dump("enc.encoders0.0.out", eb.dumps.encoders0_0_out, "encoder.encoders0.0");
     if (eb.dumps.encoders_first != nullptr) {
-        try_dump("enc.encoders.0.out",      eb.dumps.encoders_first,  "encoder.encoders.0");
+        try_dump("enc.encoders.0.out", eb.dumps.encoders_first, "encoder.encoders.0");
     }
     if (eb.dumps.encoders_mid != nullptr) {
         const char * nm = eb.dumps.encoders_mid->name;
@@ -588,9 +566,9 @@ transcribe_status run(
         const char * nm = eb.dumps.encoders_last->name;
         try_dump(nm, eb.dumps.encoders_last, "encoder.encoders.last");
     }
-    try_dump("enc.after_norm.out",          eb.dumps.after_norm_out,  "encoder.after_norm");
+    try_dump("enc.after_norm.out", eb.dumps.after_norm_out, "encoder.after_norm");
     if (eb.dumps.tp_encoders_first != nullptr) {
-        try_dump("enc.tp_encoders.0.out",   eb.dumps.tp_encoders_first, "encoder.tp_encoders.0");
+        try_dump("enc.tp_encoders.0.out", eb.dumps.tp_encoders_first, "encoder.tp_encoders.0");
     }
     if (eb.dumps.tp_encoders_mid != nullptr) {
         const char * nm = eb.dumps.tp_encoders_mid->name;
@@ -600,19 +578,17 @@ transcribe_status run(
         const char * nm = eb.dumps.tp_encoders_last->name;
         try_dump(nm, eb.dumps.tp_encoders_last, "encoder.tp_encoders.last");
     }
-    try_dump("enc.tp_norm.out",             eb.dumps.tp_norm_out,     "encoder.tp_norm");
-    try_dump("ctc.logits.raw",              eb.dumps.ctc_logits,      "ctc.logits.raw");
-    try_dump("ctc.log_probs",               eb.dumps.ctc_log_probs,   "ctc.log_probs");
+    try_dump("enc.tp_norm.out", eb.dumps.tp_norm_out, "encoder.tp_norm");
+    try_dump("ctc.logits.raw", eb.dumps.ctc_logits, "ctc.logits.raw");
+    try_dump("ctc.log_probs", eb.dumps.ctc_log_probs, "ctc.log_probs");
 
     // ---------- Read CTC log-probs to host ---------------------------
     const int vocab = hp.vocab_size;
     cc->logits_buf.resize(static_cast<size_t>(T_full) * vocab);
-    ggml_backend_tensor_get(eb.out, cc->logits_buf.data(),
-                            0, cc->logits_buf.size() * sizeof(float));
+    ggml_backend_tensor_get(eb.out, cc->logits_buf.data(), 0, cc->logits_buf.size() * sizeof(float));
 
     // ---------- Greedy CTC decode + public result --------------------
-    return decode_and_populate(cc, cm, params, cc->logits_buf.data(),
-                               T_full, vocab, lang, n_samples);
+    return decode_and_populate(cc, cm, params, cc->logits_buf.data(), T_full, vocab, lang, n_samples);
 }
 
 // ---------------------------------------------------------------------------
@@ -634,20 +610,22 @@ transcribe_status run(
 static transcribe_status run_batch_encode(
     SenseVoiceSession *                     cc,
     SenseVoiceModel *                       cm,
-    const std::vector<std::vector<float>> & feats,   // per utt: [T_lfr, d_input] row-major
+    const std::vector<std::vector<float>> & feats,  // per utt: [T_lfr, d_input] row-major
     const std::vector<int> &                T_lfr,
     int                                     d_input,
     int                                     T_max_lfr,
     const int *                             n_samples,
     int64_t                                 total_mel_us,
-    const transcribe_run_params *           params)
-{
+    const transcribe_run_params *           params) {
     const auto & hp = cm->hparams;
     const int    n  = static_cast<int>(feats.size());
 
     bool var_len = false;
     for (int b = 0; b < n; ++b) {
-        if (T_lfr[b] != T_max_lfr) { var_len = true; break; }
+        if (T_lfr[b] != T_max_lfr) {
+            var_len = true;
+            break;
+        }
     }
 
     // ---------- Soft-window advisory (see docs/input-limits.md) -------
@@ -658,18 +636,16 @@ static transcribe_status run_batch_encode(
     // regardless of which path runs. Never reject, never change numerics.
     if (hp.fe_sample_rate > 0 && n_samples != nullptr) {
         for (int b = 0; b < n; ++b) {
-            const int64_t audio_ms =
-                static_cast<int64_t>(n_samples[b]) * 1000 / hp.fe_sample_rate;
+            const int64_t audio_ms = static_cast<int64_t>(n_samples[b]) * 1000 / hp.fe_sample_rate;
             if (audio_ms > k_safe_audio_ms) {
-                transcribe::log_msg(
-                    TRANSCRIBE_LOG_LEVEL_WARN,
-                    "sensevoice run: utterance %d: audio is %.1f s, beyond the "
-                    "~%d s window this model was trained on; accuracy may "
-                    "degrade and memory use grows quadratically. Split long "
-                    "audio into <=%d s segments (e.g. with VAD). See "
-                    "transcribe_capabilities.max_audio_ms.",
-                    b, static_cast<double>(audio_ms) / 1000.0,
-                    k_safe_audio_ms / 1000, k_safe_audio_ms / 1000);
+                transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_WARN,
+                                    "sensevoice run: utterance %d: audio is %.1f s, beyond the "
+                                    "~%d s window this model was trained on; accuracy may "
+                                    "degrade and memory use grows quadratically. Split long "
+                                    "audio into <=%d s segments (e.g. with VAD). See "
+                                    "transcribe_capabilities.max_audio_ms.",
+                                    b, static_cast<double>(audio_ms) / 1000.0, k_safe_audio_ms / 1000,
+                                    k_safe_audio_ms / 1000);
             }
         }
     }
@@ -680,12 +656,11 @@ static transcribe_status run_batch_encode(
     // Destination element (d, t, b) lives at (b*T_max_lfr + t)*d_input + d;
     // each utterance's row-major [T_lfr, d_input] copies in directly, with the
     // padded tail (t >= T_lfr[b]) left zero.
-    const size_t per = static_cast<size_t>(d_input) * static_cast<size_t>(T_max_lfr);
+    const size_t       per = static_cast<size_t>(d_input) * static_cast<size_t>(T_max_lfr);
     std::vector<float> feat_buf(per * static_cast<size_t>(n), 0.0f);
     for (int b = 0; b < n; ++b) {
         const size_t rows = static_cast<size_t>(T_lfr[b]) * d_input;
-        std::copy(feats[b].data(), feats[b].data() + rows,
-                  feat_buf.data() + static_cast<size_t>(b) * per);
+        std::copy(feats[b].data(), feats[b].data() + rows, feat_buf.data() + static_cast<size_t>(b) * per);
     }
 
     // ---------- Reset per-call compute state -------------------------
@@ -694,153 +669,142 @@ static transcribe_status run_batch_encode(
         cc->compute_ctx = nullptr;
     }
     {
-        ggml_init_params init_params {};
+        ggml_init_params init_params{};
         init_params.mem_size   = 8 * 1024 * 1024;
         init_params.mem_buffer = nullptr;
         init_params.no_alloc   = true;
-        cc->compute_ctx = ggml_init(init_params);
+        cc->compute_ctx        = ggml_init(init_params);
         if (cc->compute_ctx == nullptr) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "sensevoice run: compute context allocation failed — out of "
-                "memory. Split long audio into shorter segments (see "
-                "transcribe_capabilities.max_audio_ms).");
+                                "sensevoice run: compute context allocation failed — out of "
+                                "memory. Split long audio into shorter segments (see "
+                                "transcribe_capabilities.max_audio_ms).");
             return TRANSCRIBE_ERR_OOM;
         }
     }
 
-    EncoderBuild eb = build_encoder_graph(cc->compute_ctx, cm->weights, hp,
-                                          T_max_lfr, /*n_batch=*/n,
+    EncoderBuild eb = build_encoder_graph(cc->compute_ctx, cm->weights, hp, T_max_lfr, /*n_batch=*/n,
                                           /*batch_var_len=*/var_len);
     if (eb.out == nullptr || eb.graph == nullptr || eb.frontend_in == nullptr) {
         return TRANSCRIBE_ERR_GGUF;
     }
 
     if (cc->sched == nullptr) {
-        cc->sched = ggml_backend_sched_new(
-            cm->plan.scheduler_list.data(), nullptr,
-            static_cast<int>(cm->plan.scheduler_list.size()),
-            /*graph_size=*/8192, /*parallel=*/false, /*op_offload=*/true);
+        cc->sched = ggml_backend_sched_new(cm->plan.scheduler_list.data(), nullptr,
+                                           static_cast<int>(cm->plan.scheduler_list.size()),
+                                           /*graph_size=*/8192, /*parallel=*/false, /*op_offload=*/true);
         if (cc->sched == nullptr) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "sensevoice run: scheduler allocation failed — out of memory. "
-                "Split long audio into shorter segments (see "
-                "transcribe_capabilities.max_audio_ms).");
+                                "sensevoice run: scheduler allocation failed — out of memory. "
+                                "Split long audio into shorter segments (see "
+                                "transcribe_capabilities.max_audio_ms).");
             return TRANSCRIBE_ERR_OOM;
         }
     }
     ggml_backend_sched_reset(cc->sched);
     if (!ggml_backend_sched_alloc_graph(cc->sched, eb.graph)) {
         transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "sensevoice run: encoder graph allocation failed — out of memory. "
-            "Split long audio into shorter segments (see "
-            "transcribe_capabilities.max_audio_ms).");
+                            "sensevoice run: encoder graph allocation failed — out of memory. "
+                            "Split long audio into shorter segments (see "
+                            "transcribe_capabilities.max_audio_ms).");
         return TRANSCRIBE_ERR_OOM;
     }
 
     // ---------- Upload inputs ----------------------------------------
-    ggml_backend_tensor_set(eb.frontend_in, feat_buf.data(),
-                            0, feat_buf.size() * sizeof(float));
+    ggml_backend_tensor_set(eb.frontend_in, feat_buf.data(), 0, feat_buf.size() * sizeof(float));
 
-    const char * lang = (params != nullptr) ? params->language : nullptr;
-    const int32_t lid_idx = resolve_lid_idx(hp, lang);
+    const char *  lang         = (params != nullptr) ? params->language : nullptr;
+    const int32_t lid_idx      = resolve_lid_idx(hp, lang);
     const int32_t event_emo[2] = { 1, 2 };
-    bool use_itn = false;
+    bool          use_itn      = false;
     if (params != nullptr) {
         switch (params->itn) {
-            case TRANSCRIBE_ITN_MODE_DEFAULT: use_itn = false; break;
-            case TRANSCRIBE_ITN_MODE_OFF:     use_itn = false; break;
-            case TRANSCRIBE_ITN_MODE_ON:      use_itn = true;  break;
+            case TRANSCRIBE_ITN_MODE_DEFAULT:
+                use_itn = false;
+                break;
+            case TRANSCRIBE_ITN_MODE_OFF:
+                use_itn = false;
+                break;
+            case TRANSCRIBE_ITN_MODE_ON:
+                use_itn = true;
+                break;
         }
     }
     const int32_t textnorm_idx = use_itn ? hp.prefix_withitn : hp.prefix_woitn;
 
-    ggml_backend_tensor_set(eb.lid_idx,       &lid_idx,      0, sizeof(int32_t));
-    ggml_backend_tensor_set(eb.event_emo_idx, event_emo,     0, 2 * sizeof(int32_t));
-    ggml_backend_tensor_set(eb.textnorm_idx,  &textnorm_idx, 0, sizeof(int32_t));
+    ggml_backend_tensor_set(eb.lid_idx, &lid_idx, 0, sizeof(int32_t));
+    ggml_backend_tensor_set(eb.event_emo_idx, event_emo, 0, 2 * sizeof(int32_t));
+    ggml_backend_tensor_set(eb.textnorm_idx, &textnorm_idx, 0, sizeof(int32_t));
 
     // Sinusoidal PE (depth = d_input, length = T_full_max). Broadcasts over
     // the batch axis in the graph.
     transcribe::sanm::build_sinusoidal_pe(cc->pe_buf, hp.enc_d_input, T_full_max);
-    if (eb.pe_in == nullptr) return TRANSCRIBE_ERR_GGUF;
-    ggml_backend_tensor_set(eb.pe_in, cc->pe_buf.data(),
-                            0, cc->pe_buf.size() * sizeof(float));
+    if (eb.pe_in == nullptr) {
+        return TRANSCRIBE_ERR_GGUF;
+    }
+    ggml_backend_tensor_set(eb.pe_in, cc->pe_buf.data(), 0, cc->pe_buf.size() * sizeof(float));
 
     // ---------- Variable-length masks --------------------------------
     // Real post-prefix length per utterance = T_lfr[b] + 4. SenseVoice has no
     // conv subsampling (LFR is done in the host frontend), so the encoder time
     // axis equals the input length.
     std::vector<int> real_T_full(static_cast<size_t>(n), T_full_max);
-    for (int b = 0; b < n; ++b) real_T_full[b] = T_lfr[b] + 4;
+    for (int b = 0; b < n; ++b) {
+        real_T_full[b] = T_lfr[b] + 4;
+    }
 
     if (var_len) {
         // Attention key-padding mask [T_full_max, 1, 1, n] (0 real / -INF padded)
         // and FSMN conv valid-frame mask [1, T_full_max, n] (1 real / 0 padded);
         // both share the host ordering index b*T_full_max + t.
-        transcribe::fill_keypad_mask(eb.attn_pad_mask_in, real_T_full,
-                                     T_full_max, n);
-        transcribe::fill_valid_frame_mask(eb.conv_pad_mask_in, real_T_full,
-                                          T_full_max, n);
+        transcribe::fill_keypad_mask(eb.attn_pad_mask_in, real_T_full, T_full_max, n);
+        transcribe::fill_valid_frame_mask(eb.conv_pad_mask_in, real_T_full, T_full_max, n);
     }
 
     apply_thread_policy(cc);
 
     // ---------- Compute ----------------------------------------------
     const int64_t t_enc_start = ggml_time_us();
-    if (const ggml_status gs =
-            ggml_backend_sched_graph_compute(cc->sched, eb.graph);
-        gs != GGML_STATUS_SUCCESS)
-    {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "sensevoice run_batch: graph compute failed (%d)",
-                     static_cast<int>(gs));
+    if (const ggml_status gs = ggml_backend_sched_graph_compute(cc->sched, eb.graph); gs != GGML_STATUS_SUCCESS) {
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "sensevoice run_batch: graph compute failed (%d)", static_cast<int>(gs));
         return TRANSCRIBE_ERR_GGUF;
     }
     cc->t_encode_us = ggml_time_us() - t_enc_start;
 
     // ---------- Read CTC log-probs + per-utterance decode ------------
-    const int vocab = hp.vocab_size;
-    const size_t utt_elems = static_cast<size_t>(vocab) *
-                             static_cast<size_t>(T_full_max);
+    const int    vocab     = hp.vocab_size;
+    const size_t utt_elems = static_cast<size_t>(vocab) * static_cast<size_t>(T_full_max);
     cc->logits_buf.resize(utt_elems * static_cast<size_t>(n));
-    ggml_backend_tensor_get(eb.out, cc->logits_buf.data(),
-                            0, cc->logits_buf.size() * sizeof(float));
+    ggml_backend_tensor_get(eb.out, cc->logits_buf.data(), 0, cc->logits_buf.size() * sizeof(float));
 
     // Host-slice the shared CTC log-probs and decode each utterance, with the
     // single shared encode + total mel cost amortized across the batch.
     return transcribe::decode_batch_slices(
-        cc, n, cc->logits_buf.data(), utt_elems, cc->t_encode_us, total_mel_us,
-        [&](int b, const float * lp) {
+        cc, n, cc->logits_buf.data(), utt_elems, cc->t_encode_us, total_mel_us, [&](int b, const float * lp) {
             // Per-utterance CTC log-probs dump for the batch tensor-parity
             // gate. Same vocab-innermost element order as the single-shot
             // ctc.log_probs dump, so the harness can diff slice-for-slice.
             if (transcribe::debug::enabled()) {
                 const long long shape[2] = { real_T_full[b], vocab };
-                std::string nm = "ctc.log_probs.b" + std::to_string(b);
-                transcribe::debug::dump_host_f32(
-                    nm.c_str(), lp,
-                    static_cast<long long>(real_T_full[b]) * vocab,
-                    shape, 2, "ctc.log_probs");
+                std::string     nm       = "ctc.log_probs.b" + std::to_string(b);
+                transcribe::debug::dump_host_f32(nm.c_str(), lp, static_cast<long long>(real_T_full[b]) * vocab, shape,
+                                                 2, "ctc.log_probs");
             }
-            return decode_and_populate(cc, cm, params, lp, real_T_full[b],
-                                       vocab, lang, n_samples[b]);
+            return decode_and_populate(cc, cm, params, lp, real_T_full[b], vocab, lang, n_samples[b]);
         });
 }
 
-transcribe_status run_batch(
-    transcribe_session *          session,
-    const float * const *         pcm,
-    const int *                   n_samples,
-    int                           n,
-    const transcribe_run_params * params)
-{
+transcribe_status run_batch(transcribe_session *          session,
+                            const float * const *         pcm,
+                            const int *                   n_samples,
+                            int                           n,
+                            const transcribe_run_params * params) {
     if (session == nullptr || pcm == nullptr || n_samples == nullptr || n <= 0) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
     auto * cc = static_cast<SenseVoiceSession *>(session);
     auto * cm = static_cast<SenseVoiceModel *>(cc->model);
-    if (cm == nullptr || cm->plan.scheduler_list.empty() ||
-        cm->frontend == nullptr)
-    {
+    if (cm == nullptr || cm->plan.scheduler_list.empty() || cm->frontend == nullptr) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
     transcribe::debug::init();
@@ -856,28 +820,33 @@ transcribe_status run_batch(
     // per-utterance path for the whole call.
     std::vector<std::vector<float>> feats(static_cast<size_t>(n));
     std::vector<int>                T_lfr(static_cast<size_t>(n), 0);
-    const int64_t t_mel_start = ggml_time_us();
-    const bool all_ok = transcribe::parallel_for_all(
-        n, cc->n_threads, [&](int i) -> bool {
-            if (pcm[i] == nullptr || n_samples[i] <= 0) return false;
-            const int t = cm->frontend->compute(
-                pcm[i], static_cast<size_t>(n_samples[i]), feats[i]);
-            if (t <= 0) return false;
-            T_lfr[i] = t;
-            return true;
-        });
-    const int64_t total_mel_us = ggml_time_us() - t_mel_start;
+    const int64_t                   t_mel_start  = ggml_time_us();
+    const bool                      all_ok       = transcribe::parallel_for_all(n, cc->n_threads, [&](int i) -> bool {
+        if (pcm[i] == nullptr || n_samples[i] <= 0) {
+            return false;
+        }
+        const int t = cm->frontend->compute(pcm[i], static_cast<size_t>(n_samples[i]), feats[i]);
+        if (t <= 0) {
+            return false;
+        }
+        T_lfr[i] = t;
+        return true;
+    });
+    const int64_t                   total_mel_us = ggml_time_us() - t_mel_start;
 
     if (all_ok) {
         int T_max_lfr = 0;
-        for (int i = 0; i < n; ++i) T_max_lfr = std::max(T_max_lfr, T_lfr[i]);
-        return run_batch_encode(cc, cm, feats, T_lfr, d_input, T_max_lfr,
-                                n_samples, total_mel_us, params);
+        for (int i = 0; i < n; ++i) {
+            T_max_lfr = std::max(T_max_lfr, T_lfr[i]);
+        }
+        return run_batch_encode(cc, cm, feats, T_lfr, d_input, T_max_lfr, n_samples, total_mel_us, params);
     }
 
     // Per-utterance fallback (also the malformed-input path).
     for (int i = 0; i < n; ++i) {
-        if (cc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
+        if (cc->poll_abort()) {
+            return TRANSCRIBE_ERR_ABORTED;
+        }
         if (pcm[i] == nullptr || n_samples[i] <= 0) {
             transcribe_session::ResultSet rs;
             rs.status = TRANSCRIBE_ERR_INVALID_ARG;
@@ -890,7 +859,7 @@ transcribe_status run_batch(
     return TRANSCRIBE_OK;
 }
 
-} // namespace
+}  // namespace
 
 extern const Arch arch = {
     /* .name             = */ "sensevoice",
@@ -906,4 +875,4 @@ extern const Arch arch = {
     /* .accepts_ext_kind = */ nullptr,
 };
 
-} // namespace transcribe::sensevoice
+}  // namespace transcribe::sensevoice
diff --git a/src/arch/sensevoice/sensevoice.h b/src/arch/sensevoice/sensevoice.h
index 4acbabab..f0fe57a1 100644
--- a/src/arch/sensevoice/sensevoice.h
+++ b/src/arch/sensevoice/sensevoice.h
@@ -6,13 +6,12 @@
 
 #pragma once
 
-#include "weights.h"
-
 #include "transcribe-backend.h"
-#include "transcribe-session.h"
 #include "transcribe-kaldi-fbank.h"
 #include "transcribe-model.h"
+#include "transcribe-session.h"
 #include "transcribe-tokenizer.h"
+#include "weights.h"
 
 #include <cstdint>
 #include <memory>
@@ -53,15 +52,14 @@ struct SenseVoiceSession final : public transcribe_session {
     ggml_context *       compute_ctx = nullptr;
     ggml_backend_sched_t sched       = nullptr;
 
-
     // Reusable host scratch.
-    std::vector<float>   frontend_buf;   // [T_lfr, d_input]
-    std::vector<float>   pe_buf;         // [T, d_input]
-    std::vector<float>   logits_buf;     // [T, vocab] for greedy CTC
-    std::vector<int32_t> token_ids;      // post-collapse / post-blank-strip
+    std::vector<float>   frontend_buf;  // [T_lfr, d_input]
+    std::vector<float>   pe_buf;        // [T, d_input]
+    std::vector<float>   logits_buf;    // [T, vocab] for greedy CTC
+    std::vector<int32_t> token_ids;     // post-collapse / post-blank-strip
 
     SenseVoiceSession() = default;
     ~SenseVoiceSession() override;
 };
 
-} // namespace transcribe::sensevoice
+}  // namespace transcribe::sensevoice
diff --git a/src/arch/sensevoice/weights.cpp b/src/arch/sensevoice/weights.cpp
index aa30ae21..db103419 100644
--- a/src/arch/sensevoice/weights.cpp
+++ b/src/arch/sensevoice/weights.cpp
@@ -3,12 +3,11 @@
 
 #include "weights.h"
 
-#include "transcribe-meta.h"
-#include "transcribe-weights-util.h"
-#include "transcribe-log.h"
-
 #include "ggml.h"
 #include "gguf.h"
+#include "transcribe-log.h"
+#include "transcribe-meta.h"
+#include "transcribe-weights-util.h"
 
 #include <cstdio>
 #include <initializer_list>
@@ -19,128 +18,212 @@ namespace {
 
 constexpr const char * kFamilyTag = "sensevoice";
 
-} // namespace
+}  // namespace
 
-transcribe_status read_sensevoice_hparams(const gguf_context *  gguf,
-                                          SenseVoiceHParams &   hp)
-{
+transcribe_status read_sensevoice_hparams(const gguf_context * gguf, SenseVoiceHParams & hp) {
     if (gguf == nullptr) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
 
     // Encoder.
-    if (auto st = read_required_u32_kv(gguf, "stt.sensevoice.encoder.n_blocks",   kFamilyTag, hp.enc_n_blocks);    st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.sensevoice.encoder.tp_blocks",  kFamilyTag, hp.enc_tp_blocks);   st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.sensevoice.encoder.d_model",    kFamilyTag, hp.enc_d_model);     st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.sensevoice.encoder.d_input",    kFamilyTag, hp.enc_d_input);     st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.sensevoice.encoder.n_heads",    kFamilyTag, hp.enc_n_heads);     st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.sensevoice.encoder.d_ff",       kFamilyTag, hp.enc_d_ff);        st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.sensevoice.encoder.kernel_size",kFamilyTag, hp.enc_kernel);      st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.sensevoice.encoder.sanm_shift", kFamilyTag, hp.enc_sanm_shift);  st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.sensevoice.encoder.attention_type", kFamilyTag, hp.enc_attn_type); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_bool_kv(gguf, "stt.sensevoice.encoder.normalize_before", kFamilyTag, true, hp.enc_normalize_before); st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_u32_kv(gguf, "stt.sensevoice.encoder.n_blocks", kFamilyTag, hp.enc_n_blocks);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.sensevoice.encoder.tp_blocks", kFamilyTag, hp.enc_tp_blocks);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.sensevoice.encoder.d_model", kFamilyTag, hp.enc_d_model);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.sensevoice.encoder.d_input", kFamilyTag, hp.enc_d_input);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.sensevoice.encoder.n_heads", kFamilyTag, hp.enc_n_heads);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.sensevoice.encoder.d_ff", kFamilyTag, hp.enc_d_ff);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.sensevoice.encoder.kernel_size", kFamilyTag, hp.enc_kernel);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.sensevoice.encoder.sanm_shift", kFamilyTag, hp.enc_sanm_shift);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_string_kv(gguf, "stt.sensevoice.encoder.attention_type", kFamilyTag, hp.enc_attn_type);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_bool_kv(gguf, "stt.sensevoice.encoder.normalize_before", kFamilyTag, true,
+                                        hp.enc_normalize_before);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Pre-encoder prefix indices. Required so the runtime never has to
     // hard-code lid_dict / textnorm_dict layouts.
-    if (auto st = read_required_u32_kv(gguf, "stt.sensevoice.special.lang_auto",      kFamilyTag, hp.prefix_lang_auto);      st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.sensevoice.special.lang_zh",        kFamilyTag, hp.prefix_lang_zh);        st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.sensevoice.special.lang_en",        kFamilyTag, hp.prefix_lang_en);        st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.sensevoice.special.lang_yue",       kFamilyTag, hp.prefix_lang_yue);       st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.sensevoice.special.lang_ja",        kFamilyTag, hp.prefix_lang_ja);        st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.sensevoice.special.lang_ko",        kFamilyTag, hp.prefix_lang_ko);        st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.sensevoice.special.lang_nospeech",  kFamilyTag, hp.prefix_lang_nospeech);  st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.sensevoice.special.withitn",        kFamilyTag, hp.prefix_withitn);        st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.sensevoice.special.woitn",          kFamilyTag, hp.prefix_woitn);          st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_u32_kv(gguf, "stt.sensevoice.special.lang_auto", kFamilyTag, hp.prefix_lang_auto);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.sensevoice.special.lang_zh", kFamilyTag, hp.prefix_lang_zh);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.sensevoice.special.lang_en", kFamilyTag, hp.prefix_lang_en);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.sensevoice.special.lang_yue", kFamilyTag, hp.prefix_lang_yue);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.sensevoice.special.lang_ja", kFamilyTag, hp.prefix_lang_ja);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.sensevoice.special.lang_ko", kFamilyTag, hp.prefix_lang_ko);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st =
+            read_required_u32_kv(gguf, "stt.sensevoice.special.lang_nospeech", kFamilyTag, hp.prefix_lang_nospeech);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.sensevoice.special.withitn", kFamilyTag, hp.prefix_withitn);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.sensevoice.special.woitn", kFamilyTag, hp.prefix_woitn);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
     // event_speech / emotion_neutral are documentation-only KV; the
     // hard-coded literal [1, 2] in the upstream forward is what the
     // C++ encoder uses, so we don't read these keys into hparams.
 
     // Frontend.
-    if (auto st = read_required_string_kv(gguf, "stt.frontend.type",         kFamilyTag, hp.fe_type);         st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf,    "stt.frontend.num_mels",     kFamilyTag, hp.fe_num_mels);     st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf,    "stt.frontend.sample_rate",  kFamilyTag, hp.fe_sample_rate);  st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf,    "stt.frontend.n_fft",        kFamilyTag, hp.fe_n_fft);        st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf,    "stt.frontend.win_length",   kFamilyTag, hp.fe_win_length);   st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf,    "stt.frontend.hop_length",   kFamilyTag, hp.fe_hop_length);   st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.frontend.window",       kFamilyTag, hp.fe_window);       st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.frontend.normalize",    kFamilyTag, hp.fe_normalize);    st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.frontend.fbank_style",  kFamilyTag, hp.fe_fbank_style);  st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf,    "stt.frontend.dither",       kFamilyTag, hp.fe_dither);       st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_bool_kv(gguf,   "stt.frontend.upscale_samples", kFamilyTag, true, hp.fe_upscale_samples); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_bool_kv(gguf,   "stt.frontend.snip_edges",   kFamilyTag, true, hp.fe_snip_edges); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf,    "stt.frontend.lfr_m",        kFamilyTag, hp.fe_lfr_m);        st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf,    "stt.frontend.lfr_n",        kFamilyTag, hp.fe_lfr_n);        st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_string_kv(gguf, "stt.frontend.type", kFamilyTag, hp.fe_type); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.num_mels", kFamilyTag, hp.fe_num_mels);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.sample_rate", kFamilyTag, hp.fe_sample_rate);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.n_fft", kFamilyTag, hp.fe_n_fft); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.win_length", kFamilyTag, hp.fe_win_length);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.hop_length", kFamilyTag, hp.fe_hop_length);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_string_kv(gguf, "stt.frontend.window", kFamilyTag, hp.fe_window); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_string_kv(gguf, "stt.frontend.normalize", kFamilyTag, hp.fe_normalize);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_string_kv(gguf, "stt.frontend.fbank_style", kFamilyTag, hp.fe_fbank_style);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.frontend.dither", kFamilyTag, hp.fe_dither); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_bool_kv(gguf, "stt.frontend.upscale_samples", kFamilyTag, true, hp.fe_upscale_samples);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_bool_kv(gguf, "stt.frontend.snip_edges", kFamilyTag, true, hp.fe_snip_edges);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.lfr_m", kFamilyTag, hp.fe_lfr_m); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.lfr_n", kFamilyTag, hp.fe_lfr_n); st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Cross-field invariants.
-    if (hp.enc_n_blocks <= 1 || hp.enc_tp_blocks < 0 ||
-        hp.enc_d_model <= 0  || hp.enc_d_input <= 0 ||
-        hp.enc_n_heads <= 0  || hp.enc_d_ff <= 0    ||
-        hp.enc_kernel <= 0   || hp.enc_kernel % 2 == 0)
-    {
+    if (hp.enc_n_blocks <= 1 || hp.enc_tp_blocks < 0 || hp.enc_d_model <= 0 || hp.enc_d_input <= 0 ||
+        hp.enc_n_heads <= 0 || hp.enc_d_ff <= 0 || hp.enc_kernel <= 0 || hp.enc_kernel % 2 == 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "sensevoice: encoder hparams invalid (n_blocks=%d "
-                     "tp_blocks=%d d_model=%d d_input=%d n_heads=%d d_ff=%d "
-                     "kernel=%d — kernel must be positive and odd)",
-                     hp.enc_n_blocks, hp.enc_tp_blocks, hp.enc_d_model,
-                     hp.enc_d_input, hp.enc_n_heads, hp.enc_d_ff, hp.enc_kernel);
+                "sensevoice: encoder hparams invalid (n_blocks=%d "
+                "tp_blocks=%d d_model=%d d_input=%d n_heads=%d d_ff=%d "
+                "kernel=%d — kernel must be positive and odd)",
+                hp.enc_n_blocks, hp.enc_tp_blocks, hp.enc_d_model, hp.enc_d_input, hp.enc_n_heads, hp.enc_d_ff,
+                hp.enc_kernel);
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.enc_d_model % hp.enc_n_heads != 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "sensevoice: encoder d_model (%d) not divisible by n_heads (%d)",
-                     hp.enc_d_model, hp.enc_n_heads);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "sensevoice: encoder d_model (%d) not divisible by n_heads (%d)",
+                hp.enc_d_model, hp.enc_n_heads);
         return TRANSCRIBE_ERR_GGUF;
     }
-    if (hp.fe_num_mels <= 0 || hp.fe_sample_rate <= 0 ||
-        hp.fe_n_fft <= 0    || hp.fe_win_length <= 0  ||
-        hp.fe_hop_length <= 0 || hp.fe_lfr_m <= 0     ||
-        hp.fe_lfr_n <= 0)
-    {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "sensevoice: frontend dimensions must be positive");
+    if (hp.fe_num_mels <= 0 || hp.fe_sample_rate <= 0 || hp.fe_n_fft <= 0 || hp.fe_win_length <= 0 ||
+        hp.fe_hop_length <= 0 || hp.fe_lfr_m <= 0 || hp.fe_lfr_n <= 0) {
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "sensevoice: frontend dimensions must be positive");
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.enc_d_input != hp.fe_num_mels * hp.fe_lfr_m) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "sensevoice: encoder d_input (%d) must equal num_mels (%d) "
-                     "× lfr_m (%d) = %d",
-                     hp.enc_d_input, hp.fe_num_mels, hp.fe_lfr_m,
-                     hp.fe_num_mels * hp.fe_lfr_m);
+                "sensevoice: encoder d_input (%d) must equal num_mels (%d) "
+                "× lfr_m (%d) = %d",
+                hp.enc_d_input, hp.fe_num_mels, hp.fe_lfr_m, hp.fe_num_mels * hp.fe_lfr_m);
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.enc_attn_type != "sanm") {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "sensevoice: unsupported attention type \"%s\" "
-                     "(only \"sanm\" is implemented)",
-                     hp.enc_attn_type.c_str());
+                "sensevoice: unsupported attention type \"%s\" "
+                "(only \"sanm\" is implemented)",
+                hp.enc_attn_type.c_str());
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.fe_type != "kaldi_fbank_lfr") {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "sensevoice: unsupported frontend type \"%s\" "
-                     "(only \"kaldi_fbank_lfr\" is implemented)",
-                     hp.fe_type.c_str());
+                "sensevoice: unsupported frontend type \"%s\" "
+                "(only \"kaldi_fbank_lfr\" is implemented)",
+                hp.fe_type.c_str());
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.fe_window != "hamming") {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "sensevoice: unsupported frontend window \"%s\" "
-                     "(only \"hamming\" is implemented)",
-                     hp.fe_window.c_str());
+                "sensevoice: unsupported frontend window \"%s\" "
+                "(only \"hamming\" is implemented)",
+                hp.fe_window.c_str());
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.fe_normalize != "per_feature") {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "sensevoice: unsupported frontend normalize \"%s\" "
-                     "(only \"per_feature\" is implemented)",
-                     hp.fe_normalize.c_str());
+                "sensevoice: unsupported frontend normalize \"%s\" "
+                "(only \"per_feature\" is implemented)",
+                hp.fe_normalize.c_str());
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.fe_fbank_style != "kaldi_htk") {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "sensevoice: unsupported fbank_style \"%s\" "
-                     "(only \"kaldi_htk\" is implemented)",
-                     hp.fe_fbank_style.c_str());
+                "sensevoice: unsupported fbank_style \"%s\" "
+                "(only \"kaldi_htk\" is implemented)",
+                hp.fe_fbank_style.c_str());
         return TRANSCRIBE_ERR_GGUF;
     }
 
@@ -154,46 +237,40 @@ using transcribe::weights::lname;
 
 constexpr const char * kTag = kFamilyTag;
 
-#define GET_F32(slot, name, ...) \
-    do { \
-        ggml_tensor * _t = find_tensor( \
-            ctx_meta, (name), \
-            {GGML_TYPE_F32}, {__VA_ARGS__}, kTag); \
-        if (_t == nullptr) return TRANSCRIBE_ERR_GGUF; \
-        (slot) = _t; \
+#define GET_F32(slot, name, ...)                                                                    \
+    do {                                                                                            \
+        ggml_tensor * _t = find_tensor(ctx_meta, (name), { GGML_TYPE_F32 }, { __VA_ARGS__ }, kTag); \
+        if (_t == nullptr)                                                                          \
+            return TRANSCRIBE_ERR_GGUF;                                                             \
+        (slot) = _t;                                                                                \
     } while (0)
 
-#define GET_CONV(slot, name, ...) \
-    do { \
-        ggml_tensor * _t = find_tensor( \
-            ctx_meta, (name), \
-            {TRANSCRIBE_QUANT_CONV_TYPES}, \
-            {__VA_ARGS__}, kTag); \
-        if (_t == nullptr) return TRANSCRIBE_ERR_GGUF; \
-        (slot) = _t; \
+#define GET_CONV(slot, name, ...)                                                                                 \
+    do {                                                                                                          \
+        ggml_tensor * _t = find_tensor(ctx_meta, (name), { TRANSCRIBE_QUANT_CONV_TYPES }, { __VA_ARGS__ }, kTag); \
+        if (_t == nullptr)                                                                                        \
+            return TRANSCRIBE_ERR_GGUF;                                                                           \
+        (slot) = _t;                                                                                              \
     } while (0)
 
-#define GET_LIN(slot, name, ...) \
-    do { \
-        ggml_tensor * _t = find_tensor( \
-            ctx_meta, (name), \
-            {TRANSCRIBE_QUANT_LINEAR_TYPES}, \
-            {__VA_ARGS__}, kTag); \
-        if (_t == nullptr) return TRANSCRIBE_ERR_GGUF; \
-        (slot) = _t; \
+#define GET_LIN(slot, name, ...)                                                                                    \
+    do {                                                                                                            \
+        ggml_tensor * _t = find_tensor(ctx_meta, (name), { TRANSCRIBE_QUANT_LINEAR_TYPES }, { __VA_ARGS__ }, kTag); \
+        if (_t == nullptr)                                                                                          \
+            return TRANSCRIBE_ERR_GGUF;                                                                             \
+        (slot) = _t;                                                                                                \
     } while (0)
 
 // Bind one SAN-M block (13 tensors). `prefix` is e.g. "enc.encoders.7"
 // or "enc.encoders0.0". `d_in_norm` and `d_in_qkv` are the input-side
 // dims (= d_model except for encoders0[0] where they equal d_input).
-transcribe_status load_block(ggml_context *      ctx_meta,
-                             const char *        prefix,
-                             int64_t             d_in,
-                             int64_t             d_model,
-                             int64_t             d_ff,
-                             int64_t             kernel,
-                             SenseVoiceBlock &   b)
-{
+transcribe_status load_block(ggml_context *    ctx_meta,
+                             const char *      prefix,
+                             int64_t           d_in,
+                             int64_t           d_model,
+                             int64_t           d_ff,
+                             int64_t           kernel,
+                             SenseVoiceBlock & b) {
     char buf[256];
 
     auto namef = [&](const char * suffix) -> const char * {
@@ -219,32 +296,31 @@ transcribe_status load_block(ggml_context *      ctx_meta,
     GET_F32(b.norm_attn_w, name_norm_attn_w.c_str(), d_in);
     GET_F32(b.norm_attn_b, name_norm_attn_b.c_str(), d_in);
     // Fused QKV: PyTorch [out=3·d_model, in=d_in]; ggml ne[0]=in, ne[1]=out.
-    GET_LIN(b.attn_qkv_w,  name_qkv_w.c_str(),       d_in, 3 * d_model);
-    GET_F32(b.attn_qkv_b,  name_qkv_b.c_str(),       3 * d_model);
+    GET_LIN(b.attn_qkv_w, name_qkv_w.c_str(), d_in, 3 * d_model);
+    GET_F32(b.attn_qkv_b, name_qkv_b.c_str(), 3 * d_model);
     // attn_out: PyTorch [d_model, d_model] always operates in d_model space.
-    GET_LIN(b.attn_out_w,  name_out_w.c_str(),       d_model, d_model);
-    GET_F32(b.attn_out_b,  name_out_b.c_str(),       d_model);
+    GET_LIN(b.attn_out_w, name_out_w.c_str(), d_model, d_model);
+    GET_F32(b.attn_out_b, name_out_b.c_str(), d_model);
     // FSMN depthwise conv. PyTorch shape (out=d_model, in_per_group=1, kernel).
     // ggml stores conv1d weights as [kernel, in_per_group, out] in ne order
     // — see parakeet's depthwise convention.
-    GET_CONV(b.attn_fsmn_w, name_fsmn_w.c_str(),     kernel, 1, d_model);
-
-    GET_F32(b.norm_ffn_w,  name_norm_ffn_w.c_str(),  d_model);
-    GET_F32(b.norm_ffn_b,  name_norm_ffn_b.c_str(),  d_model);
-    GET_LIN(b.ffn_fc1_w,   name_fc1_w.c_str(),       d_model, d_ff);
-    GET_F32(b.ffn_fc1_b,   name_fc1_b.c_str(),       d_ff);
-    GET_LIN(b.ffn_fc2_w,   name_fc2_w.c_str(),       d_ff, d_model);
-    GET_F32(b.ffn_fc2_b,   name_fc2_b.c_str(),       d_model);
-    (void)namef;
+    GET_CONV(b.attn_fsmn_w, name_fsmn_w.c_str(), kernel, 1, d_model);
+
+    GET_F32(b.norm_ffn_w, name_norm_ffn_w.c_str(), d_model);
+    GET_F32(b.norm_ffn_b, name_norm_ffn_b.c_str(), d_model);
+    GET_LIN(b.ffn_fc1_w, name_fc1_w.c_str(), d_model, d_ff);
+    GET_F32(b.ffn_fc1_b, name_fc1_b.c_str(), d_ff);
+    GET_LIN(b.ffn_fc2_w, name_fc2_w.c_str(), d_ff, d_model);
+    GET_F32(b.ffn_fc2_b, name_fc2_b.c_str(), d_model);
+    (void) namef;
     return TRANSCRIBE_OK;
 }
 
-} // namespace
+}  // namespace
 
 transcribe_status build_sensevoice_weights(ggml_context *            ctx_meta,
                                            const SenseVoiceHParams & hp,
-                                           SenseVoiceWeights &       weights)
-{
+                                           SenseVoiceWeights &       weights) {
     if (ctx_meta == nullptr) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
@@ -257,8 +333,9 @@ transcribe_status build_sensevoice_weights(ggml_context *            ctx_meta,
 
     if (vocab <= 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "sensevoice: build_sensevoice_weights called before "
-                     "tokenizer load (vocab_size=%d)", hp.vocab_size);
+                "sensevoice: build_sensevoice_weights called before "
+                "tokenizer load (vocab_size=%d)",
+                hp.vocab_size);
         return TRANSCRIBE_ERR_GGUF;
     }
 
@@ -274,44 +351,47 @@ transcribe_status build_sensevoice_weights(ggml_context *            ctx_meta,
 
     // ----- encoders0[0] (560 → 512 projection) -----
     if (auto st = load_block(ctx_meta, "enc.encoders0.0",
-                             /*d_in=*/d_input, d_model, d_ff, kernel,
-                             weights.encoders0);
-        st != TRANSCRIBE_OK) return st;
+                             /*d_in=*/d_input, d_model, d_ff, kernel, weights.encoders0);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // ----- encoders[0..n_blocks-2] (49 blocks at d_model) -----
     weights.encoders.assign(hp.enc_n_blocks - 1, SenseVoiceBlock{});
     for (int i = 0; i < hp.enc_n_blocks - 1; ++i) {
         char prefix[64];
         std::snprintf(prefix, sizeof(prefix), "enc.encoders.%d", i);
-        if (auto st = load_block(ctx_meta, prefix,
-                                 d_model, d_model, d_ff, kernel,
-                                 weights.encoders[static_cast<size_t>(i)]);
-            st != TRANSCRIBE_OK) return st;
+        if (auto st =
+                load_block(ctx_meta, prefix, d_model, d_model, d_ff, kernel, weights.encoders[static_cast<size_t>(i)]);
+            st != TRANSCRIBE_OK) {
+            return st;
+        }
     }
 
     // ----- after_norm -----
     GET_F32(weights.after_norm_w, "enc.after_norm.weight", d_model);
-    GET_F32(weights.after_norm_b, "enc.after_norm.bias",   d_model);
+    GET_F32(weights.after_norm_b, "enc.after_norm.bias", d_model);
 
     // ----- tp_encoders[0..tp_blocks-1] -----
     weights.tp_encoders.assign(hp.enc_tp_blocks, SenseVoiceBlock{});
     for (int i = 0; i < hp.enc_tp_blocks; ++i) {
         char prefix[64];
         std::snprintf(prefix, sizeof(prefix), "enc.tp_encoders.%d", i);
-        if (auto st = load_block(ctx_meta, prefix,
-                                 d_model, d_model, d_ff, kernel,
+        if (auto st = load_block(ctx_meta, prefix, d_model, d_model, d_ff, kernel,
                                  weights.tp_encoders[static_cast<size_t>(i)]);
-            st != TRANSCRIBE_OK) return st;
+            st != TRANSCRIBE_OK) {
+            return st;
+        }
     }
 
     // ----- tp_norm -----
     GET_F32(weights.tp_norm_w, "enc.tp_norm.weight", d_model);
-    GET_F32(weights.tp_norm_b, "enc.tp_norm.bias",   d_model);
+    GET_F32(weights.tp_norm_b, "enc.tp_norm.bias", d_model);
 
     // ----- CTC head -----
     // PyTorch [vocab, d_model] → ggml ne[0]=d_model, ne[1]=vocab.
     GET_LIN(weights.ctc_head_w, "ctc.head.weight", d_model, vocab);
-    GET_F32(weights.ctc_head_b, "ctc.head.bias",   vocab);
+    GET_F32(weights.ctc_head_b, "ctc.head.bias", vocab);
 
     return TRANSCRIBE_OK;
 }
@@ -320,4 +400,4 @@ transcribe_status build_sensevoice_weights(ggml_context *            ctx_meta,
 #undef GET_CONV
 #undef GET_LIN
 
-} // namespace transcribe::sensevoice
+}  // namespace transcribe::sensevoice
diff --git a/src/arch/sensevoice/weights.h b/src/arch/sensevoice/weights.h
index e466c24a..329ce2e1 100644
--- a/src/arch/sensevoice/weights.h
+++ b/src/arch/sensevoice/weights.h
@@ -55,15 +55,15 @@ namespace transcribe::sensevoice {
 // Hyperparameter contract. Read from stt.sensevoice.* / stt.frontend.*.
 struct SenseVoiceHParams {
     // Encoder dims.
-    int32_t enc_n_blocks  = 0;   // includes the encoders0[0] projection block
-    int32_t enc_tp_blocks = 0;
-    int32_t enc_d_model   = 0;   // 512
-    int32_t enc_d_input   = 0;   // 560 = 80 mels × lfr_m=7
-    int32_t enc_n_heads   = 0;   // 4
-    int32_t enc_d_ff      = 0;   // 2048
-    int32_t enc_kernel    = 0;   // 11 (FSMN depthwise conv)
-    int32_t enc_sanm_shift = 0;  // 0 — left-pad shift for non-causal SAN-M
-    std::string enc_attn_type;   // "sanm"
+    int32_t     enc_n_blocks   = 0;  // includes the encoders0[0] projection block
+    int32_t     enc_tp_blocks  = 0;
+    int32_t     enc_d_model    = 0;  // 512
+    int32_t     enc_d_input    = 0;  // 560 = 80 mels × lfr_m=7
+    int32_t     enc_n_heads    = 0;  // 4
+    int32_t     enc_d_ff       = 0;  // 2048
+    int32_t     enc_kernel     = 0;  // 11 (FSMN depthwise conv)
+    int32_t     enc_sanm_shift = 0;  // 0 — left-pad shift for non-causal SAN-M
+    std::string enc_attn_type;       // "sanm"
     bool        enc_normalize_before = true;
 
     // Vocab is implicit in the SentencePiece tokenizer table the loader
@@ -72,63 +72,60 @@ struct SenseVoiceHParams {
     int32_t vocab_size = 0;
 
     // Frontend (kaldi HTK fbank + LFR + per-feature CMVN).
-    std::string fe_type;          // "kaldi_fbank_lfr"
+    std::string fe_type;             // "kaldi_fbank_lfr"
     int32_t     fe_num_mels    = 0;  // 80
     int32_t     fe_sample_rate = 0;  // 16000
     int32_t     fe_n_fft       = 0;  // 400 (kaldi pads to next pow2 internally)
     int32_t     fe_win_length  = 0;  // 400
     int32_t     fe_hop_length  = 0;  // 160
-    std::string fe_window;        // "hamming"
-    std::string fe_normalize;     // "per_feature"
-    std::string fe_fbank_style;   // "kaldi_htk"
-    float       fe_dither       = 0.0f;
+    std::string fe_window;           // "hamming"
+    std::string fe_normalize;        // "per_feature"
+    std::string fe_fbank_style;      // "kaldi_htk"
+    float       fe_dither          = 0.0f;
     bool        fe_upscale_samples = true;
     bool        fe_snip_edges      = true;
-    int32_t     fe_lfr_m        = 0;  // 7
-    int32_t     fe_lfr_n        = 0;  // 6
+    int32_t     fe_lfr_m           = 0;  // 7
+    int32_t     fe_lfr_n           = 0;  // 6
 
     // Pre-encoder prefix-embedding indices baked into the GGUF KV (so
     // the runtime does not have to memorize lid_dict / textnorm_dict).
     // All indices are rows in enc.embed.weight (vocabulary IS the
     // 16-row prefix-embedding table, NOT the SentencePiece output).
-    int32_t prefix_lang_auto      = 0;
-    int32_t prefix_lang_zh        = 0;
-    int32_t prefix_lang_en        = 0;
-    int32_t prefix_lang_yue       = 0;
-    int32_t prefix_lang_ja        = 0;
-    int32_t prefix_lang_ko        = 0;
-    int32_t prefix_lang_nospeech  = 0;
-    int32_t prefix_event_speech   = 0;
+    int32_t prefix_lang_auto       = 0;
+    int32_t prefix_lang_zh         = 0;
+    int32_t prefix_lang_en         = 0;
+    int32_t prefix_lang_yue        = 0;
+    int32_t prefix_lang_ja         = 0;
+    int32_t prefix_lang_ko         = 0;
+    int32_t prefix_lang_nospeech   = 0;
+    int32_t prefix_event_speech    = 0;
     int32_t prefix_emotion_neutral = 0;
-    int32_t prefix_withitn        = 0;
-    int32_t prefix_woitn          = 0;
+    int32_t prefix_withitn         = 0;
+    int32_t prefix_woitn           = 0;
 
     // Derived.
-    int32_t enc_head_dim() const {
-        return enc_n_heads > 0 ? enc_d_model / enc_n_heads : 0;
-    }
+    int32_t enc_head_dim() const { return enc_n_heads > 0 ? enc_d_model / enc_n_heads : 0; }
 };
 
-transcribe_status read_sensevoice_hparams(const gguf_context *  gguf,
-                                          SenseVoiceHParams &   hp);
+transcribe_status read_sensevoice_hparams(const gguf_context * gguf, SenseVoiceHParams & hp);
 
 // One SAN-M block. Same shape contract for every block (encoders0,
 // encoders, tp_encoders) — only encoders0[0] differs in that its
 // norm_attn and qkv input dim is d_input rather than d_model.
 struct SenseVoiceBlock {
-    ggml_tensor * norm_attn_w  = nullptr; // [d_in]
-    ggml_tensor * norm_attn_b  = nullptr; // [d_in]
-    ggml_tensor * attn_qkv_w   = nullptr; // [3·d_model, d_in]   fused QKV
-    ggml_tensor * attn_qkv_b   = nullptr; // [3·d_model]
-    ggml_tensor * attn_out_w   = nullptr; // [d_model, d_model]
-    ggml_tensor * attn_out_b   = nullptr; // [d_model]
-    ggml_tensor * attn_fsmn_w  = nullptr; // [kernel, 1, d_model] depthwise conv1d
-    ggml_tensor * norm_ffn_w   = nullptr; // [d_model]
-    ggml_tensor * norm_ffn_b   = nullptr; // [d_model]
-    ggml_tensor * ffn_fc1_w    = nullptr; // [d_ff, d_model]
-    ggml_tensor * ffn_fc1_b    = nullptr; // [d_ff]
-    ggml_tensor * ffn_fc2_w    = nullptr; // [d_model, d_ff]
-    ggml_tensor * ffn_fc2_b    = nullptr; // [d_model]
+    ggml_tensor * norm_attn_w = nullptr;  // [d_in]
+    ggml_tensor * norm_attn_b = nullptr;  // [d_in]
+    ggml_tensor * attn_qkv_w  = nullptr;  // [3·d_model, d_in]   fused QKV
+    ggml_tensor * attn_qkv_b  = nullptr;  // [3·d_model]
+    ggml_tensor * attn_out_w  = nullptr;  // [d_model, d_model]
+    ggml_tensor * attn_out_b  = nullptr;  // [d_model]
+    ggml_tensor * attn_fsmn_w = nullptr;  // [kernel, 1, d_model] depthwise conv1d
+    ggml_tensor * norm_ffn_w  = nullptr;  // [d_model]
+    ggml_tensor * norm_ffn_b  = nullptr;  // [d_model]
+    ggml_tensor * ffn_fc1_w   = nullptr;  // [d_ff, d_model]
+    ggml_tensor * ffn_fc1_b   = nullptr;  // [d_ff]
+    ggml_tensor * ffn_fc2_w   = nullptr;  // [d_model, d_ff]
+    ggml_tensor * ffn_fc2_b   = nullptr;  // [d_model]
 };
 
 struct SenseVoiceWeights {
@@ -139,7 +136,7 @@ struct SenseVoiceWeights {
 
     // Pre-encoder prefix-embedding table (16 rows × d_input cols).
     // Indices come from the upstream lid_dict / textnorm_dict.
-    ggml_tensor * embed = nullptr;       // [16, d_input]
+    ggml_tensor * embed = nullptr;  // [16, d_input]
 
     // The first block lives separately because its norm_attn / attn_qkv
     // input dim is d_input (not d_model) and the attention sub-layer
@@ -147,17 +144,17 @@ struct SenseVoiceWeights {
     SenseVoiceBlock encoders0;
 
     // Main tier (49 blocks at d_model).
-    std::vector<SenseVoiceBlock> encoders;       // size = enc_n_blocks - 1
+    std::vector<SenseVoiceBlock> encoders;  // size = enc_n_blocks - 1
 
     // Inter-tier LayerNorm.
-    ggml_tensor * after_norm_w = nullptr; // [d_model]
-    ggml_tensor * after_norm_b = nullptr; // [d_model]
+    ggml_tensor * after_norm_w = nullptr;  // [d_model]
+    ggml_tensor * after_norm_b = nullptr;  // [d_model]
 
     // TP tier (20 blocks at d_model).
-    std::vector<SenseVoiceBlock> tp_encoders;    // size = enc_tp_blocks
+    std::vector<SenseVoiceBlock> tp_encoders;  // size = enc_tp_blocks
 
-    ggml_tensor * tp_norm_w = nullptr;   // [d_model]
-    ggml_tensor * tp_norm_b = nullptr;   // [d_model]
+    ggml_tensor * tp_norm_w = nullptr;         // [d_model]
+    ggml_tensor * tp_norm_b = nullptr;         // [d_model]
 
     // CTC head.
     ggml_tensor * ctc_head_w = nullptr;  // [d_model, vocab]
@@ -175,4 +172,4 @@ transcribe_status build_sensevoice_weights(ggml_context *            ctx_meta,
                                            const SenseVoiceHParams & hp,
                                            SenseVoiceWeights &       weights);
 
-} // namespace transcribe::sensevoice
+}  // namespace transcribe::sensevoice
diff --git a/src/arch/voxtral/capabilities.cpp b/src/arch/voxtral/capabilities.cpp
index 127b14bd..58e69108 100644
--- a/src/arch/voxtral/capabilities.cpp
+++ b/src/arch/voxtral/capabilities.cpp
@@ -28,4 +28,4 @@ void apply_family_invariants(transcribe_model & model) {
     transcribe::set_feature(&model, TRANSCRIBE_FEATURE_INITIAL_PROMPT, true);
 }
 
-} // namespace transcribe::voxtral
+}  // namespace transcribe::voxtral
diff --git a/src/arch/voxtral/decoder.cpp b/src/arch/voxtral/decoder.cpp
index d705d8ea..fab496bf 100644
--- a/src/arch/voxtral/decoder.cpp
+++ b/src/arch/voxtral/decoder.cpp
@@ -9,11 +9,10 @@
 #include "decoder.h"
 
 #include "causal_lm/causal_lm.h"
+#include "ggml.h"
 #include "transcribe-debug.h"
 #include "transcribe-log.h"
 
-#include "ggml.h"
-
 #include <cstdio>
 
 namespace transcribe::voxtral {
@@ -21,7 +20,9 @@ namespace transcribe::voxtral {
 namespace {
 
 ggml_tensor * named(ggml_tensor * t, const char * name) {
-    if (t != nullptr && name != nullptr) ggml_set_name(t, name);
+    if (t != nullptr && name != nullptr) {
+        ggml_set_name(t, name);
+    }
     return t;
 }
 
@@ -29,7 +30,7 @@ ggml_tensor * named(ggml_tensor * t, const char * name) {
 // attn_k_norm are deliberately left null: Voxtral's Llama backbone has
 // no per-head Q/K norm, and causal_lm skips the norm when the slot is null.
 causal_lm::BlockView to_block_view(const VoxtralDecBlock & b) {
-    causal_lm::BlockView v {};
+    causal_lm::BlockView v{};
     v.norm_attn_w   = b.norm_attn_w;
     v.norm_ffn_w    = b.norm_ffn_w;
     v.attn_q_w      = b.attn_q_w;
@@ -44,7 +45,7 @@ causal_lm::BlockView to_block_view(const VoxtralDecBlock & b) {
 }
 
 causal_lm::BlockParams to_block_params(const VoxtralHParams & hp) {
-    causal_lm::BlockParams p {};
+    causal_lm::BlockParams p{};
     p.n_heads      = hp.dec_n_heads;
     p.n_kv_heads   = hp.dec_n_kv_heads;
     p.head_dim     = hp.dec_head_dim;
@@ -54,37 +55,31 @@ causal_lm::BlockParams to_block_params(const VoxtralHParams & hp) {
     return p;
 }
 
-} // namespace
+}  // namespace
 
-PrefillBuild build_prefill_graph(ggml_context *                  ctx,
-                                 const VoxtralWeights &          weights,
-                                 const VoxtralHParams &          hp,
+PrefillBuild build_prefill_graph(ggml_context *                   ctx,
+                                 const VoxtralWeights &           weights,
+                                 const VoxtralHParams &           hp,
                                  transcribe::causal_lm::KvCache & kv_cache,
-                                 int                             T_prompt,
-                                 int                             T_enc,
-                                 int                             prefix_len,
-                                 int                             suffix_len,
-                                 bool                            use_flash,
-                                 bool                            slice_last)
-{
-    PrefillBuild pb {};
+                                 int                              T_prompt,
+                                 int                              T_enc,
+                                 int                              prefix_len,
+                                 int                              suffix_len,
+                                 bool                             use_flash,
+                                 bool                             slice_last) {
+    PrefillBuild pb{};
     pb.T_prompt   = T_prompt;
     pb.T_enc      = T_enc;
     pb.prefix_len = prefix_len;
     pb.suffix_len = suffix_len;
 
     if (ctx == nullptr || T_prompt <= 0 || T_enc <= 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "voxtral decoder: invalid arg (T_prompt=%d, T_enc=%d)",
-                     T_prompt, T_enc);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral decoder: invalid arg (T_prompt=%d, T_enc=%d)", T_prompt, T_enc);
         return pb;
     }
-    if (prefix_len < 0 || suffix_len < 0 ||
-        prefix_len + T_enc + suffix_len != T_prompt)
-    {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "voxtral decoder: prefix(%d)+T_enc(%d)+suffix(%d) != T_prompt(%d)",
-                     prefix_len, T_enc, suffix_len, T_prompt);
+    if (prefix_len < 0 || suffix_len < 0 || prefix_len + T_enc + suffix_len != T_prompt) {
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral decoder: prefix(%d)+T_enc(%d)+suffix(%d) != T_prompt(%d)",
+                prefix_len, T_enc, suffix_len, T_prompt);
         return pb;
     }
     if (kv_cache.self_k == nullptr || kv_cache.self_v == nullptr) {
@@ -92,9 +87,8 @@ PrefillBuild build_prefill_graph(ggml_context *                  ctx,
         return pb;
     }
     if (T_prompt > kv_cache.n_ctx) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "voxtral decoder: T_prompt=%d exceeds kv_cache.n_ctx=%d",
-                     T_prompt, kv_cache.n_ctx);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral decoder: T_prompt=%d exceeds kv_cache.n_ctx=%d", T_prompt,
+                kv_cache.n_ctx);
         return pb;
     }
 
@@ -102,8 +96,8 @@ PrefillBuild build_prefill_graph(ggml_context *                  ctx,
     const int64_t vocab   = hp.dec_vocab_size;
     const int     n_layer = hp.dec_n_layers;
 
-    const auto block_params = to_block_params(hp);
-    const float rms_eps = hp.dec_rms_norm_eps;
+    const auto  block_params = to_block_params(hp);
+    const float rms_eps      = hp.dec_rms_norm_eps;
 
     // ---------- Graph inputs ----------
     pb.input_ids_in = ggml_new_tensor_1d(ctx, GGML_TYPE_I32, T_prompt);
@@ -130,47 +124,45 @@ PrefillBuild build_prefill_graph(ggml_context *                  ctx,
     pb.graph = gf;
 
     // ---------- Token embedding (all positions, for the dump) ----------
-    ggml_tensor * token_emb_all = ggml_get_rows(
-        ctx, weights.dec_embed.token_w, pb.input_ids_in);
+    ggml_tensor * token_emb_all = ggml_get_rows(ctx, weights.dec_embed.token_w, pb.input_ids_in);
     named(token_emb_all, "dec.token_emb");
     pb.dumps.token_emb = token_emb_all;
     transcribe::debug::mark_tensor_for_dump(token_emb_all);
 
     // ---------- Audio injection via 3-way concat ----------
-    const size_t emb_elem = ggml_element_size(token_emb_all);
+    const size_t  emb_elem = ggml_element_size(token_emb_all);
     ggml_tensor * x_prefix = nullptr;
     if (prefix_len > 0) {
-        x_prefix = ggml_view_2d(ctx, token_emb_all, hidden, prefix_len,
-                                emb_elem * hidden, /*off=*/0);
+        x_prefix = ggml_view_2d(ctx, token_emb_all, hidden, prefix_len, emb_elem * hidden, /*off=*/0);
         x_prefix = ggml_cont(ctx, x_prefix);
     }
-    ggml_tensor * x_audio = pb.enc_out_in;
+    ggml_tensor * x_audio  = pb.enc_out_in;
     ggml_tensor * x_suffix = nullptr;
     if (suffix_len > 0) {
-        x_suffix = ggml_view_2d(ctx, token_emb_all, hidden, suffix_len,
-                                emb_elem * hidden,
+        x_suffix = ggml_view_2d(ctx, token_emb_all, hidden, suffix_len, emb_elem * hidden,
                                 emb_elem * hidden * static_cast<size_t>(prefix_len + T_enc));
         x_suffix = ggml_cont(ctx, x_suffix);
     }
 
     ggml_tensor * x = x_audio;
-    if (x_prefix != nullptr) x = ggml_concat(ctx, x_prefix, x, /*dim=*/1);
-    if (x_suffix != nullptr) x = ggml_concat(ctx, x, x_suffix, /*dim=*/1);
+    if (x_prefix != nullptr) {
+        x = ggml_concat(ctx, x_prefix, x, /*dim=*/1);
+    }
+    if (x_suffix != nullptr) {
+        x = ggml_concat(ctx, x, x_suffix, /*dim=*/1);
+    }
     named(x, "dec.audio_injected");
     pb.dumps.audio_injected = x;
     transcribe::debug::mark_tensor_for_dump(x);
 
     // ---------- Block stack ----------
     for (int il = 0; il < n_layer; ++il) {
-        causal_lm::BlockOpts opts {};
+        causal_lm::BlockOpts opts{};
         opts.use_flash             = use_flash;
         opts.slice_last_before_ffn = slice_last && (il == n_layer - 1);
 
-        x = causal_lm::block_prefill(
-            ctx, gf, x,
-            to_block_view(weights.dec_blocks[il]),
-            block_params, kv_cache, il, T_prompt,
-            pb.mask_in, pb.positions_in, opts);
+        x = causal_lm::block_prefill(ctx, gf, x, to_block_view(weights.dec_blocks[il]), block_params, kv_cache, il,
+                                     T_prompt, pb.mask_in, pb.positions_in, opts);
 
         if (il == 0) {
             named(x, "dec.block.0.out");
@@ -201,14 +193,13 @@ PrefillBuild build_prefill_graph(ggml_context *                  ctx,
     if (slice_last) {
         last_x = x;
     } else {
-        last_x = ggml_view_2d(ctx, x, hidden, 1,
-                              ggml_element_size(x) * hidden,
+        last_x = ggml_view_2d(ctx, x, hidden, 1, ggml_element_size(x) * hidden,
                               ggml_element_size(x) * hidden * static_cast<size_t>(T_prompt - 1));
         last_x = ggml_cont(ctx, last_x);
     }
 
     ggml_tensor * logits = ggml_mul_mat(ctx, weights.dec_embed.output_w, last_x);
-    logits = ggml_reshape_1d(ctx, logits, vocab);
+    logits               = ggml_reshape_1d(ctx, logits, vocab);
     named(logits, "dec.logits_raw");
     pb.dumps.logits_raw = logits;
     transcribe::debug::mark_tensor_for_dump(logits);
@@ -217,24 +208,35 @@ PrefillBuild build_prefill_graph(ggml_context *                  ctx,
     ggml_set_output(pb.out);
 
     ggml_build_forward_expand(gf, pb.out);
-    if (pb.dumps.token_emb)       ggml_build_forward_expand(gf, pb.dumps.token_emb);
-    if (pb.dumps.audio_injected)  ggml_build_forward_expand(gf, pb.dumps.audio_injected);
-    if (pb.dumps.block_0_out)     ggml_build_forward_expand(gf, pb.dumps.block_0_out);
-    if (pb.dumps.block_mid_out)   ggml_build_forward_expand(gf, pb.dumps.block_mid_out);
-    if (pb.dumps.block_last_out)  ggml_build_forward_expand(gf, pb.dumps.block_last_out);
-    if (pb.dumps.out_before_head) ggml_build_forward_expand(gf, pb.dumps.out_before_head);
+    if (pb.dumps.token_emb) {
+        ggml_build_forward_expand(gf, pb.dumps.token_emb);
+    }
+    if (pb.dumps.audio_injected) {
+        ggml_build_forward_expand(gf, pb.dumps.audio_injected);
+    }
+    if (pb.dumps.block_0_out) {
+        ggml_build_forward_expand(gf, pb.dumps.block_0_out);
+    }
+    if (pb.dumps.block_mid_out) {
+        ggml_build_forward_expand(gf, pb.dumps.block_mid_out);
+    }
+    if (pb.dumps.block_last_out) {
+        ggml_build_forward_expand(gf, pb.dumps.block_last_out);
+    }
+    if (pb.dumps.out_before_head) {
+        ggml_build_forward_expand(gf, pb.dumps.out_before_head);
+    }
 
     return pb;
 }
 
-StepBuild build_step_graph(ggml_context *                  ctx,
-                           const VoxtralWeights &          weights,
-                           const VoxtralHParams &          hp,
+StepBuild build_step_graph(ggml_context *                   ctx,
+                           const VoxtralWeights &           weights,
+                           const VoxtralHParams &           hp,
                            transcribe::causal_lm::KvCache & kv_cache,
-                           int                             max_n_kv,
-                           bool                            use_flash)
-{
-    StepBuild sb {};
+                           int                              max_n_kv,
+                           bool                             use_flash) {
+    StepBuild sb{};
     sb.max_n_kv = max_n_kv;
 
     if (ctx == nullptr || max_n_kv <= 0) {
@@ -246,9 +248,8 @@ StepBuild build_step_graph(ggml_context *                  ctx,
         return sb;
     }
     if (max_n_kv > kv_cache.n_ctx) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "voxtral step: max_n_kv=%d exceeds kv_cache.n_ctx=%d",
-                     max_n_kv, kv_cache.n_ctx);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral step: max_n_kv=%d exceeds kv_cache.n_ctx=%d", max_n_kv,
+                kv_cache.n_ctx);
         return sb;
     }
 
@@ -284,16 +285,13 @@ StepBuild build_step_graph(ggml_context *                  ctx,
     ggml_tensor * x = ggml_get_rows(ctx, weights.dec_embed.token_w, sb.input_id_in);
 
     for (int il = 0; il < n_layer; ++il) {
-        x = causal_lm::block_step(
-            ctx, gf, x,
-            to_block_view(weights.dec_blocks[il]),
-            block_params, kv_cache, il, max_n_kv,
-            sb.mask_in, sb.position_in, sb.kv_idx_in, use_flash);
+        x = causal_lm::block_step(ctx, gf, x, to_block_view(weights.dec_blocks[il]), block_params, kv_cache, il,
+                                  max_n_kv, sb.mask_in, sb.position_in, sb.kv_idx_in, use_flash);
     }
 
-    x = ggml_mul(ctx, ggml_rms_norm(ctx, x, rms_eps), weights.dec_final.norm_w);
+    x                    = ggml_mul(ctx, ggml_rms_norm(ctx, x, rms_eps), weights.dec_final.norm_w);
     ggml_tensor * logits = ggml_mul_mat(ctx, weights.dec_embed.output_w, x);
-    logits = ggml_reshape_1d(ctx, logits, vocab);
+    logits               = ggml_reshape_1d(ctx, logits, vocab);
     ggml_set_name(logits, "step.logits");
     // Kept as a graph output so the mid-generation dec.logits_raw.gen<N> dump
     // can read it back after a step compute.
@@ -318,46 +316,40 @@ StepBuild build_step_graph(ggml_context *                  ctx,
 // and audio injection at the audio_token_id positions.
 // ---------------------------------------------------------------------------
 
-PrefillBuildBatched build_prefill_graph_batched(
-    ggml_context *                  ctx,
-    const VoxtralWeights &          weights,
-    const VoxtralHParams &          hp,
-    transcribe::causal_lm::KvCache & kv_cache,
-    int                             T_prompt_max,
-    int                             T_audio_max,
-    int                             n_batch,
-    bool                            use_flash)
-{
-    PrefillBuildBatched pb {};
+PrefillBuildBatched build_prefill_graph_batched(ggml_context *                   ctx,
+                                                const VoxtralWeights &           weights,
+                                                const VoxtralHParams &           hp,
+                                                transcribe::causal_lm::KvCache & kv_cache,
+                                                int                              T_prompt_max,
+                                                int                              T_audio_max,
+                                                int                              n_batch,
+                                                bool                             use_flash) {
+    PrefillBuildBatched pb{};
     pb.T_prompt_max = T_prompt_max;
     pb.T_audio_max  = T_audio_max;
     pb.n_batch      = n_batch;
 
-    if (ctx == nullptr || T_prompt_max <= 0 || T_audio_max <= 0 ||
-        n_batch <= 0 || !use_flash ||
-        kv_cache.self_k == nullptr || kv_cache.n_batch != n_batch ||
-        T_prompt_max > kv_cache.n_ctx) {
+    if (ctx == nullptr || T_prompt_max <= 0 || T_audio_max <= 0 || n_batch <= 0 || !use_flash ||
+        kv_cache.self_k == nullptr || kv_cache.n_batch != n_batch || T_prompt_max > kv_cache.n_ctx) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral prefill(batched): invalid arg");
         return pb;
     }
 
-    const int64_t hidden  = hp.dec_hidden;
-    const int64_t vocab   = hp.dec_vocab_size;
-    const int     n_layer = hp.dec_n_layers;
-    const float   rms_eps = hp.dec_rms_norm_eps;
-    const int     B       = n_batch;
-    const auto block_params = to_block_params(hp);
+    const int64_t hidden       = hp.dec_hidden;
+    const int64_t vocab        = hp.dec_vocab_size;
+    const int     n_layer      = hp.dec_n_layers;
+    const float   rms_eps      = hp.dec_rms_norm_eps;
+    const int     B            = n_batch;
+    const auto    block_params = to_block_params(hp);
 
     (void) T_audio_max;  // audio_dense is prompt-sized; T_audio_max no longer used
     pb.input_ids_in = ggml_new_tensor_2d(ctx, GGML_TYPE_I32, T_prompt_max, B);
     ggml_set_input(pb.input_ids_in);
     // Audio injection is an elementwise blend (see header): x*keep_mask +
     // audio_dense, which crosses the CPU/CUDA split cleanly unlike a set_rows.
-    pb.audio_dense_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, hidden,
-                                           static_cast<int64_t>(T_prompt_max) * B);
+    pb.audio_dense_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, hidden, static_cast<int64_t>(T_prompt_max) * B);
     ggml_set_input(pb.audio_dense_in);
-    pb.keep_mask_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, 1,
-                                         static_cast<int64_t>(T_prompt_max) * B);
+    pb.keep_mask_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, 1, static_cast<int64_t>(T_prompt_max) * B);
     ggml_set_input(pb.keep_mask_in);
     pb.positions_in = ggml_new_tensor_1d(ctx, GGML_TYPE_I32, T_prompt_max);
     ggml_set_input(pb.positions_in);
@@ -378,60 +370,55 @@ PrefillBuildBatched build_prefill_graph_batched(
     // Token-embed all (right-padded) prompt rows, then blend the audio embeds in
     // elementwise: x = x*keep_mask + audio_dense (keep_mask broadcasts over
     // hidden). Reshape to 3D for the batched block stack.
-    ggml_tensor * ids_flat =
-        ggml_reshape_1d(ctx, pb.input_ids_in,
-                        static_cast<int64_t>(T_prompt_max) * B);
-    ggml_tensor * x = ggml_get_rows(ctx, weights.dec_embed.token_w, ids_flat);
-    x = ggml_add(ctx, ggml_mul(ctx, x, pb.keep_mask_in), pb.audio_dense_in);
-    x = ggml_reshape_3d(ctx, x, hidden, T_prompt_max, B);
+    ggml_tensor * ids_flat = ggml_reshape_1d(ctx, pb.input_ids_in, static_cast<int64_t>(T_prompt_max) * B);
+    ggml_tensor * x        = ggml_get_rows(ctx, weights.dec_embed.token_w, ids_flat);
+    x                      = ggml_add(ctx, ggml_mul(ctx, x, pb.keep_mask_in), pb.audio_dense_in);
+    x                      = ggml_reshape_3d(ctx, x, hidden, T_prompt_max, B);
 
     for (int il = 0; il < n_layer; ++il) {
-        x = causal_lm::block_prefill_batched(
-            ctx, gf, x, to_block_view(weights.dec_blocks[il]),
-            block_params, kv_cache, il, T_prompt_max, B,
-            pb.mask_in, pb.positions_in, pb.kv_idx_in, use_flash);
-        if (x == nullptr) { pb.graph = nullptr; return pb; }
+        x = causal_lm::block_prefill_batched(ctx, gf, x, to_block_view(weights.dec_blocks[il]), block_params, kv_cache,
+                                             il, T_prompt_max, B, pb.mask_in, pb.positions_in, pb.kv_idx_in, use_flash);
+        if (x == nullptr) {
+            pb.graph = nullptr;
+            return pb;
+        }
     }
 
     // Gather each utterance's real last position, final RMSNorm, UNTIED head.
     ggml_tensor * x_last = ggml_get_rows(ctx, x, pb.last_idx_in);
-    x_last = ggml_reshape_2d(ctx, x_last, hidden, B);
-    x_last = ggml_mul(ctx, ggml_rms_norm(ctx, x_last, rms_eps),
-                      weights.dec_final.norm_w);
+    x_last               = ggml_reshape_2d(ctx, x_last, hidden, B);
+    x_last               = ggml_mul(ctx, ggml_rms_norm(ctx, x_last, rms_eps), weights.dec_final.norm_w);
     ggml_tensor * logits = ggml_mul_mat(ctx, weights.dec_embed.output_w, x_last);
-    logits = ggml_reshape_2d(ctx, logits, vocab, B);
-    pb.logits = logits;
-    pb.out = ggml_argmax(ctx, logits);
+    logits               = ggml_reshape_2d(ctx, logits, vocab, B);
+    pb.logits            = logits;
+    pb.out               = ggml_argmax(ctx, logits);
     ggml_set_output(pb.out);
     ggml_build_forward_expand(gf, pb.out);
     ggml_build_forward_expand(gf, logits);
     return pb;
 }
 
-StepBuildBatched build_step_graph_batched(
-    ggml_context *                  ctx,
-    const VoxtralWeights &          weights,
-    const VoxtralHParams &          hp,
-    transcribe::causal_lm::KvCache & kv_cache,
-    int                             max_n_kv,
-    int                             n_batch,
-    bool                            use_flash)
-{
-    StepBuildBatched sb {};
+StepBuildBatched build_step_graph_batched(ggml_context *                   ctx,
+                                          const VoxtralWeights &           weights,
+                                          const VoxtralHParams &           hp,
+                                          transcribe::causal_lm::KvCache & kv_cache,
+                                          int                              max_n_kv,
+                                          int                              n_batch,
+                                          bool                             use_flash) {
+    StepBuildBatched sb{};
     sb.max_n_kv = max_n_kv;
     sb.n_batch  = n_batch;
-    if (ctx == nullptr || max_n_kv <= 0 || n_batch <= 0 || !use_flash ||
-        kv_cache.self_k == nullptr || kv_cache.n_batch != n_batch ||
-        max_n_kv > kv_cache.n_ctx) {
+    if (ctx == nullptr || max_n_kv <= 0 || n_batch <= 0 || !use_flash || kv_cache.self_k == nullptr ||
+        kv_cache.n_batch != n_batch || max_n_kv > kv_cache.n_ctx) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral step(batched): invalid arg");
         return sb;
     }
 
-    const int64_t vocab   = hp.dec_vocab_size;
-    const int     n_layer = hp.dec_n_layers;
-    const float   rms_eps = hp.dec_rms_norm_eps;
-    const int     B       = n_batch;
-    const auto block_params = to_block_params(hp);
+    const int64_t vocab        = hp.dec_vocab_size;
+    const int     n_layer      = hp.dec_n_layers;
+    const float   rms_eps      = hp.dec_rms_norm_eps;
+    const int     B            = n_batch;
+    const auto    block_params = to_block_params(hp);
 
     sb.input_ids_in = ggml_new_tensor_1d(ctx, GGML_TYPE_I32, B);
     ggml_set_input(sb.input_ids_in);
@@ -452,22 +439,23 @@ StepBuildBatched build_step_graph_batched(
     ggml_tensor * x = ggml_get_rows(ctx, weights.dec_embed.token_w,
                                     sb.input_ids_in);  // [hidden, B]
     for (int il = 0; il < n_layer; ++il) {
-        x = causal_lm::block_step_batched(
-            ctx, gf, x, to_block_view(weights.dec_blocks[il]),
-            block_params, kv_cache, il, max_n_kv, B,
-            sb.mask_in, sb.position_in, sb.kv_idx_in, use_flash);
-        if (x == nullptr) { sb.graph = nullptr; return sb; }
+        x = causal_lm::block_step_batched(ctx, gf, x, to_block_view(weights.dec_blocks[il]), block_params, kv_cache, il,
+                                          max_n_kv, B, sb.mask_in, sb.position_in, sb.kv_idx_in, use_flash);
+        if (x == nullptr) {
+            sb.graph = nullptr;
+            return sb;
+        }
     }
 
-    x = ggml_mul(ctx, ggml_rms_norm(ctx, x, rms_eps), weights.dec_final.norm_w);
+    x                    = ggml_mul(ctx, ggml_rms_norm(ctx, x, rms_eps), weights.dec_final.norm_w);
     ggml_tensor * logits = ggml_mul_mat(ctx, weights.dec_embed.output_w, x);
-    logits = ggml_reshape_2d(ctx, logits, vocab, B);
-    sb.logits = logits;
-    sb.out = ggml_argmax(ctx, logits);
+    logits               = ggml_reshape_2d(ctx, logits, vocab, B);
+    sb.logits            = logits;
+    sb.out               = ggml_argmax(ctx, logits);
     ggml_set_output(sb.out);
     ggml_build_forward_expand(gf, sb.out);
     ggml_build_forward_expand(gf, logits);
     return sb;
 }
 
-} // namespace transcribe::voxtral
+}  // namespace transcribe::voxtral
diff --git a/src/arch/voxtral/decoder.h b/src/arch/voxtral/decoder.h
index b5cbac07..ab23f13c 100644
--- a/src/arch/voxtral/decoder.h
+++ b/src/arch/voxtral/decoder.h
@@ -18,11 +18,10 @@
 
 #pragma once
 
-#include "voxtral.h"
 #include "causal_lm/causal_lm.h"
-#include "weights.h"
-
 #include "ggml.h"
+#include "voxtral.h"
+#include "weights.h"
 
 struct ggml_context;
 struct ggml_cgraph;
@@ -46,8 +45,8 @@ struct PrefillBuild {
     ggml_tensor * positions_in = nullptr;  // [T_prompt] i32 for RoPE
     ggml_tensor * mask_in      = nullptr;  // [T_prompt, T_prompt] f16 causal
     ggml_tensor * out          = nullptr;  // [vocab] last-position logits
-    DecoderDumps  dumps {};
-    ggml_cgraph * graph        = nullptr;
+    DecoderDumps  dumps{};
+    ggml_cgraph * graph = nullptr;
 
     int T_prompt   = 0;
     int T_enc      = 0;
@@ -58,16 +57,16 @@ struct PrefillBuild {
 // Prefill graph: token-embed the prompt, splice proj.out over the audio
 // placeholder run, run the LM blocks (writing KV [0,T_prompt)), final
 // RMSNorm + UNTIED head, output last-position logits.
-PrefillBuild build_prefill_graph(ggml_context *                  ctx,
-                                 const VoxtralWeights &          weights,
-                                 const VoxtralHParams &          hp,
+PrefillBuild build_prefill_graph(ggml_context *                   ctx,
+                                 const VoxtralWeights &           weights,
+                                 const VoxtralHParams &           hp,
                                  transcribe::causal_lm::KvCache & kv_cache,
-                                 int                             T_prompt,
-                                 int                             T_enc,
-                                 int                             prefix_len,
-                                 int                             suffix_len,
-                                 bool                            use_flash,
-                                 bool                            slice_last);
+                                 int                              T_prompt,
+                                 int                              T_enc,
+                                 int                              prefix_len,
+                                 int                              suffix_len,
+                                 bool                             use_flash,
+                                 bool                             slice_last);
 
 struct StepBuild {
     ggml_tensor * input_id_in = nullptr;  // [1] i32
@@ -82,12 +81,12 @@ struct StepBuild {
 };
 
 // Static-shape single-token step graph, reused across every step.
-StepBuild build_step_graph(ggml_context *                  ctx,
-                           const VoxtralWeights &          weights,
-                           const VoxtralHParams &          hp,
+StepBuild build_step_graph(ggml_context *                   ctx,
+                           const VoxtralWeights &           weights,
+                           const VoxtralHParams &           hp,
                            transcribe::causal_lm::KvCache & kv_cache,
-                           int                             max_n_kv,
-                           bool                            use_flash);
+                           int                              max_n_kv,
+                           bool                             use_flash);
 
 // ---------------------------------------------------------------------------
 // Batched prefill / step (offline transcribe_run_batch fast path)
@@ -109,28 +108,27 @@ struct PrefillBuildBatched {
     // split (forced by k-quant token_embd get_rows) cleanly, unlike a set_rows.
     ggml_tensor * audio_dense_in = nullptr;  // [dec_hidden, T_prompt_max*B] f32
     ggml_tensor * keep_mask_in   = nullptr;  // [1, T_prompt_max*B] f32 (0=audio,1=keep)
-    ggml_tensor * positions_in = nullptr;  // [T_prompt_max] i32 (shared)
-    ggml_tensor * mask_in      = nullptr;  // [T_prompt_max, T_prompt_max] f16 causal
-    ggml_tensor * kv_idx_in    = nullptr;  // [T_prompt_max, B] i64 (idx[t,b]=t)
-    ggml_tensor * last_idx_in  = nullptr;  // [1, B] i32 (real last position per utt)
-    ggml_tensor * out          = nullptr;  // [B] i32 argmax of last-position logits
-    ggml_tensor * logits       = nullptr;  // [vocab, B] f32
-    ggml_cgraph * graph        = nullptr;
+    ggml_tensor * positions_in   = nullptr;  // [T_prompt_max] i32 (shared)
+    ggml_tensor * mask_in        = nullptr;  // [T_prompt_max, T_prompt_max] f16 causal
+    ggml_tensor * kv_idx_in      = nullptr;  // [T_prompt_max, B] i64 (idx[t,b]=t)
+    ggml_tensor * last_idx_in    = nullptr;  // [1, B] i32 (real last position per utt)
+    ggml_tensor * out            = nullptr;  // [B] i32 argmax of last-position logits
+    ggml_tensor * logits         = nullptr;  // [vocab, B] f32
+    ggml_cgraph * graph          = nullptr;
 
     int T_prompt_max = 0;
     int T_audio_max  = 0;
     int n_batch      = 0;
 };
 
-PrefillBuildBatched build_prefill_graph_batched(
-    ggml_context *                  ctx,
-    const VoxtralWeights &          weights,
-    const VoxtralHParams &          hp,
-    transcribe::causal_lm::KvCache & kv_cache,
-    int                             T_prompt_max,
-    int                             T_audio_max,
-    int                             n_batch,
-    bool                            use_flash);
+PrefillBuildBatched build_prefill_graph_batched(ggml_context *                   ctx,
+                                                const VoxtralWeights &           weights,
+                                                const VoxtralHParams &           hp,
+                                                transcribe::causal_lm::KvCache & kv_cache,
+                                                int                              T_prompt_max,
+                                                int                              T_audio_max,
+                                                int                              n_batch,
+                                                bool                             use_flash);
 
 struct StepBuildBatched {
     ggml_tensor * input_ids_in = nullptr;  // [B] i32
@@ -145,13 +143,12 @@ struct StepBuildBatched {
     int n_batch  = 0;
 };
 
-StepBuildBatched build_step_graph_batched(
-    ggml_context *                  ctx,
-    const VoxtralWeights &          weights,
-    const VoxtralHParams &          hp,
-    transcribe::causal_lm::KvCache & kv_cache,
-    int                             max_n_kv,
-    int                             n_batch,
-    bool                            use_flash);
+StepBuildBatched build_step_graph_batched(ggml_context *                   ctx,
+                                          const VoxtralWeights &           weights,
+                                          const VoxtralHParams &           hp,
+                                          transcribe::causal_lm::KvCache & kv_cache,
+                                          int                              max_n_kv,
+                                          int                              n_batch,
+                                          bool                             use_flash);
 
-} // namespace transcribe::voxtral
+}  // namespace transcribe::voxtral
diff --git a/src/arch/voxtral/encoder.cpp b/src/arch/voxtral/encoder.cpp
index b5af82d2..97c356f4 100644
--- a/src/arch/voxtral/encoder.cpp
+++ b/src/arch/voxtral/encoder.cpp
@@ -21,13 +21,11 @@
 
 #include "encoder.h"
 
-#include "weights.h"
-
 #include "conformer/conformer.h"
+#include "ggml.h"
 #include "transcribe-debug.h"
 #include "transcribe-log.h"
-
-#include "ggml.h"
+#include "weights.h"
 
 #include <cmath>
 #include <cstdio>
@@ -37,40 +35,46 @@ namespace transcribe::voxtral {
 namespace {
 
 namespace conf = transcribe::conformer;
-using conf::named;
 using conf::layer_norm;
+using conf::named;
 
 // Reshape a 1D conv bias [Cout] into [1, Cout, 1, 1] so it broadcasts
 // across T when added to a ggml_conv_1d output [T_out, Cout, 1, 1].
-ggml_tensor * add_conv1d_bias(ggml_context * ctx,
-                              ggml_tensor *  conv_out,
-                              ggml_tensor *  bias_1d) {
-    if (bias_1d == nullptr) return conv_out;
+ggml_tensor * add_conv1d_bias(ggml_context * ctx, ggml_tensor * conv_out, ggml_tensor * bias_1d) {
+    if (bias_1d == nullptr) {
+        return conv_out;
+    }
     const int64_t channels = bias_1d->ne[0];
-    ggml_tensor * bias_4d = ggml_reshape_4d(ctx, bias_1d, 1, channels, 1, 1);
+    ggml_tensor * bias_4d  = ggml_reshape_4d(ctx, bias_1d, 1, channels, 1, 1);
     return ggml_add(ctx, conv_out, bias_4d);
 }
 
 // Whisper-style MHSA. x:[d_model, T]; q/v/out bias, k no bias.
 ggml_tensor * mha_encoder(ggml_context * ctx,
                           ggml_tensor *  x,
-                          ggml_tensor *  q_w, ggml_tensor * q_b,
+                          ggml_tensor *  q_w,
+                          ggml_tensor *  q_b,
                           ggml_tensor *  k_w,
-                          ggml_tensor *  v_w, ggml_tensor * v_b,
-                          ggml_tensor *  out_w, ggml_tensor * out_b,
+                          ggml_tensor *  v_w,
+                          ggml_tensor *  v_b,
+                          ggml_tensor *  out_w,
+                          ggml_tensor *  out_b,
                           int            n_heads,
                           int            d_model,
-                          bool           use_flash)
-{
+                          bool           use_flash) {
     const int     head_dim = d_model / n_heads;
     const float   scale    = 1.0f / std::sqrt(static_cast<float>(head_dim));
     const int64_t T        = x->ne[1];
 
     ggml_tensor * q = ggml_mul_mat(ctx, q_w, x);
-    if (q_b != nullptr) q = ggml_add(ctx, q, q_b);
+    if (q_b != nullptr) {
+        q = ggml_add(ctx, q, q_b);
+    }
     ggml_tensor * k = ggml_mul_mat(ctx, k_w, x);  // no bias
     ggml_tensor * v = ggml_mul_mat(ctx, v_w, x);
-    if (v_b != nullptr) v = ggml_add(ctx, v, v_b);
+    if (v_b != nullptr) {
+        v = ggml_add(ctx, v, v_b);
+    }
 
     q = ggml_permute(ctx, ggml_reshape_3d(ctx, q, head_dim, n_heads, T), 0, 2, 1, 3);
     k = ggml_permute(ctx, ggml_reshape_3d(ctx, k, head_dim, n_heads, T), 0, 2, 1, 3);
@@ -81,55 +85,58 @@ ggml_tensor * mha_encoder(ggml_context * ctx,
         ggml_tensor * q_c = ggml_cont(ctx, q);
         ggml_tensor * k_c = ggml_cont(ctx, k);
         ggml_tensor * v_c = ggml_cont(ctx, v);
-        o = ggml_flash_attn_ext(ctx, q_c, k_c, v_c, nullptr, scale, 0.0f, 0.0f);
-        o = ggml_reshape_2d(ctx, o, d_model, T);
+        o                 = ggml_flash_attn_ext(ctx, q_c, k_c, v_c, nullptr, scale, 0.0f, 0.0f);
+        o                 = ggml_reshape_2d(ctx, o, d_model, T);
     } else {
         ggml_tensor * kq      = ggml_mul_mat(ctx, ggml_cont(ctx, k), ggml_cont(ctx, q));
         ggml_tensor * kq_soft = ggml_soft_max_ext(ctx, kq, nullptr, scale, 0.0f);
         ggml_tensor * v_t     = ggml_cont(ctx, ggml_permute(ctx, v, 1, 0, 2, 3));
-        o = ggml_mul_mat(ctx, v_t, kq_soft);
-        o = ggml_cont(ctx, ggml_permute(ctx, o, 0, 2, 1, 3));
-        o = ggml_reshape_2d(ctx, o, d_model, T);
+        o                     = ggml_mul_mat(ctx, v_t, kq_soft);
+        o                     = ggml_cont(ctx, ggml_permute(ctx, o, 0, 2, 1, 3));
+        o                     = ggml_reshape_2d(ctx, o, d_model, T);
     }
 
     o = ggml_mul_mat(ctx, out_w, o);
-    if (out_b != nullptr) o = ggml_add(ctx, o, out_b);
+    if (out_b != nullptr) {
+        o = ggml_add(ctx, o, out_b);
+    }
     return o;
 }
 
 ggml_tensor * ffn(ggml_context * ctx,
                   ggml_tensor *  x,
-                  ggml_tensor *  fc1_w, ggml_tensor * fc1_b,
-                  ggml_tensor *  fc2_w, ggml_tensor * fc2_b) {
+                  ggml_tensor *  fc1_w,
+                  ggml_tensor *  fc1_b,
+                  ggml_tensor *  fc2_w,
+                  ggml_tensor *  fc2_b) {
     ggml_tensor * h = ggml_mul_mat(ctx, fc1_w, x);
-    if (fc1_b != nullptr) h = ggml_add(ctx, h, fc1_b);
-    h = ggml_gelu_erf(ctx, h);
+    if (fc1_b != nullptr) {
+        h = ggml_add(ctx, h, fc1_b);
+    }
+    h               = ggml_gelu_erf(ctx, h);
     ggml_tensor * o = ggml_mul_mat(ctx, fc2_w, h);
-    if (fc2_b != nullptr) o = ggml_add(ctx, o, fc2_b);
+    if (fc2_b != nullptr) {
+        o = ggml_add(ctx, o, fc2_b);
+    }
     return o;
 }
 
-ggml_tensor * build_block(ggml_context *         ctx,
-                          ggml_tensor *          x,
+ggml_tensor * build_block(ggml_context *          ctx,
+                          ggml_tensor *           x,
                           const VoxtralEncBlock & b,
-                          int                    n_heads,
-                          int                    d_model,
-                          bool                   use_flash)
-{
+                          int                     n_heads,
+                          int                     d_model,
+                          bool                    use_flash) {
     {
         ggml_tensor * y = layer_norm(ctx, x, b.norm_attn_w, b.norm_attn_b);
-        y = mha_encoder(ctx, y,
-                        b.attn_q_w, b.attn_q_b,
-                        b.attn_k_w,
-                        b.attn_v_w, b.attn_v_b,
-                        b.attn_out_w, b.attn_out_b,
+        y = mha_encoder(ctx, y, b.attn_q_w, b.attn_q_b, b.attn_k_w, b.attn_v_w, b.attn_v_b, b.attn_out_w, b.attn_out_b,
                         n_heads, d_model, use_flash);
         x = ggml_add(ctx, x, y);
     }
     {
         ggml_tensor * y = layer_norm(ctx, x, b.norm_ffn_w, b.norm_ffn_b);
-        y = ffn(ctx, y, b.fc1_w, b.fc1_b, b.fc2_w, b.fc2_b);
-        x = ggml_add(ctx, x, y);
+        y               = ffn(ctx, y, b.fc1_w, b.fc1_b, b.fc2_w, b.fc2_b);
+        x               = ggml_add(ctx, x, y);
     }
     return x;
 }
@@ -138,23 +145,29 @@ ggml_tensor * build_block(ggml_context *         ctx,
 // q/v/out bias, k no bias. Flash-only (the batch fast path requires it).
 ggml_tensor * mha_encoder_batched(ggml_context * ctx,
                                   ggml_tensor *  x,
-                                  ggml_tensor *  q_w, ggml_tensor * q_b,
+                                  ggml_tensor *  q_w,
+                                  ggml_tensor *  q_b,
                                   ggml_tensor *  k_w,
-                                  ggml_tensor *  v_w, ggml_tensor * v_b,
-                                  ggml_tensor *  out_w, ggml_tensor * out_b,
+                                  ggml_tensor *  v_w,
+                                  ggml_tensor *  v_b,
+                                  ggml_tensor *  out_w,
+                                  ggml_tensor *  out_b,
                                   int            n_heads,
-                                  int            d_model)
-{
+                                  int            d_model) {
     const int     head_dim = d_model / n_heads;
     const float   scale    = 1.0f / std::sqrt(static_cast<float>(head_dim));
     const int64_t T        = x->ne[1];
     const int64_t B        = x->ne[2];
 
     ggml_tensor * q = ggml_mul_mat(ctx, q_w, x);
-    if (q_b != nullptr) q = ggml_add(ctx, q, q_b);
+    if (q_b != nullptr) {
+        q = ggml_add(ctx, q, q_b);
+    }
     ggml_tensor * k = ggml_mul_mat(ctx, k_w, x);  // no bias
     ggml_tensor * v = ggml_mul_mat(ctx, v_w, x);
-    if (v_b != nullptr) v = ggml_add(ctx, v, v_b);
+    if (v_b != nullptr) {
+        v = ggml_add(ctx, v, v_b);
+    }
 
     // [d_model, T, B] -> [head_dim, n_heads, T, B] -> [head_dim, T, n_heads, B]
     q = ggml_permute(ctx, ggml_reshape_4d(ctx, q, head_dim, n_heads, T, B), 0, 2, 1, 3);
@@ -165,23 +178,31 @@ ggml_tensor * mha_encoder_batched(ggml_context * ctx,
     ggml_tensor * k_c = ggml_cont(ctx, k);
     ggml_tensor * v_c = ggml_cont(ctx, v);
     // flash batches on ne[3]; output [head_dim, n_heads, T, B] -> [d_model, T, B].
-    ggml_tensor * o = ggml_flash_attn_ext(ctx, q_c, k_c, v_c, nullptr, scale, 0.0f, 0.0f);
-    o = ggml_reshape_3d(ctx, o, d_model, T, B);
+    ggml_tensor * o   = ggml_flash_attn_ext(ctx, q_c, k_c, v_c, nullptr, scale, 0.0f, 0.0f);
+    o                 = ggml_reshape_3d(ctx, o, d_model, T, B);
 
     o = ggml_mul_mat(ctx, out_w, o);
-    if (out_b != nullptr) o = ggml_add(ctx, o, out_b);
+    if (out_b != nullptr) {
+        o = ggml_add(ctx, o, out_b);
+    }
     return o;
 }
 
 ggml_tensor * ffn_batched(ggml_context * ctx,
                           ggml_tensor *  x,
-                          ggml_tensor *  fc1_w, ggml_tensor * fc1_b,
-                          ggml_tensor *  fc2_w, ggml_tensor * fc2_b) {
+                          ggml_tensor *  fc1_w,
+                          ggml_tensor *  fc1_b,
+                          ggml_tensor *  fc2_w,
+                          ggml_tensor *  fc2_b) {
     ggml_tensor * h = ggml_mul_mat(ctx, fc1_w, x);
-    if (fc1_b != nullptr) h = ggml_add(ctx, h, fc1_b);
-    h = ggml_gelu_erf(ctx, h);
+    if (fc1_b != nullptr) {
+        h = ggml_add(ctx, h, fc1_b);
+    }
+    h               = ggml_gelu_erf(ctx, h);
     ggml_tensor * o = ggml_mul_mat(ctx, fc2_w, h);
-    if (fc2_b != nullptr) o = ggml_add(ctx, o, fc2_b);
+    if (fc2_b != nullptr) {
+        o = ggml_add(ctx, o, fc2_b);
+    }
     return o;
 }
 
@@ -189,40 +210,33 @@ ggml_tensor * build_block_batched(ggml_context *          ctx,
                                   ggml_tensor *           x,
                                   const VoxtralEncBlock & b,
                                   int                     n_heads,
-                                  int                     d_model)
-{
+                                  int                     d_model) {
     {
         ggml_tensor * y = layer_norm(ctx, x, b.norm_attn_w, b.norm_attn_b);
-        y = mha_encoder_batched(ctx, y,
-                                b.attn_q_w, b.attn_q_b,
-                                b.attn_k_w,
-                                b.attn_v_w, b.attn_v_b,
-                                b.attn_out_w, b.attn_out_b,
-                                n_heads, d_model);
+        y = mha_encoder_batched(ctx, y, b.attn_q_w, b.attn_q_b, b.attn_k_w, b.attn_v_w, b.attn_v_b, b.attn_out_w,
+                                b.attn_out_b, n_heads, d_model);
         x = ggml_add(ctx, x, y);
     }
     {
         ggml_tensor * y = layer_norm(ctx, x, b.norm_ffn_w, b.norm_ffn_b);
-        y = ffn_batched(ctx, y, b.fc1_w, b.fc1_b, b.fc2_w, b.fc2_b);
-        x = ggml_add(ctx, x, y);
+        y               = ffn_batched(ctx, y, b.fc1_w, b.fc1_b, b.fc2_w, b.fc2_b);
+        x               = ggml_add(ctx, x, y);
     }
     return x;
 }
 
-} // namespace
+}  // namespace
 
 EncoderBuild build_encoder_graph(ggml_context *         ctx,
                                  const VoxtralWeights & w,
                                  const VoxtralHParams & hp,
                                  int                    n_mel_frames,
-                                 bool                   use_flash)
-{
-    EncoderBuild eb {};
+                                 bool                   use_flash) {
+    EncoderBuild eb{};
 
     if (ctx == nullptr || n_mel_frames <= 0 || n_mel_frames % 2 != 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "voxtral encoder: invalid n_mel_frames=%d (must be positive even)",
-                     n_mel_frames);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral encoder: invalid n_mel_frames=%d (must be positive even)",
+                n_mel_frames);
         return eb;
     }
 
@@ -233,28 +247,29 @@ EncoderBuild build_encoder_graph(ggml_context *         ctx,
 
     if (T_enc != hp.enc_max_source_positions) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "voxtral encoder: T_enc=%d != max_source_positions=%d "
-                     "(mel must be padded to %d frames)",
-                     T_enc, hp.enc_max_source_positions,
-                     2 * hp.enc_max_source_positions);
+                "voxtral encoder: T_enc=%d != max_source_positions=%d "
+                "(mel must be padded to %d frames)",
+                T_enc, hp.enc_max_source_positions, 2 * hp.enc_max_source_positions);
         return eb;
     }
 
     // ---- mel input ----
     eb.mel_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, n_mels, n_mel_frames);
-    if (eb.mel_in == nullptr) return eb;
+    if (eb.mel_in == nullptr) {
+        return eb;
+    }
     named(eb.mel_in, "enc.mel.in");
     ggml_set_input(eb.mel_in);
 
     // ---- conv stem ----
     ggml_tensor * x = ggml_cont(ctx, ggml_transpose(ctx, eb.mel_in));  // [T, n_mels]
-    x = conf::conv_1d_f32(ctx, w.enc_stem.conv0_w, x, /*s=*/1, /*p=*/1, /*d=*/1);
-    x = add_conv1d_bias(ctx, x, w.enc_stem.conv0_b);
-    x = ggml_gelu_erf(ctx, x);  // [T, d_model] — already the layout conv2 wants
-    x = conf::conv_1d_f32(ctx, w.enc_stem.conv1_w, x, /*s=*/2, /*p=*/1, /*d=*/1);
-    x = add_conv1d_bias(ctx, x, w.enc_stem.conv1_b);
-    x = ggml_gelu_erf(ctx, x);
-    x = ggml_cont(ctx, ggml_transpose(ctx, x));  // [d_model, T_enc]
+    x               = conf::conv_1d_f32(ctx, w.enc_stem.conv0_w, x, /*s=*/1, /*p=*/1, /*d=*/1);
+    x               = add_conv1d_bias(ctx, x, w.enc_stem.conv0_b);
+    x               = ggml_gelu_erf(ctx, x);  // [T, d_model] — already the layout conv2 wants
+    x               = conf::conv_1d_f32(ctx, w.enc_stem.conv1_w, x, /*s=*/2, /*p=*/1, /*d=*/1);
+    x               = add_conv1d_bias(ctx, x, w.enc_stem.conv1_b);
+    x               = ggml_gelu_erf(ctx, x);
+    x               = ggml_cont(ctx, ggml_transpose(ctx, x));  // [d_model, T_enc]
 
     // ---- + fixed sinusoidal positional embedding ----
     x = ggml_add(ctx, x, w.enc_top.pos_emb_w);
@@ -282,12 +297,12 @@ EncoderBuild build_encoder_graph(ggml_context *         ctx,
     // ggml contiguous memory order is (d innermost, t next), which is the
     // C-order [1500, 1280] of the reference last_hidden_state, so a plain
     // reshape yields token i = concat(frames 4i..4i+3).
-    const int n_audio = hp.audio_tokens_per_chunk();
-    ggml_tensor * xc = ggml_cont(ctx, x);
+    const int     n_audio = hp.audio_tokens_per_chunk();
+    ggml_tensor * xc      = ggml_cont(ctx, x);
     ggml_tensor * grouped = ggml_reshape_2d(ctx, xc, hp.proj_in, n_audio);
-    ggml_tensor * p = ggml_mul_mat(ctx, w.proj.linear_1_w, grouped);  // [H, 375]
-    p = ggml_gelu_erf(ctx, p);
-    p = ggml_mul_mat(ctx, w.proj.linear_2_w, p);                      // [H, 375]
+    ggml_tensor * p       = ggml_mul_mat(ctx, w.proj.linear_1_w, grouped);  // [H, 375]
+    p                     = ggml_gelu_erf(ctx, p);
+    p                     = ggml_mul_mat(ctx, w.proj.linear_2_w, p);        // [H, 375]
     named(p, "proj.out");
     eb.dumps.proj_out = p;
     transcribe::debug::mark_tensor_for_dump(p);
@@ -302,7 +317,9 @@ EncoderBuild build_encoder_graph(ggml_context *         ctx,
     }
     ggml_build_forward_expand(eb.graph, eb.out);
     // Keep dumped intermediates alive (they are side outputs).
-    if (eb.dumps.enc_out) ggml_build_forward_expand(eb.graph, eb.dumps.enc_out);
+    if (eb.dumps.enc_out) {
+        ggml_build_forward_expand(eb.graph, eb.dumps.enc_out);
+    }
     for (ggml_tensor * t : eb.dumps.block_outs) {
         ggml_build_forward_expand(eb.graph, t);
     }
@@ -315,16 +332,14 @@ EncoderBuild build_encoder_graph_batched(ggml_context *         ctx,
                                          const VoxtralHParams & hp,
                                          int                    n_mel_frames,
                                          int                    n_chunks,
-                                         bool                   use_flash)
-{
-    EncoderBuild eb {};
+                                         bool                   use_flash) {
+    EncoderBuild eb{};
 
-    if (ctx == nullptr || n_mel_frames <= 0 || n_mel_frames % 2 != 0 ||
-        n_chunks <= 0 || !use_flash) {
+    if (ctx == nullptr || n_mel_frames <= 0 || n_mel_frames % 2 != 0 || n_chunks <= 0 || !use_flash) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "voxtral encoder(batched): invalid arg "
-                     "(n_mel_frames=%d, n_chunks=%d, use_flash=%d)",
-                     n_mel_frames, n_chunks, static_cast<int>(use_flash));
+                "voxtral encoder(batched): invalid arg "
+                "(n_mel_frames=%d, n_chunks=%d, use_flash=%d)",
+                n_mel_frames, n_chunks, static_cast<int>(use_flash));
         return eb;
     }
 
@@ -335,27 +350,28 @@ EncoderBuild build_encoder_graph_batched(ggml_context *         ctx,
     const int B       = n_chunks;
 
     if (T_enc != hp.enc_max_source_positions) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "voxtral encoder(batched): T_enc=%d != max_source_positions=%d",
-                     T_enc, hp.enc_max_source_positions);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral encoder(batched): T_enc=%d != max_source_positions=%d", T_enc,
+                hp.enc_max_source_positions);
         return eb;
     }
 
     // ---- mel input [n_mels, n_mel_frames, n_chunks] ----
     eb.mel_in = ggml_new_tensor_3d(ctx, GGML_TYPE_F32, n_mels, n_mel_frames, B);
-    if (eb.mel_in == nullptr) return eb;
+    if (eb.mel_in == nullptr) {
+        return eb;
+    }
     named(eb.mel_in, "enc.mel.in.batched");
     ggml_set_input(eb.mel_in);
 
     // ---- conv stem (batch rides ne[2]; conv_1d_f32 N>1 path) ----
     ggml_tensor * x = ggml_cont(ctx, ggml_transpose(ctx, eb.mel_in));  // [T, n_mels, B]
-    x = conf::conv_1d_f32(ctx, w.enc_stem.conv0_w, x, /*s=*/1, /*p=*/1, /*d=*/1);
-    x = add_conv1d_bias(ctx, x, w.enc_stem.conv0_b);
-    x = ggml_gelu_erf(ctx, x);                                         // [T, d_model, B]
-    x = conf::conv_1d_f32(ctx, w.enc_stem.conv1_w, x, /*s=*/2, /*p=*/1, /*d=*/1);
-    x = add_conv1d_bias(ctx, x, w.enc_stem.conv1_b);
-    x = ggml_gelu_erf(ctx, x);                                         // [T_enc, d_model, B]
-    x = ggml_cont(ctx, ggml_transpose(ctx, x));                        // [d_model, T_enc, B]
+    x               = conf::conv_1d_f32(ctx, w.enc_stem.conv0_w, x, /*s=*/1, /*p=*/1, /*d=*/1);
+    x               = add_conv1d_bias(ctx, x, w.enc_stem.conv0_b);
+    x               = ggml_gelu_erf(ctx, x);  // [T, d_model, B]
+    x               = conf::conv_1d_f32(ctx, w.enc_stem.conv1_w, x, /*s=*/2, /*p=*/1, /*d=*/1);
+    x               = add_conv1d_bias(ctx, x, w.enc_stem.conv1_b);
+    x               = ggml_gelu_erf(ctx, x);                   // [T_enc, d_model, B]
+    x               = ggml_cont(ctx, ggml_transpose(ctx, x));  // [d_model, T_enc, B]
 
     // ---- + fixed sinusoidal positional embedding (broadcast over batch) ----
     x = ggml_add(ctx, x, w.enc_top.pos_emb_w);
@@ -367,15 +383,15 @@ EncoderBuild build_encoder_graph_batched(ggml_context *         ctx,
     }
 
     // ---- final LayerNorm ----
-    x = layer_norm(ctx, x, w.enc_top.ln_post_w, w.enc_top.ln_post_b);   // [d_model, T_enc, B]
+    x = layer_norm(ctx, x, w.enc_top.ln_post_w, w.enc_top.ln_post_b);  // [d_model, T_enc, B]
 
     // ---- projector: group 4 frames per chunk -> [proj_in, n_audio, B] ----
-    const int n_audio = hp.audio_tokens_per_chunk();
-    ggml_tensor * xc = ggml_cont(ctx, x);
+    const int     n_audio = hp.audio_tokens_per_chunk();
+    ggml_tensor * xc      = ggml_cont(ctx, x);
     ggml_tensor * grouped = ggml_reshape_3d(ctx, xc, hp.proj_in, n_audio, B);
-    ggml_tensor * p = ggml_mul_mat(ctx, w.proj.linear_1_w, grouped);    // [H, n_audio, B]
-    p = ggml_gelu_erf(ctx, p);
-    p = ggml_mul_mat(ctx, w.proj.linear_2_w, p);                        // [dec_h, n_audio, B]
+    ggml_tensor * p       = ggml_mul_mat(ctx, w.proj.linear_1_w, grouped);  // [H, n_audio, B]
+    p                     = ggml_gelu_erf(ctx, p);
+    p                     = ggml_mul_mat(ctx, w.proj.linear_2_w, p);        // [dec_h, n_audio, B]
     named(p, "proj.out.batched");
 
     eb.out = p;
@@ -390,4 +406,4 @@ EncoderBuild build_encoder_graph_batched(ggml_context *         ctx,
     return eb;
 }
 
-} // namespace transcribe::voxtral
+}  // namespace transcribe::voxtral
diff --git a/src/arch/voxtral/encoder.h b/src/arch/voxtral/encoder.h
index 024b0fa2..165531f5 100644
--- a/src/arch/voxtral/encoder.h
+++ b/src/arch/voxtral/encoder.h
@@ -27,16 +27,16 @@ struct VoxtralHParams;
 struct VoxtralWeights;
 
 struct EncoderDumps {
-    ggml_tensor * enc_out  = nullptr;  // final encoder LayerNorm output
-    ggml_tensor * proj_out = nullptr;  // projector output (audio embeds)
-    std::vector<ggml_tensor *> block_outs;  // per-block residual outputs
+    ggml_tensor *              enc_out  = nullptr;  // final encoder LayerNorm output
+    ggml_tensor *              proj_out = nullptr;  // projector output (audio embeds)
+    std::vector<ggml_tensor *> block_outs;          // per-block residual outputs
 };
 
 struct EncoderBuild {
-    ggml_tensor * mel_in   = nullptr;  // [n_mels, n_mel_frames] input
-    ggml_tensor * out      = nullptr;  // proj.out [dec_hidden, n_audio_tokens]
-    EncoderDumps  dumps {};
-    ggml_cgraph * graph    = nullptr;
+    ggml_tensor * mel_in = nullptr;  // [n_mels, n_mel_frames] input
+    ggml_tensor * out    = nullptr;  // proj.out [dec_hidden, n_audio_tokens]
+    EncoderDumps  dumps{};
+    ggml_cgraph * graph = nullptr;
 };
 
 // Build the encoder+projector forward graph for ONE 30 s chunk.
@@ -62,4 +62,4 @@ EncoderBuild build_encoder_graph_batched(ggml_context *         ctx,
                                          int                    n_chunks,
                                          bool                   use_flash);
 
-} // namespace transcribe::voxtral
+}  // namespace transcribe::voxtral
diff --git a/src/arch/voxtral/model.cpp b/src/arch/voxtral/model.cpp
index b05b8251..d9d755ed 100644
--- a/src/arch/voxtral/model.cpp
+++ b/src/arch/voxtral/model.cpp
@@ -10,13 +10,12 @@
 // Instruct mode covers translation (task TRANSLATE synthesizes "Translate this
 // to {Language}.") and free-text prompting.
 
-#include "voxtral.h"
-
+#include "causal_lm/causal_lm.h"
 #include "decoder.h"
 #include "encoder.h"
-#include "weights.h"
-
-#include "causal_lm/causal_lm.h"
+#include "ggml-backend.h"
+#include "ggml.h"
+#include "gguf.h"
 #include "transcribe-arch.h"
 #include "transcribe-batch-util.h"
 #include "transcribe-debug.h"
@@ -26,18 +25,16 @@
 #include "transcribe-log.h"
 #include "transcribe-mel.h"
 #include "transcribe-meta.h"
-
-#include "ggml.h"
-#include "ggml-backend.h"
-#include "gguf.h"
+#include "voxtral.h"
+#include "weights.h"
 
 #include <algorithm>
 #include <cctype>
+#include <cmath>
 #include <cstdint>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
-#include <cmath>
 #include <memory>
 #include <string>
 #include <thread>
@@ -48,7 +45,7 @@ namespace transcribe::voxtral {
 
 extern const Arch arch;
 
-static_assert(std::is_base_of_v<transcribe_model,   VoxtralModel>);
+static_assert(std::is_base_of_v<transcribe_model, VoxtralModel>);
 static_assert(std::is_base_of_v<transcribe_session, VoxtralSession>);
 
 VoxtralSession::~VoxtralSession() {
@@ -74,9 +71,7 @@ VoxtralModel::~VoxtralModel() {
         backend_buffer = nullptr;
     }
     packed_gate_up.free();
-    for (auto it = plan.scheduler_list.rbegin();
-         it != plan.scheduler_list.rend(); ++it)
-    {
+    for (auto it = plan.scheduler_list.rbegin(); it != plan.scheduler_list.rend(); ++it) {
         ggml_backend_free(*it);
     }
     plan.scheduler_list.clear();
@@ -98,9 +93,11 @@ constexpr int k_decode_budget_min = 448;
 // the trained max so prompt+decode fits. Greedy decode stops at EOS well before
 // this, so a generous ceiling costs only its KV allocation.
 int pick_decode_budget(int n_audio, int t_prompt, int model_max) {
-    int budget = std::max(k_decode_budget_min, n_audio);
-    const int room = model_max - t_prompt;
-    if (budget > room) budget = room;
+    int       budget = std::max(k_decode_budget_min, n_audio);
+    const int room   = model_max - t_prompt;
+    if (budget > room) {
+        budget = room;
+    }
     return budget;
 }
 
@@ -110,8 +107,12 @@ int pick_decode_budget(int n_audio, int t_prompt, int model_max) {
 // max_position_embeddings — the real ceiling, since RoPE is only valid there.
 int pick_kv_ctx(int needed, int model_max) {
     int want = 1024;
-    while (want < needed) want *= 2;
-    if (want > model_max) want = model_max;
+    while (want < needed) {
+        want *= 2;
+    }
+    if (want > model_max) {
+        want = model_max;
+    }
     return want;
 }
 
@@ -143,8 +144,7 @@ int voxtral_context_ceiling(int32_t n_ctx_knob, const VoxtralHParams & hp) {
 // missing, so a misconfigured model is never advertised with a wrong number.
 int64_t voxtral_max_audio_ms(const VoxtralHParams & hp) {
     const int tokens_per_chunk = hp.audio_tokens_per_chunk();
-    if (tokens_per_chunk <= 0 || hp.fe_nb_max_frames <= 0 ||
-        hp.fe_hop_length <= 0 || hp.fe_sample_rate <= 0 ||
+    if (tokens_per_chunk <= 0 || hp.fe_nb_max_frames <= 0 || hp.fe_hop_length <= 0 || hp.fe_sample_rate <= 0 ||
         hp.dec_max_position_embeddings <= 0) {
         return 0;
     }
@@ -152,33 +152,44 @@ int64_t voxtral_max_audio_ms(const VoxtralHParams & hp) {
     // affixes: BOS/INST/BEGIN_AUDIO/[/INST]/TRANSCRIBE plus an optional
     // language hint). Advisory; the real gate uses the actual prompt length.
     constexpr int k_prompt_overhead = 16;
-    const int max_audio_tokens =
-        hp.dec_max_position_embeddings - k_prompt_overhead - k_gen_reserve;
+    const int     max_audio_tokens  = hp.dec_max_position_embeddings - k_prompt_overhead - k_gen_reserve;
     if (max_audio_tokens <= 0) {
         return 0;
     }
     // One 30 s chunk = fe_nb_max_frames mel frames; chunk_ms = frames * hop_ms.
     //   ms_per_audio_token = chunk_ms / tokens_per_chunk
     //   max_audio_ms       = max_audio_tokens * ms_per_audio_token
-    const int64_t chunk_ms = static_cast<int64_t>(hp.fe_nb_max_frames) *
-                             hp.fe_hop_length * 1000 / hp.fe_sample_rate;
+    const int64_t chunk_ms = static_cast<int64_t>(hp.fe_nb_max_frames) * hp.fe_hop_length * 1000 / hp.fe_sample_rate;
     return static_cast<int64_t>(max_audio_tokens) * chunk_ms / tokens_per_chunk;
 }
 
 // BCP-47 -> English language name for the synthesized translate
 // instruction ("Translate this to {Name}."). Covers Voxtral's advertised
 // languages; falls back to the raw code if unknown.
-struct LangName { const char * bcp47; const char * name; };
+struct LangName {
+    const char * bcp47;
+    const char * name;
+};
+
 constexpr LangName k_lang_names[] = {
-    {"en", "English"}, {"fr", "French"},  {"de", "German"},
-    {"es", "Spanish"}, {"it", "Italian"}, {"pt", "Portuguese"},
-    {"nl", "Dutch"},   {"hi", "Hindi"},
+    { "en", "English"    },
+    { "fr", "French"     },
+    { "de", "German"     },
+    { "es", "Spanish"    },
+    { "it", "Italian"    },
+    { "pt", "Portuguese" },
+    { "nl", "Dutch"      },
+    { "hi", "Hindi"      },
 };
 
 const char * lang_name_for(const char * bcp47) {
-    if (bcp47 == nullptr || bcp47[0] == '\0') return "English";
+    if (bcp47 == nullptr || bcp47[0] == '\0') {
+        return "English";
+    }
     for (const auto & e : k_lang_names) {
-        if (std::strcmp(e.bcp47, bcp47) == 0) return e.name;
+        if (std::strcmp(e.bcp47, bcp47) == 0) {
+            return e.name;
+        }
     }
     return bcp47;
 }
@@ -186,23 +197,22 @@ const char * lang_name_for(const char * bcp47) {
 // Resolve the transcription/instruct control tokens against the loaded
 // tokenizer. Hard-fails if any piece is missing so a vocab reorder
 // surfaces at load, not mid-decode.
-transcribe_status resolve_specials(const transcribe::Tokenizer & tok,
-                                   const VoxtralHParams &        hp,
-                                   PromptSpecials &              out)
-{
-    struct PieceSlot { const char * piece; int32_t * slot; };
+transcribe_status resolve_specials(const transcribe::Tokenizer & tok, const VoxtralHParams & hp, PromptSpecials & out) {
+    struct PieceSlot {
+        const char * piece;
+        int32_t *    slot;
+    };
+
     const PieceSlot pieces[] = {
-        { "[INST]",         &out.inst        },
-        { "[BEGIN_AUDIO]",  &out.begin_audio },
-        { "[/INST]",        &out.end_inst    },
-        { "[TRANSCRIBE]",   &out.transcribe  },
+        { "[INST]",        &out.inst        },
+        { "[BEGIN_AUDIO]", &out.begin_audio },
+        { "[/INST]",       &out.end_inst    },
+        { "[TRANSCRIBE]",  &out.transcribe  },
     };
     for (const auto & p : pieces) {
         const int id = tok.find(p.piece);
         if (id < 0) {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "voxtral: control token \"%s\" not in tokenizer",
-                         p.piece);
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral: control token \"%s\" not in tokenizer", p.piece);
             return TRANSCRIBE_ERR_GGUF;
         }
         *p.slot = id;
@@ -213,32 +223,31 @@ transcribe_status resolve_specials(const transcribe::Tokenizer & tok,
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral: tokenizer missing bos/eos id");
         return TRANSCRIBE_ERR_GGUF;
     }
-    (void)hp;
+    (void) hp;
     return TRANSCRIBE_OK;
 }
 
 // Build the transcription prompt. language may be null/empty (auto).
-transcribe_status build_transcription_prompt(const VoxtralModel & m,
-                                             const char *         language,
-                                             int                  n_audio,
+transcribe_status build_transcription_prompt(const VoxtralModel &   m,
+                                             const char *           language,
+                                             int                    n_audio,
                                              std::vector<int32_t> & out_ids,
-                                             int &                prefix_len,
-                                             int &                suffix_len)
-{
+                                             int &                  prefix_len,
+                                             int &                  suffix_len) {
     const PromptSpecials & s = m.specials;
     out_ids.clear();
     out_ids.push_back(s.bos);
     out_ids.push_back(s.inst);
     out_ids.push_back(s.begin_audio);
     prefix_len = static_cast<int>(out_ids.size());  // 3
-    for (int i = 0; i < n_audio; ++i) out_ids.push_back(m.hparams.audio_token_id);
+    for (int i = 0; i < n_audio; ++i) {
+        out_ids.push_back(m.hparams.audio_token_id);
+    }
     out_ids.push_back(s.end_inst);
     if (language != nullptr && language[0] != '\0') {
         std::vector<int32_t> lang_ids;
-        const std::string lang_str = std::string("lang:") + language;
-        if (const transcribe_status st = m.tok.encode(lang_str, lang_ids);
-            st != TRANSCRIBE_OK)
-        {
+        const std::string    lang_str = std::string("lang:") + language;
+        if (const transcribe_status st = m.tok.encode(lang_str, lang_ids); st != TRANSCRIBE_OK) {
             log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral: failed to encode \"%s\"", lang_str.c_str());
             return st;
         }
@@ -250,24 +259,23 @@ transcribe_status build_transcription_prompt(const VoxtralModel & m,
 }
 
 // Build the instruct prompt: audio + BPE(instruction) + [/INST].
-transcribe_status build_instruct_prompt(const VoxtralModel & m,
-                                        const std::string &  instruction,
-                                        int                  n_audio,
+transcribe_status build_instruct_prompt(const VoxtralModel &   m,
+                                        const std::string &    instruction,
+                                        int                    n_audio,
                                         std::vector<int32_t> & out_ids,
-                                        int &                prefix_len,
-                                        int &                suffix_len)
-{
+                                        int &                  prefix_len,
+                                        int &                  suffix_len) {
     const PromptSpecials & s = m.specials;
     out_ids.clear();
     out_ids.push_back(s.bos);
     out_ids.push_back(s.inst);
     out_ids.push_back(s.begin_audio);
     prefix_len = static_cast<int>(out_ids.size());  // 3
-    for (int i = 0; i < n_audio; ++i) out_ids.push_back(m.hparams.audio_token_id);
+    for (int i = 0; i < n_audio; ++i) {
+        out_ids.push_back(m.hparams.audio_token_id);
+    }
     std::vector<int32_t> instr_ids;
-    if (const transcribe_status st = m.tok.encode(instruction, instr_ids);
-        st != TRANSCRIBE_OK)
-    {
+    if (const transcribe_status st = m.tok.encode(instruction, instr_ids); st != TRANSCRIBE_OK) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral: failed to encode instruction text");
         return st;
     }
@@ -277,14 +285,10 @@ transcribe_status build_instruct_prompt(const VoxtralModel & m,
     return TRANSCRIBE_OK;
 }
 
-transcribe_status load(
-    Loader &                              loader,
-    const transcribe_model_load_params *  params,
-    transcribe_model **                   out_model)
-{
+transcribe_status load(Loader & loader, const transcribe_model_load_params * params, transcribe_model ** out_model) {
     const int64_t t_load_start = ggml_time_us();
 
-    auto m = std::make_unique<VoxtralModel>();
+    auto m       = std::make_unique<VoxtralModel>();
     m->arch      = &arch;
     m->t_load_us = 0;
     m->variant   = loader.variant().empty() ? k_default_variant : loader.variant();
@@ -294,16 +298,20 @@ transcribe_status load(
     m->caps.n_languages = 0;
     m->caps.languages   = nullptr;
 
-    if (const transcribe_status st = read_capability_kv(loader.gguf(), m->caps);
-        st != TRANSCRIBE_OK) return st;
-    if (const transcribe_status st = read_languages_kv(loader.gguf(), *m);
-        st != TRANSCRIBE_OK) return st;
+    if (const transcribe_status st = read_capability_kv(loader.gguf(), m->caps); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (const transcribe_status st = read_languages_kv(loader.gguf(), *m); st != TRANSCRIBE_OK) {
+        return st;
+    }
 
-    if (const transcribe_status st = m->tok.load(loader.gguf());
-        st != TRANSCRIBE_OK) return st;
+    if (const transcribe_status st = m->tok.load(loader.gguf()); st != TRANSCRIBE_OK) {
+        return st;
+    }
 
-    if (const transcribe_status st = read_voxtral_hparams(loader.gguf(), m->hparams);
-        st != TRANSCRIBE_OK) return st;
+    if (const transcribe_status st = read_voxtral_hparams(loader.gguf(), m->hparams); st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Publish the input-length ceiling now that the decoder context window and
     // the 30 s-chunk encoder rate are known (apply_family_invariants ran before
@@ -315,24 +323,21 @@ transcribe_status load(
     // a lowered session n_ctx.
     {
         const int tokens_per_chunk = m->hparams.audio_tokens_per_chunk();
-        if (m->hparams.dec_max_position_embeddings > 0 && tokens_per_chunk > 0 &&
-            m->hparams.fe_nb_max_frames > 0 &&
+        if (m->hparams.dec_max_position_embeddings > 0 && tokens_per_chunk > 0 && m->hparams.fe_nb_max_frames > 0 &&
             m->hparams.fe_hop_length > 0 && m->hparams.fe_sample_rate > 0) {
-            m->limits.has_context_cap = true;
-            m->limits.model_max_ctx   = m->hparams.dec_max_position_embeddings;
-            m->limits.prompt_overhead = 16;            // k_prompt_overhead in
-                                                       // voxtral_max_audio_ms
-            m->limits.gen_reserve     = k_gen_reserve;
+            m->limits.has_context_cap    = true;
+            m->limits.model_max_ctx      = m->hparams.dec_max_position_embeddings;
+            m->limits.prompt_overhead    = 16;  // k_prompt_overhead in
+                                                // voxtral_max_audio_ms
+            m->limits.gen_reserve        = k_gen_reserve;
             // ms-per-audio-token = chunk_ms / tokens_per_chunk, where one 30 s
             // chunk = fe_nb_max_frames mel frames (same rate the max_audio_ms
             // helper inverts).
-            const double chunk_ms =
-                static_cast<double>(m->hparams.fe_nb_max_frames) *
-                m->hparams.fe_hop_length * 1000.0 / m->hparams.fe_sample_rate;
+            const double chunk_ms        = static_cast<double>(m->hparams.fe_nb_max_frames) * m->hparams.fe_hop_length *
+                                           1000.0 / m->hparams.fe_sample_rate;
             m->limits.ms_per_audio_token = chunk_ms / tokens_per_chunk;
             m->limits.kv_elems_per_ctx_token =
-                (int64_t) m->hparams.dec_n_kv_heads *
-                m->hparams.dec_head_dim * m->hparams.dec_n_layers * 2;
+                (int64_t) m->hparams.dec_n_kv_heads * m->hparams.dec_head_dim * m->hparams.dec_n_layers * 2;
         }
     }
 
@@ -341,9 +346,8 @@ transcribe_status load(
     m->hparams.eos_token_id = m->tok.eos_id();
 
     if (m->hparams.vocab_size != m->hparams.dec_vocab_size) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "voxtral: tokenizer vocab (%d) != decoder vocab_size (%d)",
-                     m->hparams.vocab_size, m->hparams.dec_vocab_size);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral: tokenizer vocab (%d) != decoder vocab_size (%d)",
+                m->hparams.vocab_size, m->hparams.dec_vocab_size);
         return TRANSCRIBE_ERR_GGUF;
     }
     if (m->hparams.eos_token_id < 0) {
@@ -351,12 +355,13 @@ transcribe_status load(
         return TRANSCRIBE_ERR_GGUF;
     }
 
-    if (const transcribe_status st = resolve_specials(m->tok, m->hparams, m->specials);
-        st != TRANSCRIBE_OK) return st;
+    if (const transcribe_status st = resolve_specials(m->tok, m->hparams, m->specials); st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Mel frontend (Whisper 128-bin log-mel at 16 kHz, per-utterance norm).
     {
-        transcribe::MelConfig cfg {};
+        transcribe::MelConfig cfg{};
         cfg.sample_rate  = m->hparams.fe_sample_rate;
         cfg.num_mels     = m->hparams.fe_num_mels;
         cfg.n_fft        = m->hparams.fe_n_fft;
@@ -369,50 +374,48 @@ transcribe_status load(
         cfg.window_type  = m->hparams.fe_window;     // "hann_periodic"
         cfg.normalize    = m->hparams.fe_normalize;  // "per_utterance"
 
-        using R = transcribe::load_common::ReadF32Result;
-        const size_t fb_elems =
-            static_cast<size_t>(cfg.num_mels) * static_cast<size_t>(cfg.n_fft / 2 + 1);
-        const auto fb_rc = transcribe::load_common::read_f32_tensor_checked(
-            loader.gguf(), loader.path(), "frontend.mel_filterbank", fb_elems,
-            "voxtral", cfg.filterbank);
-        if (fb_rc != R::Ok && fb_rc != R::Absent) return TRANSCRIBE_ERR_GGUF;
+        using R               = transcribe::load_common::ReadF32Result;
+        const size_t fb_elems = static_cast<size_t>(cfg.num_mels) * static_cast<size_t>(cfg.n_fft / 2 + 1);
+        const auto   fb_rc    = transcribe::load_common::read_f32_tensor_checked(
+            loader.gguf(), loader.path(), "frontend.mel_filterbank", fb_elems, "voxtral", cfg.filterbank);
+        if (fb_rc != R::Ok && fb_rc != R::Absent) {
+            return TRANSCRIBE_ERR_GGUF;
+        }
         const size_t win_elems = static_cast<size_t>(cfg.win_length);
-        const auto win_rc = transcribe::load_common::read_f32_tensor_checked(
-            loader.gguf(), loader.path(), "frontend.window", win_elems,
-            "voxtral", cfg.window);
-        if (win_rc != R::Ok && win_rc != R::Absent) return TRANSCRIBE_ERR_GGUF;
+        const auto   win_rc    = transcribe::load_common::read_f32_tensor_checked(
+            loader.gguf(), loader.path(), "frontend.window", win_elems, "voxtral", cfg.window);
+        if (win_rc != R::Ok && win_rc != R::Absent) {
+            return TRANSCRIBE_ERR_GGUF;
+        }
 
         m->mel.emplace(cfg);
     }
 
     // Tensor catalog (no_alloc) + backend alloc + data stream.
-    gguf_init_params init_params {};
-    init_params.no_alloc = true;
-    init_params.ctx      = &m->ctx_meta;
+    gguf_init_params init_params{};
+    init_params.no_alloc     = true;
+    init_params.ctx          = &m->ctx_meta;
     gguf_context * gguf_data = gguf_init_from_file(loader.path().c_str(), init_params);
-    if (gguf_data == nullptr) return TRANSCRIBE_ERR_GGUF;
+    if (gguf_data == nullptr) {
+        return TRANSCRIBE_ERR_GGUF;
+    }
 
-    if (const transcribe_status st = build_voxtral_weights(m->ctx_meta, m->hparams, m->weights);
-        st != TRANSCRIBE_OK)
-    {
+    if (const transcribe_status st = build_voxtral_weights(m->ctx_meta, m->hparams, m->weights); st != TRANSCRIBE_OK) {
         gguf_free(gguf_data);
         return st;
     }
 
-    const transcribe_backend_request backend_req =
-        (params != nullptr) ? params->backend : TRANSCRIBE_BACKEND_AUTO;
+    const transcribe_backend_request backend_req = (params != nullptr) ? params->backend : TRANSCRIBE_BACKEND_AUTO;
     if (const transcribe_status st = transcribe::load_common::init_backends(
             backend_req, (params != nullptr) ? params->gpu_device : 0, "voxtral", m->plan);
-        st != TRANSCRIBE_OK)
-    {
+        st != TRANSCRIBE_OK) {
         gguf_free(gguf_data);
         return st;
     }
-    m->backend = ggml_backend_name(m->plan.primary);
+    m->backend         = ggml_backend_name(m->plan.primary);
     m->primary_backend = m->plan.primary;
 
-    ggml_backend_buffer_t weights_buffer =
-        ggml_backend_alloc_ctx_tensors(m->ctx_meta, m->plan.primary);
+    ggml_backend_buffer_t weights_buffer = ggml_backend_alloc_ctx_tensors(m->ctx_meta, m->plan.primary);
     if (weights_buffer == nullptr) {
         gguf_free(gguf_data);
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral: ggml_backend_alloc_ctx_tensors failed");
@@ -421,10 +424,9 @@ transcribe_status load(
     m->backend_buffer = weights_buffer;
     ggml_backend_buffer_set_usage(weights_buffer, GGML_BACKEND_BUFFER_USAGE_WEIGHTS);
 
-    if (const transcribe_status st = transcribe::load_common::stream_tensor_data(
-            loader.path(), gguf_data, m->ctx_meta, "voxtral");
-        st != TRANSCRIBE_OK)
-    {
+    if (const transcribe_status st =
+            transcribe::load_common::stream_tensor_data(loader.path(), gguf_data, m->ctx_meta, "voxtral");
+        st != TRANSCRIBE_OK) {
         gguf_free(gguf_data);
         return st;
     }
@@ -435,30 +437,28 @@ transcribe_status load(
         std::vector<transcribe::causal_lm::GateUpEntry> entries;
         entries.reserve(m->weights.dec_blocks.size());
         for (auto & b : m->weights.dec_blocks) {
-            entries.push_back({b.ffn_gate_w, b.ffn_up_w, &b.ffn_gate_up_w});
+            entries.push_back({ b.ffn_gate_w, b.ffn_up_w, &b.ffn_gate_up_w });
         }
-        if (!transcribe::causal_lm::pack_gate_up(
-                m->plan.primary, m->hparams.dec_hidden, m->hparams.dec_intermediate,
-                entries, m->packed_gate_up, "voxtral"))
-        {
+        if (!transcribe::causal_lm::pack_gate_up(m->plan.primary, m->hparams.dec_hidden, m->hparams.dec_intermediate,
+                                                 entries, m->packed_gate_up, "voxtral")) {
             m->packed_gate_up.free();
             return TRANSCRIBE_ERR_GGUF;
         }
     }
 
     m->t_load_us = ggml_time_us() - t_load_start;
-    *out_model = m.release();
+    *out_model   = m.release();
     return TRANSCRIBE_OK;
 }
 
-transcribe_status init_context(
-    transcribe_model *                model,
-    const transcribe_session_params * params,
-    transcribe_session **             out_ctx)
-{
-    if (model->arch != &arch) return TRANSCRIBE_ERR_INVALID_ARG;
+transcribe_status init_context(transcribe_model *                model,
+                               const transcribe_session_params * params,
+                               transcribe_session **             out_ctx) {
+    if (model->arch != &arch) {
+        return TRANSCRIBE_ERR_INVALID_ARG;
+    }
 
-    auto cc = std::make_unique<VoxtralSession>();
+    auto cc       = std::make_unique<VoxtralSession>();
     cc->model     = model;
     cc->n_threads = params->n_threads;
     cc->kv_type   = params->kv_type;
@@ -473,23 +473,20 @@ transcribe_status init_context(
     auto * cm = static_cast<VoxtralModel *>(model);
     {
         ggml_type kv_type = GGML_TYPE_F16;
-        if (cc->kv_type == TRANSCRIBE_KV_TYPE_F32) kv_type = GGML_TYPE_F32;
+        if (cc->kv_type == TRANSCRIBE_KV_TYPE_F32) {
+            kv_type = GGML_TYPE_F32;
+        }
         // Initial allocation only: run()/run_batch() grow the KV cache per
         // utterance up to the decoder's trained context (131072 for Mini-3B).
         // 4096 covers short clips (~5 min) without a realloc on the hot path.
         if (!transcribe::causal_lm::kv_init(cc->kv_cache, cm->plan.primary,
-                                           /*n_ctx=*/4096,
-                                           cm->hparams.dec_n_kv_heads,
-                                           cm->hparams.dec_head_dim,
-                                           cm->hparams.dec_n_layers,
-                                           kv_type))
-        {
+                                            /*n_ctx=*/4096, cm->hparams.dec_n_kv_heads, cm->hparams.dec_head_dim,
+                                            cm->hparams.dec_n_layers, kv_type)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "voxtral init_context: KV cache allocation failed "
-                "(n_ctx=4096, %d kv-heads x %d head-dim x %d layers) — "
-                "out of memory.",
-                cm->hparams.dec_n_kv_heads, cm->hparams.dec_head_dim,
-                cm->hparams.dec_n_layers);
+                                "voxtral init_context: KV cache allocation failed "
+                                "(n_ctx=4096, %d kv-heads x %d head-dim x %d layers) — "
+                                "out of memory.",
+                                cm->hparams.dec_n_kv_heads, cm->hparams.dec_head_dim, cm->hparams.dec_n_layers);
             return TRANSCRIBE_ERR_OOM;
         }
     }
@@ -503,12 +500,10 @@ void set_sched_threads(ggml_backend_sched_t sched, int n_threads) {
     transcribe::configure_sched_n_threads(sched, n_threads);
 }
 
-transcribe_status run(
-    transcribe_session *          session,
-    const float *                 pcm,
-    int                           n_samples,
-    const transcribe_run_params * params)
-{
+transcribe_status run(transcribe_session *          session,
+                      const float *                 pcm,
+                      int                           n_samples,
+                      const transcribe_run_params * params) {
     if (session == nullptr || pcm == nullptr || n_samples <= 0) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
@@ -517,17 +512,18 @@ transcribe_status run(
     if (cm == nullptr || cm->plan.scheduler_list.empty()) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
-    if (cc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
+    if (cc->poll_abort()) {
+        return TRANSCRIBE_ERR_ABORTED;
+    }
 
     transcribe::debug::init();
 
     // ----- Prompt mode -----
-    const bool translate = (params != nullptr &&
-                            params->task == TRANSCRIBE_TASK_TRANSLATE);
+    const bool  translate = (params != nullptr && params->task == TRANSCRIBE_TASK_TRANSLATE);
     std::string instruction;
     if (translate) {
         const char * tgt = (params != nullptr) ? params->target_language : nullptr;
-        instruction = std::string("Translate this to ") + lang_name_for(tgt) + ".";
+        instruction      = std::string("Translate this to ") + lang_name_for(tgt) + ".";
     }
 
     if (!cm->mel.has_value()) {
@@ -538,92 +534,91 @@ transcribe_status run(
     // ----- Chunking: pad PCM to a multiple of 30 s and mel once -----
     int samples_per_chunk = cm->hparams.fe_n_samples;
     if (samples_per_chunk <= 0) {
-        samples_per_chunk = (cm->hparams.fe_chunk_length > 0
-                                 ? cm->hparams.fe_chunk_length : 30) *
-                            cm->hparams.fe_sample_rate;
+        samples_per_chunk =
+            (cm->hparams.fe_chunk_length > 0 ? cm->hparams.fe_chunk_length : 30) * cm->hparams.fe_sample_rate;
     }
-    const int frames_per_chunk = (cm->hparams.fe_nb_max_frames > 0)
-        ? cm->hparams.fe_nb_max_frames
-        : samples_per_chunk / cm->hparams.fe_hop_length;
-    const int audio_per_chunk = cm->hparams.audio_tokens_per_chunk();
+    const int frames_per_chunk = (cm->hparams.fe_nb_max_frames > 0) ? cm->hparams.fe_nb_max_frames :
+                                                                      samples_per_chunk / cm->hparams.fe_hop_length;
+    const int audio_per_chunk  = cm->hparams.audio_tokens_per_chunk();
 
-    const int n_chunks = std::max(1, (n_samples + samples_per_chunk - 1) / samples_per_chunk);
-    const size_t padded = static_cast<size_t>(n_chunks) * samples_per_chunk;
+    const int    n_chunks = std::max(1, (n_samples + samples_per_chunk - 1) / samples_per_chunk);
+    const size_t padded   = static_cast<size_t>(n_chunks) * samples_per_chunk;
 
     std::vector<float> pcm_padded(padded, 0.0f);
     std::memcpy(pcm_padded.data(), pcm, static_cast<size_t>(n_samples) * sizeof(float));
 
     const int64_t t_mel_start = ggml_time_us();
-    int mel_n_mels = 0, mel_n_frames = 0;
-    if (const transcribe_status mst = cm->mel->compute(
-            pcm_padded.data(), padded, cc->mel_buf, mel_n_mels, mel_n_frames,
-            cc->n_threads);
-        mst != TRANSCRIBE_OK)
-    {
+    int           mel_n_mels = 0, mel_n_frames = 0;
+    if (const transcribe_status mst =
+            cm->mel->compute(pcm_padded.data(), padded, cc->mel_buf, mel_n_mels, mel_n_frames, cc->n_threads);
+        mst != TRANSCRIBE_OK) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral run: MelFrontend::compute failed (%s)",
-                     transcribe_status_string(mst));
+                transcribe_status_string(mst));
         return mst;
     }
     cc->t_mel_us = ggml_time_us() - t_mel_start;
 
     if (mel_n_mels != cm->hparams.enc_num_mel_bins) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral run: mel bins %d != %d",
-                     mel_n_mels, cm->hparams.enc_num_mel_bins);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral run: mel bins %d != %d", mel_n_mels, cm->hparams.enc_num_mel_bins);
         return TRANSCRIBE_ERR_GGUF;
     }
     if (mel_n_frames < n_chunks * frames_per_chunk) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral run: mel frames %d < %d*%d",
-                     mel_n_frames, n_chunks, frames_per_chunk);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral run: mel frames %d < %d*%d", mel_n_frames, n_chunks,
+                frames_per_chunk);
         return TRANSCRIBE_ERR_GGUF;
     }
 
     // enc.mel.in dump: mel-major [n_mels, n_frames], matching the reference.
     if (transcribe::debug::enabled()) {
         const long long shape[2] = { mel_n_mels, mel_n_frames };
-        transcribe::debug::dump_host_f32(
-            "enc.mel.in", cc->mel_buf.data(),
-            static_cast<long long>(cc->mel_buf.size()), shape, 2, "frontend.mel.norm");
+        transcribe::debug::dump_host_f32("enc.mel.in", cc->mel_buf.data(), static_cast<long long>(cc->mel_buf.size()),
+                                         shape, 2, "frontend.mel.norm");
     }
 
     // ----- Encoder + projector, per 30 s chunk -----
-    const int dec_h = cm->hparams.dec_hidden;
+    const int dec_h         = cm->hparams.dec_hidden;
     const int n_audio_total = n_chunks * audio_per_chunk;
     cc->enc_host.assign(static_cast<size_t>(dec_h) * n_audio_total, 0.0f);
 
     if (cc->sched == nullptr) {
-        cc->sched = ggml_backend_sched_new(
-            cm->plan.scheduler_list.data(), nullptr,
-            static_cast<int>(cm->plan.scheduler_list.size()), 16384, false, true);
+        cc->sched = ggml_backend_sched_new(cm->plan.scheduler_list.data(), nullptr,
+                                           static_cast<int>(cm->plan.scheduler_list.size()), 16384, false, true);
         if (cc->sched == nullptr) {
             log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral run: ggml_backend_sched_new failed");
             return TRANSCRIBE_ERR_GGUF;
         }
     }
 
-    const int64_t t_enc_start = ggml_time_us();
+    const int64_t      t_enc_start = ggml_time_us();
     std::vector<float> chunk_mel(static_cast<size_t>(mel_n_mels) * frames_per_chunk);
     for (int c = 0; c < n_chunks; ++c) {
-        if (cc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
+        if (cc->poll_abort()) {
+            return TRANSCRIBE_ERR_ABORTED;
+        }
 
-        if (cc->compute_ctx != nullptr) { ggml_free(cc->compute_ctx); cc->compute_ctx = nullptr; }
-        ggml_init_params ip {};
-        ip.mem_size = 32 * 1024 * 1024;
-        ip.no_alloc = true;
+        if (cc->compute_ctx != nullptr) {
+            ggml_free(cc->compute_ctx);
+            cc->compute_ctx = nullptr;
+        }
+        ggml_init_params ip{};
+        ip.mem_size     = 32 * 1024 * 1024;
+        ip.no_alloc     = true;
         cc->compute_ctx = ggml_init(ip);
         if (cc->compute_ctx == nullptr) {
-            transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "voxtral run: ggml_init (encoder) failed — out of memory.");
+            transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral run: ggml_init (encoder) failed — out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
 
-        EncoderBuild eb = build_encoder_graph(cc->compute_ctx, cm->weights, cm->hparams,
-                                              frames_per_chunk, cc->encoder_use_flash);
-        if (eb.graph == nullptr || eb.out == nullptr) return TRANSCRIBE_ERR_GGUF;
+        EncoderBuild eb =
+            build_encoder_graph(cc->compute_ctx, cm->weights, cm->hparams, frames_per_chunk, cc->encoder_use_flash);
+        if (eb.graph == nullptr || eb.out == nullptr) {
+            return TRANSCRIBE_ERR_GGUF;
+        }
 
         ggml_backend_sched_reset(cc->sched);
         if (!ggml_backend_sched_alloc_graph(cc->sched, eb.graph)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "voxtral run: encoder graph allocation failed — out of memory.");
+                                "voxtral run: encoder graph allocation failed — out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
 
@@ -636,15 +631,11 @@ transcribe_status run(
                     cc->mel_buf[static_cast<size_t>(mm) * mel_n_frames + tg];
             }
         }
-        ggml_backend_tensor_set(eb.mel_in, chunk_mel.data(), 0,
-                                chunk_mel.size() * sizeof(float));
+        ggml_backend_tensor_set(eb.mel_in, chunk_mel.data(), 0, chunk_mel.size() * sizeof(float));
         set_sched_threads(cc->sched, cc->n_threads);
 
-        if (const ggml_status gs = ggml_backend_sched_graph_compute(cc->sched, eb.graph);
-            gs != GGML_STATUS_SUCCESS)
-        {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral run: encoder compute failed (%d)",
-                         static_cast<int>(gs));
+        if (const ggml_status gs = ggml_backend_sched_graph_compute(cc->sched, eb.graph); gs != GGML_STATUS_SUCCESS) {
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral run: encoder compute failed (%d)", static_cast<int>(gs));
             return TRANSCRIBE_ERR_GGUF;
         }
 
@@ -655,30 +646,36 @@ transcribe_status run(
                 std::snprintf(nm, sizeof(nm), "enc.block.%zu.out", i);
                 transcribe::debug::dump_tensor(nm, eb.dumps.block_outs[i], "enc.block");
             }
-            if (eb.dumps.enc_out)  transcribe::debug::dump_tensor("enc.out",  eb.dumps.enc_out,  "enc");
-            if (eb.dumps.proj_out) transcribe::debug::dump_tensor("proj.out", eb.dumps.proj_out, "proj");
+            if (eb.dumps.enc_out) {
+                transcribe::debug::dump_tensor("enc.out", eb.dumps.enc_out, "enc");
+            }
+            if (eb.dumps.proj_out) {
+                transcribe::debug::dump_tensor("proj.out", eb.dumps.proj_out, "proj");
+            }
         }
 
         // Read proj.out [dec_h, audio_per_chunk] into the chunk's slot.
-        ggml_backend_tensor_get(
-            eb.out,
-            cc->enc_host.data() + static_cast<size_t>(c) * audio_per_chunk * dec_h,
-            0, static_cast<size_t>(audio_per_chunk) * dec_h * sizeof(float));
+        ggml_backend_tensor_get(eb.out, cc->enc_host.data() + static_cast<size_t>(c) * audio_per_chunk * dec_h, 0,
+                                static_cast<size_t>(audio_per_chunk) * dec_h * sizeof(float));
     }
     cc->t_encode_us = ggml_time_us() - t_enc_start;
 
     // ----- Prompt construction -----
     std::vector<int32_t> prompt_ids;
-    int prefix_len = 0, suffix_len = 0;
+    int                  prefix_len = 0, suffix_len = 0;
     if (translate) {
-        if (const transcribe_status st = build_instruct_prompt(
-                *cm, instruction, n_audio_total, prompt_ids, prefix_len, suffix_len);
-            st != TRANSCRIBE_OK) return st;
+        if (const transcribe_status st =
+                build_instruct_prompt(*cm, instruction, n_audio_total, prompt_ids, prefix_len, suffix_len);
+            st != TRANSCRIBE_OK) {
+            return st;
+        }
     } else {
         const char * lang = (params != nullptr) ? params->language : nullptr;
-        if (const transcribe_status st = build_transcription_prompt(
-                *cm, lang, n_audio_total, prompt_ids, prefix_len, suffix_len);
-            st != TRANSCRIBE_OK) return st;
+        if (const transcribe_status st =
+                build_transcription_prompt(*cm, lang, n_audio_total, prompt_ids, prefix_len, suffix_len);
+            st != TRANSCRIBE_OK) {
+            return st;
+        }
     }
     const int T_prompt = static_cast<int>(prompt_ids.size());
 
@@ -690,95 +687,93 @@ transcribe_status run(
     // raised).
     const int model_max = voxtral_context_ceiling(cc->n_ctx, cm->hparams);
     if (T_prompt + k_gen_reserve > model_max) {
-        transcribe::log_msg(
-            TRANSCRIBE_LOG_LEVEL_ERROR,
-            "voxtral run: input too long — %d audio tokens + %d prompt exceed "
-            "the %d-token context (need %d incl. generation reserve). Shorten "
-            "the audio (see transcribe_capabilities.max_audio_ms) or split it "
-            "into segments.",
-            n_audio_total, T_prompt - n_audio_total, model_max,
-            T_prompt + k_gen_reserve);
+        transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
+                            "voxtral run: input too long — %d audio tokens + %d prompt exceed "
+                            "the %d-token context (need %d incl. generation reserve). Shorten "
+                            "the audio (see transcribe_capabilities.max_audio_ms) or split it "
+                            "into segments.",
+                            n_audio_total, T_prompt - n_audio_total, model_max, T_prompt + k_gen_reserve);
         return TRANSCRIBE_ERR_INPUT_TOO_LONG;
     }
-    const int max_new = pick_decode_budget(n_audio_total, T_prompt, model_max);
+    const int max_new  = pick_decode_budget(n_audio_total, T_prompt, model_max);
     const int want_ctx = pick_kv_ctx(T_prompt + max_new, model_max);
     if (cc->kv_cache.n_ctx < want_ctx) {
-        const ggml_type kv_type = (cc->kv_type == TRANSCRIBE_KV_TYPE_F32)
-                                ? GGML_TYPE_F32 : GGML_TYPE_F16;
+        const ggml_type kv_type = (cc->kv_type == TRANSCRIBE_KV_TYPE_F32) ? GGML_TYPE_F32 : GGML_TYPE_F16;
         cc->kv_cache.free();
-        if (!transcribe::causal_lm::kv_init(
-                cc->kv_cache, cm->plan.primary, want_ctx,
-                cm->hparams.dec_n_kv_heads, cm->hparams.dec_head_dim,
-                cm->hparams.dec_n_layers, kv_type)) {
+        if (!transcribe::causal_lm::kv_init(cc->kv_cache, cm->plan.primary, want_ctx, cm->hparams.dec_n_kv_heads,
+                                            cm->hparams.dec_head_dim, cm->hparams.dec_n_layers, kv_type)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "voxtral run: KV cache allocation failed (grow to n_ctx=%d) — "
-                "out of memory. Lower transcribe_session_params.n_ctx or shorten "
-                "the audio.", want_ctx);
+                                "voxtral run: KV cache allocation failed (grow to n_ctx=%d) — "
+                                "out of memory. Lower transcribe_session_params.n_ctx or shorten "
+                                "the audio.",
+                                want_ctx);
             return TRANSCRIBE_ERR_OOM;
         }
     }
 
     // ----- KV reset -----
     const int64_t t_dec_start = ggml_time_us();
-    if (cc->kv_cache.buffer != nullptr) ggml_backend_buffer_clear(cc->kv_cache.buffer, 0);
-    cc->kv_cache.n = 0;
+    if (cc->kv_cache.buffer != nullptr) {
+        ggml_backend_buffer_clear(cc->kv_cache.buffer, 0);
+    }
+    cc->kv_cache.n    = 0;
     cc->kv_cache.head = 0;
 
     // ----- Prefill -----
     const bool dumps_on   = transcribe::debug::enabled();
     const bool slice_last = !dumps_on;
-    if (cc->compute_ctx != nullptr) { ggml_free(cc->compute_ctx); cc->compute_ctx = nullptr; }
+    if (cc->compute_ctx != nullptr) {
+        ggml_free(cc->compute_ctx);
+        cc->compute_ctx = nullptr;
+    }
     {
-        ggml_init_params ip {};
-        ip.mem_size = 64 * 1024 * 1024;
-        ip.no_alloc = true;
+        ggml_init_params ip{};
+        ip.mem_size     = 64 * 1024 * 1024;
+        ip.no_alloc     = true;
         cc->compute_ctx = ggml_init(ip);
         if (cc->compute_ctx == nullptr) {
-            transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "voxtral run: ggml_init (prefill) failed — out of memory.");
+            transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral run: ggml_init (prefill) failed — out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
     }
-    PrefillBuild pb = build_prefill_graph(
-        cc->compute_ctx, cm->weights, cm->hparams, cc->kv_cache,
-        T_prompt, n_audio_total, prefix_len, suffix_len,
-        cc->decoder_use_flash, slice_last);
-    if (pb.graph == nullptr || pb.out == nullptr) return TRANSCRIBE_ERR_GGUF;
+    PrefillBuild pb = build_prefill_graph(cc->compute_ctx, cm->weights, cm->hparams, cc->kv_cache, T_prompt,
+                                          n_audio_total, prefix_len, suffix_len, cc->decoder_use_flash, slice_last);
+    if (pb.graph == nullptr || pb.out == nullptr) {
+        return TRANSCRIBE_ERR_GGUF;
+    }
 
     ggml_backend_sched_reset(cc->sched);
     if (!ggml_backend_sched_alloc_graph(cc->sched, pb.graph)) {
         transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "voxtral run: prefill graph allocation failed — out of memory. "
-            "Lower transcribe_session_params.n_ctx or shorten the audio.");
+                            "voxtral run: prefill graph allocation failed — out of memory. "
+                            "Lower transcribe_session_params.n_ctx or shorten the audio.");
         return TRANSCRIBE_ERR_OOM;
     }
 
-    ggml_backend_tensor_set(pb.input_ids_in, prompt_ids.data(),
-                            0, prompt_ids.size() * sizeof(int32_t));
-    ggml_backend_tensor_set(pb.enc_out_in, cc->enc_host.data(),
-                            0, cc->enc_host.size() * sizeof(float));
+    ggml_backend_tensor_set(pb.input_ids_in, prompt_ids.data(), 0, prompt_ids.size() * sizeof(int32_t));
+    ggml_backend_tensor_set(pb.enc_out_in, cc->enc_host.data(), 0, cc->enc_host.size() * sizeof(float));
     {
         std::vector<int32_t> positions(T_prompt);
-        for (int i = 0; i < T_prompt; ++i) positions[i] = i;
-        ggml_backend_tensor_set(pb.positions_in, positions.data(),
-                                0, positions.size() * sizeof(int32_t));
+        for (int i = 0; i < T_prompt; ++i) {
+            positions[i] = i;
+        }
+        ggml_backend_tensor_set(pb.positions_in, positions.data(), 0, positions.size() * sizeof(int32_t));
     }
     {
-        const ggml_fp16_t mz = ggml_fp32_to_fp16(0.0f);
-        const ggml_fp16_t mn = ggml_fp32_to_fp16(-INFINITY);
+        const ggml_fp16_t        mz = ggml_fp32_to_fp16(0.0f);
+        const ggml_fp16_t        mn = ggml_fp32_to_fp16(-INFINITY);
         std::vector<ggml_fp16_t> mask(static_cast<size_t>(T_prompt) * T_prompt, mn);
-        for (int r = 0; r < T_prompt; ++r)
-            for (int col = 0; col <= r; ++col)
+        for (int r = 0; r < T_prompt; ++r) {
+            for (int col = 0; col <= r; ++col) {
                 mask[static_cast<size_t>(r) * T_prompt + col] = mz;
+            }
+        }
         ggml_backend_tensor_set(pb.mask_in, mask.data(), 0, mask.size() * sizeof(ggml_fp16_t));
     }
     set_sched_threads(cc->sched, cc->n_threads);
 
-    if (const ggml_status gs = ggml_backend_sched_graph_compute(cc->sched, pb.graph);
-        gs != GGML_STATUS_SUCCESS)
-    {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral run: prefill compute failed (%d)",
-                     static_cast<int>(gs));
+    if (const ggml_status gs = ggml_backend_sched_graph_compute(cc->sched, pb.graph); gs != GGML_STATUS_SUCCESS) {
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral run: prefill compute failed (%d)", static_cast<int>(gs));
         return TRANSCRIBE_ERR_GGUF;
     }
     cc->kv_cache.n    = T_prompt;
@@ -786,11 +781,13 @@ transcribe_status run(
 
     if (dumps_on) {
         auto try_dump = [](const char * name, ggml_tensor * t, const char * stage) {
-            if (t != nullptr) transcribe::debug::dump_tensor(name, t, stage);
+            if (t != nullptr) {
+                transcribe::debug::dump_tensor(name, t, stage);
+            }
         };
-        try_dump("dec.token_emb",       pb.dumps.token_emb,       "dec.token_emb");
-        try_dump("dec.audio_injected",  pb.dumps.audio_injected,  "dec.audio_injected");
-        try_dump("dec.block.0.out",     pb.dumps.block_0_out,     "dec.block.0");
+        try_dump("dec.token_emb", pb.dumps.token_emb, "dec.token_emb");
+        try_dump("dec.audio_injected", pb.dumps.audio_injected, "dec.audio_injected");
+        try_dump("dec.block.0.out", pb.dumps.block_0_out, "dec.block.0");
         {
             char nm[64];
             std::snprintf(nm, sizeof(nm), "dec.block.%d.out", cm->hparams.dec_n_layers / 2);
@@ -802,63 +799,75 @@ transcribe_status run(
             try_dump(nm, pb.dumps.block_last_out, "dec.block.last");
         }
         try_dump("dec.out_before_head", pb.dumps.out_before_head, "dec.out_before_head");
-        try_dump("dec.logits_raw",      pb.dumps.logits_raw,      "dec.logits_raw");
+        try_dump("dec.logits_raw", pb.dumps.logits_raw, "dec.logits_raw");
     }
 
     // ----- First token (argmax of prefill logits) -----
-    const int vocab = cm->hparams.dec_vocab_size;
+    const int          vocab = cm->hparams.dec_vocab_size;
     std::vector<float> logits(vocab);
     ggml_backend_tensor_get(pb.out, logits.data(), 0, logits.size() * sizeof(float));
     auto argmax = [&](const std::vector<float> & v) -> int32_t {
-        int32_t best = 0; float best_v = v[0];
-        for (int32_t i = 1; i < static_cast<int32_t>(v.size()); ++i)
-            if (v[i] > best_v) { best_v = v[i]; best = i; }
+        int32_t best   = 0;
+        float   best_v = v[0];
+        for (int32_t i = 1; i < static_cast<int32_t>(v.size()); ++i) {
+            if (v[i] > best_v) {
+                best_v = v[i];
+                best   = i;
+            }
+        }
         return best;
     };
     std::vector<int32_t> generated_ids;
-    int32_t next_tok = argmax(logits);
+    int32_t              next_tok = argmax(logits);
     generated_ids.push_back(next_tok);
 
     // ----- Step loop -----
-    const int32_t eos_id = cm->hparams.eos_token_id;
-    int cur_past = T_prompt;
+    const int32_t eos_id   = cm->hparams.eos_token_id;
+    int           cur_past = T_prompt;
 
     int max_n_kv = 1024;
-    while (max_n_kv < T_prompt + max_new) max_n_kv *= 2;
-    if (max_n_kv > cc->kv_cache.n_ctx) max_n_kv = cc->kv_cache.n_ctx;
+    while (max_n_kv < T_prompt + max_new) {
+        max_n_kv *= 2;
+    }
+    if (max_n_kv > cc->kv_cache.n_ctx) {
+        max_n_kv = cc->kv_cache.n_ctx;
+    }
 
-    if (cc->compute_ctx != nullptr) { ggml_free(cc->compute_ctx); cc->compute_ctx = nullptr; }
+    if (cc->compute_ctx != nullptr) {
+        ggml_free(cc->compute_ctx);
+        cc->compute_ctx = nullptr;
+    }
     {
-        ggml_init_params ip {};
-        ip.mem_size = 16 * 1024 * 1024;
-        ip.no_alloc = true;
+        ggml_init_params ip{};
+        ip.mem_size     = 16 * 1024 * 1024;
+        ip.no_alloc     = true;
         cc->compute_ctx = ggml_init(ip);
         if (cc->compute_ctx == nullptr) {
-            transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "voxtral run: ggml_init (step) failed — out of memory.");
+            transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral run: ggml_init (step) failed — out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
     }
-    StepBuild sb = build_step_graph(cc->compute_ctx, cm->weights, cm->hparams,
-                                    cc->kv_cache, max_n_kv, cc->decoder_use_flash);
-    if (sb.graph == nullptr || sb.out == nullptr) return TRANSCRIBE_ERR_GGUF;
+    StepBuild sb =
+        build_step_graph(cc->compute_ctx, cm->weights, cm->hparams, cc->kv_cache, max_n_kv, cc->decoder_use_flash);
+    if (sb.graph == nullptr || sb.out == nullptr) {
+        return TRANSCRIBE_ERR_GGUF;
+    }
     ggml_backend_sched_reset(cc->sched);
     if (!ggml_backend_sched_alloc_graph(cc->sched, sb.graph)) {
         transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "voxtral run: step graph allocation failed — out of memory. "
-            "Lower transcribe_session_params.n_ctx or shorten the audio.");
+                            "voxtral run: step graph allocation failed — out of memory. "
+                            "Lower transcribe_session_params.n_ctx or shorten the audio.");
         return TRANSCRIBE_ERR_OOM;
     }
     set_sched_threads(cc->sched, cc->n_threads);
 
-    const ggml_fp16_t mz = ggml_fp32_to_fp16(0.0f);
-    const ggml_fp16_t mn = ggml_fp32_to_fp16(-INFINITY);
+    const ggml_fp16_t        mz = ggml_fp32_to_fp16(0.0f);
+    const ggml_fp16_t        mn = ggml_fp32_to_fp16(-INFINITY);
     std::vector<ggml_fp16_t> step_mask(max_n_kv, mn);
-    while (next_tok != eos_id &&
-           static_cast<int32_t>(generated_ids.size()) < max_new &&
-           cur_past + 1 <= max_n_kv)
-    {
-        if (cc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
+    while (next_tok != eos_id && static_cast<int32_t>(generated_ids.size()) < max_new && cur_past + 1 <= max_n_kv) {
+        if (cc->poll_abort()) {
+            return TRANSCRIBE_ERR_ABORTED;
+        }
         ggml_backend_tensor_set(sb.input_id_in, &next_tok, 0, sizeof(int32_t));
         const int32_t pos_val = cur_past;
         ggml_backend_tensor_set(sb.position_in, &pos_val, 0, sizeof(int32_t));
@@ -869,14 +878,10 @@ transcribe_status run(
         } else {
             step_mask[cur_past] = mz;
         }
-        ggml_backend_tensor_set(sb.mask_in, step_mask.data(), 0,
-                                static_cast<size_t>(max_n_kv) * sizeof(ggml_fp16_t));
+        ggml_backend_tensor_set(sb.mask_in, step_mask.data(), 0, static_cast<size_t>(max_n_kv) * sizeof(ggml_fp16_t));
 
-        if (const ggml_status gs = ggml_backend_sched_graph_compute(cc->sched, sb.graph);
-            gs != GGML_STATUS_SUCCESS)
-        {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral run: step compute failed (%d)",
-                         static_cast<int>(gs));
+        if (const ggml_status gs = ggml_backend_sched_graph_compute(cc->sched, sb.graph); gs != GGML_STATUS_SUCCESS) {
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral run: step compute failed (%d)", static_cast<int>(gs));
             return TRANSCRIBE_ERR_GGUF;
         }
         // Mid-generation logits dump: the step at cur_past == T_prompt + 7 is
@@ -899,35 +904,36 @@ transcribe_status run(
     // width (truncated). Surface the latter via transcribe_was_truncated() + WARN.
     if (next_tok != eos_id) {
         cc->was_truncated = true;
-        transcribe::log_msg(
-            TRANSCRIBE_LOG_LEVEL_WARN,
-            "voxtral run: output truncated at %d tokens — decode reached the "
-            "generation budget before end-of-stream; the transcript may be "
-            "incomplete.",
-            static_cast<int>(generated_ids.size()));
+        transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_WARN,
+                            "voxtral run: output truncated at %d tokens — decode reached the "
+                            "generation budget before end-of-stream; the transcript may be "
+                            "incomplete.",
+                            static_cast<int>(generated_ids.size()));
     }
 
     if (!generated_ids.empty() && generated_ids.back() == eos_id) {
         generated_ids.pop_back();
     }
 
-    std::string text = cm->tok.decode(
-        generated_ids.data(), static_cast<int>(generated_ids.size()));
+    std::string text = cm->tok.decode(generated_ids.data(), static_cast<int>(generated_ids.size()));
     // Trim leading/trailing whitespace (the assistant turn often starts
     // with a byte-level space token).
-    size_t b = 0, e = text.size();
-    while (b < e && std::isspace(static_cast<unsigned char>(text[b]))) ++b;
-    while (e > b && std::isspace(static_cast<unsigned char>(text[e - 1]))) --e;
+    size_t      b = 0, e = text.size();
+    while (b < e && std::isspace(static_cast<unsigned char>(text[b]))) {
+        ++b;
+    }
+    while (e > b && std::isspace(static_cast<unsigned char>(text[e - 1]))) {
+        --e;
+    }
     text = text.substr(b, e - b);
 
-    cc->full_text = text;
+    cc->full_text   = text;
     cc->result_kind = TRANSCRIBE_TIMESTAMPS_NONE;
     cc->has_result  = true;
-    transcribe_session::SegmentEntry seg {};
+    transcribe_session::SegmentEntry seg{};
     seg.text  = text;
     seg.t0_ms = 0;
-    seg.t1_ms = static_cast<int64_t>(n_samples) * 1000
-              / static_cast<int64_t>(cm->hparams.fe_sample_rate);
+    seg.t1_ms = static_cast<int64_t>(n_samples) * 1000 / static_cast<int64_t>(cm->hparams.fe_sample_rate);
     cc->segments.push_back(std::move(seg));
 
     // Output truncation is a hard status: the partial transcript stays readable
@@ -950,89 +956,88 @@ transcribe_status run_batch_serial(VoxtralSession *              cc,
                                    int                           n,
                                    const transcribe_run_params * params) {
     for (int i = 0; i < n; ++i) {
-        if (cc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
-        const transcribe_status st =
-            (pcm[i] == nullptr || n_samples[i] <= 0)
-                ? TRANSCRIBE_ERR_INVALID_ARG
-                : run(cc, pcm[i], n_samples[i], params);
-        if (st == TRANSCRIBE_OK) cc->batch_results.push_back(cc->capture_result(st));
-        else {
-            transcribe_session::ResultSet rs; rs.status = st;
+        if (cc->poll_abort()) {
+            return TRANSCRIBE_ERR_ABORTED;
+        }
+        const transcribe_status st = (pcm[i] == nullptr || n_samples[i] <= 0) ? TRANSCRIBE_ERR_INVALID_ARG :
+                                                                                run(cc, pcm[i], n_samples[i], params);
+        if (st == TRANSCRIBE_OK) {
+            cc->batch_results.push_back(cc->capture_result(st));
+        } else {
+            transcribe_session::ResultSet rs;
+            rs.status = st;
             cc->batch_results.push_back(std::move(rs));
         }
     }
     return TRANSCRIBE_OK;
 }
 
-transcribe_status run_batch(
-    transcribe_session *          session,
-    const float * const *         pcm,
-    const int *                   n_samples,
-    int                           n,
-    const transcribe_run_params * params)
-{
-    if (session == nullptr || pcm == nullptr || n_samples == nullptr || n <= 0)
+transcribe_status run_batch(transcribe_session *          session,
+                            const float * const *         pcm,
+                            const int *                   n_samples,
+                            int                           n,
+                            const transcribe_run_params * params) {
+    if (session == nullptr || pcm == nullptr || n_samples == nullptr || n <= 0) {
         return TRANSCRIBE_ERR_INVALID_ARG;
+    }
     auto * cc = static_cast<VoxtralSession *>(session);
     auto * cm = static_cast<VoxtralModel *>(cc->model);
-    if (cm == nullptr || cm->plan.scheduler_list.empty() || !cm->mel.has_value())
+    if (cm == nullptr || cm->plan.scheduler_list.empty() || !cm->mel.has_value()) {
         return TRANSCRIBE_ERR_INVALID_ARG;
+    }
 
     // The batched encoder + causal_lm batched blocks are flash-only; dump mode
     // and n==1 take the established single-shot path for byte-parity.
-    if (!cc->decoder_use_flash || !cc->encoder_use_flash ||
-        transcribe::debug::enabled() || n == 1)
+    if (!cc->decoder_use_flash || !cc->encoder_use_flash || transcribe::debug::enabled() || n == 1) {
         return run_batch_serial(cc, pcm, n_samples, n, params);
+    }
 
     transcribe::debug::init();
     const auto & hp = cm->hparams;
 
     // ----- Prompt mode (uniform across the batch) -----
-    const bool translate = (params != nullptr &&
-                            params->task == TRANSCRIBE_TASK_TRANSLATE);
+    const bool  translate = (params != nullptr && params->task == TRANSCRIBE_TASK_TRANSLATE);
     std::string instruction;
     if (translate) {
         const char * tgt = (params != nullptr) ? params->target_language : nullptr;
-        instruction = std::string("Translate this to ") + lang_name_for(tgt) + ".";
+        instruction      = std::string("Translate this to ") + lang_name_for(tgt) + ".";
     }
     const char * lang = (params != nullptr) ? params->language : nullptr;
 
     // ----- Chunk geometry -----
     int samples_per_chunk = hp.fe_n_samples;
     if (samples_per_chunk <= 0) {
-        samples_per_chunk = (hp.fe_chunk_length > 0 ? hp.fe_chunk_length : 30) *
-                            hp.fe_sample_rate;
+        samples_per_chunk = (hp.fe_chunk_length > 0 ? hp.fe_chunk_length : 30) * hp.fe_sample_rate;
     }
-    const int frames_per_chunk = (hp.fe_nb_max_frames > 0)
-        ? hp.fe_nb_max_frames
-        : samples_per_chunk / hp.fe_hop_length;
-    const int audio_per_chunk = hp.audio_tokens_per_chunk();
-    const int n_mels          = hp.enc_num_mel_bins;
-    const int dec_h           = hp.dec_hidden;
+    const int frames_per_chunk = (hp.fe_nb_max_frames > 0) ? hp.fe_nb_max_frames : samples_per_chunk / hp.fe_hop_length;
+    const int audio_per_chunk  = hp.audio_tokens_per_chunk();
+    const int n_mels           = hp.enc_num_mel_bins;
+    const int dec_h            = hp.dec_hidden;
 
     // ----- Pass 0: per-utterance chunking + parallel mel -----
-    std::vector<char> valid(n, 0);
+    std::vector<char>               valid(n, 0);
     // Utterances rejected by the input-length gate below. Tracked separately
     // from `valid` so the result-capture pass can report the precise
     // TRANSCRIBE_ERR_INPUT_TOO_LONG status rather than a generic invalid-arg.
-    std::vector<char> over_length(n, 0);
-    std::vector<int>  n_chunks(n, 0);
+    std::vector<char>               over_length(n, 0);
+    std::vector<int>                n_chunks(n, 0);
     std::vector<std::vector<float>> mel_bufs(n);
-    std::vector<int>  mel_nf(n, 0);
+    std::vector<int>                mel_nf(n, 0);
 
     int n_mel_threads = cc->n_threads;
-    if (n_mel_threads <= 0)
+    if (n_mel_threads <= 0) {
         n_mel_threads = transcribe::default_n_threads();
+    }
 
     const int64_t t_mel0 = ggml_time_us();
     transcribe::parallel_for_all(n, n_mel_threads, [&](int b) {
-        if (pcm[b] == nullptr || n_samples[b] <= 0) return true;
-        const int nc = std::max(1,
-            (n_samples[b] + samples_per_chunk - 1) / samples_per_chunk);
-        const size_t padded = static_cast<size_t>(nc) * samples_per_chunk;
+        if (pcm[b] == nullptr || n_samples[b] <= 0) {
+            return true;
+        }
+        const int          nc     = std::max(1, (n_samples[b] + samples_per_chunk - 1) / samples_per_chunk);
+        const size_t       padded = static_cast<size_t>(nc) * samples_per_chunk;
         std::vector<float> pcm_padded(padded, 0.0f);
-        std::memcpy(pcm_padded.data(), pcm[b],
-                    static_cast<size_t>(n_samples[b]) * sizeof(float));
+        std::memcpy(pcm_padded.data(), pcm[b], static_cast<size_t>(n_samples[b]) * sizeof(float));
         int nm = 0, nf = 0;
         if (cm->mel->compute(pcm_padded.data(), padded, mel_bufs[b], nm, nf,
                              /*n_threads=*/1) == TRANSCRIBE_OK &&
@@ -1047,7 +1052,9 @@ transcribe_status run_batch(
     // Map global chunk index -> (utterance, local chunk).
     std::vector<int> chunk_owner, chunk_local;
     for (int b = 0; b < n; ++b) {
-        if (n_chunks[b] <= 0) continue;
+        if (n_chunks[b] <= 0) {
+            continue;
+        }
         valid[b] = 1;
         for (int lc = 0; lc < n_chunks[b]; ++lc) {
             chunk_owner.push_back(b);
@@ -1057,7 +1064,8 @@ transcribe_status run_batch(
     const int total_chunks = static_cast<int>(chunk_owner.size());
     if (total_chunks == 0) {
         for (int b = 0; b < n; ++b) {
-            transcribe_session::ResultSet rs; rs.status = TRANSCRIBE_ERR_INVALID_ARG;
+            transcribe_session::ResultSet rs;
+            rs.status = TRANSCRIBE_ERR_INVALID_ARG;
             cc->batch_results.push_back(std::move(rs));
         }
         return TRANSCRIBE_OK;
@@ -1065,80 +1073,84 @@ transcribe_status run_batch(
 
     // Lazy scheduler (shared with the single-shot path).
     if (cc->sched == nullptr) {
-        cc->sched = ggml_backend_sched_new(
-            cm->plan.scheduler_list.data(), nullptr,
-            static_cast<int>(cm->plan.scheduler_list.size()), 16384, false, true);
-        if (cc->sched == nullptr) return TRANSCRIBE_ERR_GGUF;
+        cc->sched = ggml_backend_sched_new(cm->plan.scheduler_list.data(), nullptr,
+                                           static_cast<int>(cm->plan.scheduler_list.size()), 16384, false, true);
+        if (cc->sched == nullptr) {
+            return TRANSCRIBE_ERR_GGUF;
+        }
     }
 
     // ----- Pass 1: batched encoder over all chunks -----
     std::vector<std::vector<float>> enc_hosts(n);
-    for (int b = 0; b < n; ++b)
-        if (valid[b])
+    for (int b = 0; b < n; ++b) {
+        if (valid[b]) {
             enc_hosts[b].assign(static_cast<size_t>(dec_h) * n_chunks[b] * audio_per_chunk, 0.0f);
+        }
+    }
 
     int64_t enc_us = 0;
     {
         // Frame-major mel slab [n_mels, frames_per_chunk, total_chunks]:
         // slab[(gc*FPC + t)*n_mels + m] = mel_bufs[b][m*mel_nf[b] + lc*FPC + t].
-        std::vector<float> slab(
-            static_cast<size_t>(n_mels) * frames_per_chunk * total_chunks, 0.0f);
+        std::vector<float> slab(static_cast<size_t>(n_mels) * frames_per_chunk * total_chunks, 0.0f);
         for (int gc = 0; gc < total_chunks; ++gc) {
-            const int b  = chunk_owner[gc];
-            const int lc = chunk_local[gc];
+            const int     b   = chunk_owner[gc];
+            const int     lc  = chunk_local[gc];
             const float * src = mel_bufs[b].data();
-            const int nf = mel_nf[b];
+            const int     nf  = mel_nf[b];
             for (int t = 0; t < frames_per_chunk; ++t) {
-                const size_t dst_base =
-                    (static_cast<size_t>(gc) * frames_per_chunk + t) * n_mels;
-                const int gframe = lc * frames_per_chunk + t;
-                for (int m = 0; m < n_mels; ++m)
+                const size_t dst_base = (static_cast<size_t>(gc) * frames_per_chunk + t) * n_mels;
+                const int    gframe   = lc * frames_per_chunk + t;
+                for (int m = 0; m < n_mels; ++m) {
                     slab[dst_base + m] = src[static_cast<size_t>(m) * nf + gframe];
+                }
             }
         }
 
-        if (cc->compute_ctx != nullptr) { ggml_free(cc->compute_ctx); cc->compute_ctx = nullptr; }
-        ggml_init_params ip {};
-        ip.mem_size = 64 * 1024 * 1024;
-        ip.no_alloc = true;
+        if (cc->compute_ctx != nullptr) {
+            ggml_free(cc->compute_ctx);
+            cc->compute_ctx = nullptr;
+        }
+        ggml_init_params ip{};
+        ip.mem_size     = 64 * 1024 * 1024;
+        ip.no_alloc     = true;
         cc->compute_ctx = ggml_init(ip);
         if (cc->compute_ctx == nullptr) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "voxtral run_batch: ggml_init (encoder) failed — out of memory.");
+                                "voxtral run_batch: ggml_init (encoder) failed — out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
 
-        EncoderBuild eb = build_encoder_graph_batched(
-            cc->compute_ctx, cm->weights, hp, frames_per_chunk, total_chunks,
-            cc->encoder_use_flash);
-        if (eb.graph == nullptr || eb.out == nullptr) return TRANSCRIBE_ERR_GGUF;
+        EncoderBuild eb = build_encoder_graph_batched(cc->compute_ctx, cm->weights, hp, frames_per_chunk, total_chunks,
+                                                      cc->encoder_use_flash);
+        if (eb.graph == nullptr || eb.out == nullptr) {
+            return TRANSCRIBE_ERR_GGUF;
+        }
 
         ggml_backend_sched_reset(cc->sched);
         if (!ggml_backend_sched_alloc_graph(cc->sched, eb.graph)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "voxtral run_batch: encoder graph allocation failed — out of memory.");
+                                "voxtral run_batch: encoder graph allocation failed — out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
         ggml_backend_tensor_set(eb.mel_in, slab.data(), 0, slab.size() * sizeof(float));
         set_sched_threads(cc->sched, cc->n_threads);
 
         const int64_t t_enc0 = ggml_time_us();
-        if (ggml_backend_sched_graph_compute(cc->sched, eb.graph) != GGML_STATUS_SUCCESS)
+        if (ggml_backend_sched_graph_compute(cc->sched, eb.graph) != GGML_STATUS_SUCCESS) {
             return TRANSCRIBE_ERR_GGUF;
+        }
         enc_us = ggml_time_us() - t_enc0;
 
         // proj.out [dec_h, audio_per_chunk, total_chunks] -> per-utterance host.
-        std::vector<float> proj_host(
-            static_cast<size_t>(dec_h) * audio_per_chunk * total_chunks);
-        ggml_backend_tensor_get(eb.out, proj_host.data(), 0,
-                                proj_host.size() * sizeof(float));
+        std::vector<float> proj_host(static_cast<size_t>(dec_h) * audio_per_chunk * total_chunks);
+        ggml_backend_tensor_get(eb.out, proj_host.data(), 0, proj_host.size() * sizeof(float));
         const size_t chunk_elems = static_cast<size_t>(dec_h) * audio_per_chunk;
         for (int gc = 0; gc < total_chunks; ++gc) {
             const int b  = chunk_owner[gc];
             const int lc = chunk_local[gc];
             std::memcpy(enc_hosts[b].data() + static_cast<size_t>(lc) * chunk_elems,
-                        proj_host.data() + static_cast<size_t>(gc) * chunk_elems,
-                        chunk_elems * sizeof(float));
+                        proj_host.data() + static_cast<size_t>(gc) * chunk_elems, chunk_elems * sizeof(float));
         }
     }
 
@@ -1148,46 +1160,53 @@ transcribe_status run_batch(
     // (the trained max, lowered by the caller's n_ctx knob). An over-length
     // utterance is dropped from the batch and flagged so its captured result
     // carries TRANSCRIBE_ERR_INPUT_TOO_LONG.
-    const int ctx_ceiling = voxtral_context_ceiling(cc->n_ctx, hp);
+    const int                         ctx_ceiling = voxtral_context_ceiling(cc->n_ctx, hp);
     std::vector<std::vector<int32_t>> prompt_ids(n);
-    std::vector<int> T_prompt(n, 0), T_audio(n, 0);
-    int prefix_len = 0, suffix_len = 0;
+    std::vector<int>                  T_prompt(n, 0), T_audio(n, 0);
+    int                               prefix_len = 0, suffix_len = 0;
     for (int b = 0; b < n; ++b) {
-        if (!valid[b]) continue;
-        const int n_audio = n_chunks[b] * audio_per_chunk;
-        int pfx = 0, sfx = 0;
-        const transcribe_status st = translate
-            ? build_instruct_prompt(*cm, instruction, n_audio, prompt_ids[b], pfx, sfx)
-            : build_transcription_prompt(*cm, lang, n_audio, prompt_ids[b], pfx, sfx);
-        if (st != TRANSCRIBE_OK) { valid[b] = 0; continue; }
+        if (!valid[b]) {
+            continue;
+        }
+        const int               n_audio = n_chunks[b] * audio_per_chunk;
+        int                     pfx = 0, sfx = 0;
+        const transcribe_status st = translate ?
+                                         build_instruct_prompt(*cm, instruction, n_audio, prompt_ids[b], pfx, sfx) :
+                                         build_transcription_prompt(*cm, lang, n_audio, prompt_ids[b], pfx, sfx);
+        if (st != TRANSCRIBE_OK) {
+            valid[b] = 0;
+            continue;
+        }
         const int t_prompt = static_cast<int>(prompt_ids[b].size());
         if (t_prompt + k_gen_reserve > ctx_ceiling) {
-            transcribe::log_msg(
-                TRANSCRIBE_LOG_LEVEL_ERROR,
-                "voxtral run_batch: utterance %d input too long — %d audio "
-                "tokens + %d prompt exceed the %d-token context (need %d incl. "
-                "generation reserve). Shorten the audio (see "
-                "transcribe_capabilities.max_audio_ms) or split it into "
-                "segments.",
-                b, n_audio, t_prompt - n_audio, ctx_ceiling,
-                t_prompt + k_gen_reserve);
-            valid[b] = 0; over_length[b] = 1; continue;
-        }
-        prefix_len = pfx; suffix_len = sfx;  // uniform across the batch
+            transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
+                                "voxtral run_batch: utterance %d input too long — %d audio "
+                                "tokens + %d prompt exceed the %d-token context (need %d incl. "
+                                "generation reserve). Shorten the audio (see "
+                                "transcribe_capabilities.max_audio_ms) or split it into "
+                                "segments.",
+                                b, n_audio, t_prompt - n_audio, ctx_ceiling, t_prompt + k_gen_reserve);
+            valid[b]       = 0;
+            over_length[b] = 1;
+            continue;
+        }
+        prefix_len  = pfx;
+        suffix_len  = sfx;  // uniform across the batch
         T_prompt[b] = t_prompt;
         T_audio[b]  = n_audio;
     }
 
     int max_T_prompt = 0, T_audio_max = 0;
-    for (int b = 0; b < n; ++b) if (valid[b]) {
-        max_T_prompt = std::max(max_T_prompt, T_prompt[b]);
-        T_audio_max  = std::max(T_audio_max, T_audio[b]);
+    for (int b = 0; b < n; ++b) {
+        if (valid[b]) {
+            max_T_prompt = std::max(max_T_prompt, T_prompt[b]);
+            T_audio_max  = std::max(T_audio_max, T_audio[b]);
+        }
     }
     if (max_T_prompt == 0) {
         for (int b = 0; b < n; ++b) {
             transcribe_session::ResultSet rs;
-            rs.status = over_length[b] ? TRANSCRIBE_ERR_INPUT_TOO_LONG
-                                       : TRANSCRIBE_ERR_INVALID_ARG;
+            rs.status = over_length[b] ? TRANSCRIBE_ERR_INPUT_TOO_LONG : TRANSCRIBE_ERR_INVALID_ARG;
             cc->batch_results.push_back(std::move(rs));
         }
         return TRANSCRIBE_OK;
@@ -1197,56 +1216,62 @@ transcribe_status run_batch(
     // Size the batched KV cache to the longest prompt plus the decode budget,
     // clamped to the context ceiling. kv_init_batched grows the cache on demand.
     const int model_max = ctx_ceiling;
-    const int max_new = pick_decode_budget(T_audio_max, max_T_prompt, model_max);
-    int max_n_kv = 1024;
-    while (max_n_kv < max_T_prompt + max_new) max_n_kv *= 2;
-    if (max_n_kv > model_max) max_n_kv = model_max;
+    const int max_new   = pick_decode_budget(T_audio_max, max_T_prompt, model_max);
+    int       max_n_kv  = 1024;
+    while (max_n_kv < max_T_prompt + max_new) {
+        max_n_kv *= 2;
+    }
+    if (max_n_kv > model_max) {
+        max_n_kv = model_max;
+    }
 
     // ----- Batched KV cache (reused; re-alloc only on growth) -----
-    ggml_type kv_type = (cc->kv_type == TRANSCRIBE_KV_TYPE_F32)
-                      ? GGML_TYPE_F32 : GGML_TYPE_F16;
-    if (cc->kv_cache_batch.self_k == nullptr ||
-        cc->kv_batch_cap != n || cc->kv_batch_n_ctx != max_n_kv) {
+    ggml_type kv_type = (cc->kv_type == TRANSCRIBE_KV_TYPE_F32) ? GGML_TYPE_F32 : GGML_TYPE_F16;
+    if (cc->kv_cache_batch.self_k == nullptr || cc->kv_batch_cap != n || cc->kv_batch_n_ctx != max_n_kv) {
         cc->kv_cache_batch.free();
-        if (!transcribe::causal_lm::kv_init_batched(
-                cc->kv_cache_batch, cm->plan.primary, max_n_kv,
-                hp.dec_n_kv_heads, hp.dec_head_dim, hp.dec_n_layers, n, kv_type)) {
+        if (!transcribe::causal_lm::kv_init_batched(cc->kv_cache_batch, cm->plan.primary, max_n_kv, hp.dec_n_kv_heads,
+                                                    hp.dec_head_dim, hp.dec_n_layers, n, kv_type)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "voxtral run_batch: batched KV cache allocation failed — "
-                "out of memory. Lower transcribe_session_params.n_ctx or "
-                "shorten the audio.");
+                                "voxtral run_batch: batched KV cache allocation failed — "
+                                "out of memory. Lower transcribe_session_params.n_ctx or "
+                                "shorten the audio.");
             return TRANSCRIBE_ERR_OOM;
         }
-        cc->kv_batch_cap = n; cc->kv_batch_n_ctx = max_n_kv;
+        cc->kv_batch_cap   = n;
+        cc->kv_batch_n_ctx = max_n_kv;
     } else if (cc->kv_cache_batch.buffer != nullptr) {
         ggml_backend_buffer_clear(cc->kv_cache_batch.buffer, 0);
     }
 
     // ----- Pass 2: batched prefill -----
-    std::vector<int32_t> next_tok(n, 0);
-    std::vector<int> n_past(n, 0);
+    std::vector<int32_t>              next_tok(n, 0);
+    std::vector<int>                  n_past(n, 0);
     std::vector<std::vector<int32_t>> generated(n);
-    int64_t dec_us = 0;
+    int64_t                           dec_us = 0;
     {
-        if (cc->compute_ctx != nullptr) { ggml_free(cc->compute_ctx); cc->compute_ctx = nullptr; }
-        ggml_init_params ip {};
-        ip.mem_size = 64 * 1024 * 1024;
-        ip.no_alloc = true;
+        if (cc->compute_ctx != nullptr) {
+            ggml_free(cc->compute_ctx);
+            cc->compute_ctx = nullptr;
+        }
+        ggml_init_params ip{};
+        ip.mem_size     = 64 * 1024 * 1024;
+        ip.no_alloc     = true;
         cc->compute_ctx = ggml_init(ip);
         if (cc->compute_ctx == nullptr) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "voxtral run_batch: ggml_init (prefill) failed — out of memory.");
+                                "voxtral run_batch: ggml_init (prefill) failed — out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
 
-        PrefillBuildBatched pb = build_prefill_graph_batched(
-            cc->compute_ctx, cm->weights, hp, cc->kv_cache_batch,
-            max_T_prompt, T_audio_max, n, cc->decoder_use_flash);
-        if (pb.graph == nullptr || pb.out == nullptr) return TRANSCRIBE_ERR_GGUF;
+        PrefillBuildBatched pb = build_prefill_graph_batched(cc->compute_ctx, cm->weights, hp, cc->kv_cache_batch,
+                                                             max_T_prompt, T_audio_max, n, cc->decoder_use_flash);
+        if (pb.graph == nullptr || pb.out == nullptr) {
+            return TRANSCRIBE_ERR_GGUF;
+        }
         ggml_backend_sched_reset(cc->sched);
         if (!ggml_backend_sched_alloc_graph(cc->sched, pb.graph)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "voxtral run_batch: prefill graph allocation failed — out of memory.");
+                                "voxtral run_batch: prefill graph allocation failed — out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
 
@@ -1262,22 +1287,21 @@ transcribe_status run_batch(
             const int ta = valid[b] ? T_audio[b] : 0;
             const int tp = valid[b] ? T_prompt[b] : 0;
             if (valid[b]) {
-                std::memcpy(ids.data() + static_cast<size_t>(b) * max_T_prompt,
-                            prompt_ids[b].data(),
+                std::memcpy(ids.data() + static_cast<size_t>(b) * max_T_prompt, prompt_ids[b].data(),
                             static_cast<size_t>(tp) * sizeof(int32_t));
                 // enc_hosts[b] is [dec_h, ta] column-major; audio token j lands
                 // at prompt position prefix_len+j, flat column b*max_T_prompt+pos.
                 for (int j = 0; j < ta; ++j) {
-                    const size_t dst_col =
-                        static_cast<size_t>(b) * max_T_prompt + (prefix_len + j);
+                    const size_t dst_col = static_cast<size_t>(b) * max_T_prompt + (prefix_len + j);
                     std::memcpy(audio_dense.data() + dst_col * dec_h,
                                 enc_hosts[b].data() + static_cast<size_t>(j) * dec_h,
                                 static_cast<size_t>(dec_h) * sizeof(float));
                     keep[dst_col] = 0.0f;
                 }
             }
-            for (int t = 0; t < max_T_prompt; ++t)
+            for (int t = 0; t < max_T_prompt; ++t) {
                 kidx[static_cast<size_t>(b) * max_T_prompt + t] = t;
+            }
             lidx[b] = valid[b] ? (tp - 1) : 0;
         }
         ggml_backend_tensor_set(pb.input_ids_in, ids.data(), 0, ids.size() * sizeof(int32_t));
@@ -1285,16 +1309,19 @@ transcribe_status run_batch(
         ggml_backend_tensor_set(pb.keep_mask_in, keep.data(), 0, keep.size() * sizeof(float));
         {
             std::vector<int32_t> pos(max_T_prompt);
-            for (int t = 0; t < max_T_prompt; ++t) pos[t] = t;
+            for (int t = 0; t < max_T_prompt; ++t) {
+                pos[t] = t;
+            }
             ggml_backend_tensor_set(pb.positions_in, pos.data(), 0, pos.size() * sizeof(int32_t));
         }
         {
-            const ggml_fp16_t mz = ggml_fp32_to_fp16(0.0f);
-            const ggml_fp16_t mn = ggml_fp32_to_fp16(-INFINITY);
+            const ggml_fp16_t        mz = ggml_fp32_to_fp16(0.0f);
+            const ggml_fp16_t        mn = ggml_fp32_to_fp16(-INFINITY);
             std::vector<ggml_fp16_t> mask(static_cast<size_t>(max_T_prompt) * max_T_prompt, mn);
-            for (int q = 0; q < max_T_prompt; ++q)
+            for (int q = 0; q < max_T_prompt; ++q) {
                 std::fill(mask.begin() + static_cast<size_t>(q) * max_T_prompt,
                           mask.begin() + static_cast<size_t>(q) * max_T_prompt + q + 1, mz);
+            }
             ggml_backend_tensor_set(pb.mask_in, mask.data(), 0, mask.size() * sizeof(ggml_fp16_t));
         }
         ggml_backend_tensor_set(pb.kv_idx_in, kidx.data(), 0, kidx.size() * sizeof(int64_t));
@@ -1302,49 +1329,57 @@ transcribe_status run_batch(
         set_sched_threads(cc->sched, cc->n_threads);
 
         const int64_t t_dec0 = ggml_time_us();
-        if (ggml_backend_sched_graph_compute(cc->sched, pb.graph) != GGML_STATUS_SUCCESS)
+        if (ggml_backend_sched_graph_compute(cc->sched, pb.graph) != GGML_STATUS_SUCCESS) {
             return TRANSCRIBE_ERR_GGUF;
+        }
         dec_us += ggml_time_us() - t_dec0;
 
         std::vector<int32_t> amax(n, 0);
         ggml_backend_tensor_get(pb.out, amax.data(), 0, amax.size() * sizeof(int32_t));
         for (int b = 0; b < n; ++b) {
-            if (!valid[b]) continue;
-            n_past[b] = T_prompt[b]; next_tok[b] = amax[b];
+            if (!valid[b]) {
+                continue;
+            }
+            n_past[b]   = T_prompt[b];
+            next_tok[b] = amax[b];
             generated[b].push_back(amax[b]);
         }
     }
 
     // ----- Pass 3: batched greedy step loop (shared causal_lm driver) -----
-    const int32_t eos_id = hp.eos_token_id;
+    const int32_t     eos_id = hp.eos_token_id;
     // Per-utterance truncation flags from the step loop (consumed in the
     // result-capture pass below, outside this block's scope).
     std::vector<char> truncated;
     {
-        if (cc->compute_ctx != nullptr) { ggml_free(cc->compute_ctx); cc->compute_ctx = nullptr; }
-        ggml_init_params ip {};
-        ip.mem_size = 32 * 1024 * 1024;
-        ip.no_alloc = true;
+        if (cc->compute_ctx != nullptr) {
+            ggml_free(cc->compute_ctx);
+            cc->compute_ctx = nullptr;
+        }
+        ggml_init_params ip{};
+        ip.mem_size     = 32 * 1024 * 1024;
+        ip.no_alloc     = true;
         cc->compute_ctx = ggml_init(ip);
         if (cc->compute_ctx == nullptr) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "voxtral run_batch: ggml_init (step) failed — out of memory.");
+                                "voxtral run_batch: ggml_init (step) failed — out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
 
-        StepBuildBatched sb = build_step_graph_batched(
-            cc->compute_ctx, cm->weights, hp, cc->kv_cache_batch,
-            max_n_kv, n, cc->decoder_use_flash);
-        if (sb.graph == nullptr || sb.out == nullptr) return TRANSCRIBE_ERR_GGUF;
+        StepBuildBatched sb = build_step_graph_batched(cc->compute_ctx, cm->weights, hp, cc->kv_cache_batch, max_n_kv,
+                                                       n, cc->decoder_use_flash);
+        if (sb.graph == nullptr || sb.out == nullptr) {
+            return TRANSCRIBE_ERR_GGUF;
+        }
         ggml_backend_sched_reset(cc->sched);
         if (!ggml_backend_sched_alloc_graph(cc->sched, sb.graph)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "voxtral run_batch: step graph allocation failed — out of memory.");
+                                "voxtral run_batch: step graph allocation failed — out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
         set_sched_threads(cc->sched, cc->n_threads);
 
-        transcribe::causal_lm::StepBatchedIO io {};
+        transcribe::causal_lm::StepBatchedIO io{};
         io.input_ids = sb.input_ids_in;
         io.positions = sb.position_in;
         io.kv_idx    = sb.kv_idx_in;
@@ -1359,29 +1394,34 @@ transcribe_status run_batch(
 
         transcribe::causal_lm::StepLoopStats step_stats;
         if (const transcribe_status st = transcribe::causal_lm::run_batched_step_loop(
-                cc, cc->sched, io, n, max_n_kv, eos_id, max_new, step_state,
-                generated, &step_stats, &truncated); st != TRANSCRIBE_OK)
+                cc, cc->sched, io, n, max_n_kv, eos_id, max_new, step_state, generated, &step_stats, &truncated);
+            st != TRANSCRIBE_OK) {
             return st;
+        }
         dec_us += step_stats.step_us;
     }
 
     // ----- Capture per-utterance results -----
-    const int valid_count = std::max(1,
-        static_cast<int>(std::count(valid.begin(), valid.end(), char(1))));
+    const int valid_count = std::max(1, static_cast<int>(std::count(valid.begin(), valid.end(), char(1))));
     for (int b = 0; b < n; ++b) {
         if (!valid[b]) {
             transcribe_session::ResultSet rs;
-            rs.status = over_length[b] ? TRANSCRIBE_ERR_INPUT_TOO_LONG
-                                       : TRANSCRIBE_ERR_INVALID_ARG;
+            rs.status = over_length[b] ? TRANSCRIBE_ERR_INPUT_TOO_LONG : TRANSCRIBE_ERR_INVALID_ARG;
             cc->batch_results.push_back(std::move(rs));
             continue;
         }
         std::vector<int32_t> gen = generated[b];
-        if (!gen.empty() && gen.back() == eos_id) gen.pop_back();
+        if (!gen.empty() && gen.back() == eos_id) {
+            gen.pop_back();
+        }
         std::string text = cm->tok.decode(gen.data(), static_cast<int>(gen.size()));
-        size_t s = 0, e = text.size();
-        while (s < e && std::isspace(static_cast<unsigned char>(text[s]))) ++s;
-        while (e > s && std::isspace(static_cast<unsigned char>(text[e - 1]))) --e;
+        size_t      s = 0, e = text.size();
+        while (s < e && std::isspace(static_cast<unsigned char>(text[s]))) {
+            ++s;
+        }
+        while (e > s && std::isspace(static_cast<unsigned char>(text[e - 1]))) {
+            --e;
+        }
         text = text.substr(s, e - s);
 
         transcribe_session::ResultSet rs;
@@ -1389,20 +1429,18 @@ transcribe_status run_batch(
         rs.result_kind = TRANSCRIBE_TIMESTAMPS_NONE;
         rs.has_result  = true;
         rs.status      = TRANSCRIBE_OK;
-        transcribe_session::SegmentEntry seg {};
+        transcribe_session::SegmentEntry seg{};
         seg.text  = text;
         seg.t0_ms = 0;
-        seg.t1_ms = static_cast<int64_t>(n_samples[b]) * 1000
-                  / static_cast<int64_t>(hp.fe_sample_rate);
+        seg.t1_ms = static_cast<int64_t>(n_samples[b]) * 1000 / static_cast<int64_t>(hp.fe_sample_rate);
         rs.segments.push_back(std::move(seg));
         // Per-utterance truncation parity with single-shot run(): a row cut at
         // the generation budget / KV window before eos reports
         // TRANSCRIBE_ERR_OUTPUT_TRUNCATED (partial transcript retained). Only
         // override a TRANSCRIBE_OK status, never a worse one.
-        if (b < static_cast<int>(truncated.size()) && truncated[b] &&
-            rs.status == TRANSCRIBE_OK) {
+        if (b < static_cast<int>(truncated.size()) && truncated[b] && rs.status == TRANSCRIBE_OK) {
             cc->was_truncated = true;
-            rs.status = TRANSCRIBE_ERR_OUTPUT_TRUNCATED;
+            rs.status         = TRANSCRIBE_ERR_OUTPUT_TRUNCATED;
         }
         rs.t_mel_us    = mel_us / valid_count;
         rs.t_encode_us = enc_us / valid_count;
@@ -1412,7 +1450,7 @@ transcribe_status run_batch(
     return TRANSCRIBE_OK;
 }
 
-} // namespace
+}  // namespace
 
 extern const Arch arch = {
     /* .name             = */ "voxtral",
@@ -1428,4 +1466,4 @@ extern const Arch arch = {
     /* .accepts_ext_kind = */ nullptr,
 };
 
-} // namespace transcribe::voxtral
+}  // namespace transcribe::voxtral
diff --git a/src/arch/voxtral/voxtral.h b/src/arch/voxtral/voxtral.h
index 264ac48c..9fac9c7f 100644
--- a/src/arch/voxtral/voxtral.h
+++ b/src/arch/voxtral/voxtral.h
@@ -10,16 +10,15 @@
 #pragma once
 
 #include "causal_lm/causal_lm.h"
+#include "ggml-backend.h"
+#include "ggml.h"
 #include "transcribe-backend.h"
-#include "transcribe-session.h"
 #include "transcribe-mel.h"
 #include "transcribe-model.h"
+#include "transcribe-session.h"
 #include "transcribe-tokenizer.h"
 #include "weights.h"
 
-#include "ggml.h"
-#include "ggml-backend.h"
-
 #include <cstdint>
 #include <optional>
 #include <string>
@@ -60,8 +59,8 @@ struct VoxtralModel final : public transcribe_model {
     VoxtralWeights weights;
     ggml_context * ctx_meta = nullptr;
 
-    transcribe::BackendPlan       plan;
-    ggml_backend_buffer_t         backend_buffer = nullptr;
+    transcribe::BackendPlan                    plan;
+    ggml_backend_buffer_t                      backend_buffer = nullptr;
     transcribe::causal_lm::PackedGateUpHandles packed_gate_up;
 
     std::optional<transcribe::MelFrontend> mel;
@@ -84,8 +83,8 @@ struct VoxtralSession final : public transcribe_session {
     // one slab per utterance, reused across calls and re-allocated only when
     // the batch size or context window grows.
     transcribe::causal_lm::KvCache kv_cache_batch;
-    int kv_batch_cap   = 0;  // slabs allocated (== n_batch of last alloc)
-    int kv_batch_n_ctx = 0;  // n_ctx of last alloc
+    int                            kv_batch_cap   = 0;  // slabs allocated (== n_batch of last alloc)
+    int                            kv_batch_n_ctx = 0;  // n_ctx of last alloc
 
     std::vector<float> mel_buf;
     std::vector<float> enc_host;  // projector output (audio embeds), all chunks
@@ -97,4 +96,4 @@ struct VoxtralSession final : public transcribe_session {
     ~VoxtralSession() override;
 };
 
-} // namespace transcribe::voxtral
+}  // namespace transcribe::voxtral
diff --git a/src/arch/voxtral/weights.cpp b/src/arch/voxtral/weights.cpp
index 0f720ac9..5a077f77 100644
--- a/src/arch/voxtral/weights.cpp
+++ b/src/arch/voxtral/weights.cpp
@@ -10,12 +10,11 @@
 
 #include "weights.h"
 
-#include "transcribe-meta.h"
-#include "transcribe-weights-util.h"
-#include "transcribe-log.h"
-
 #include "ggml.h"
 #include "gguf.h"
+#include "transcribe-log.h"
+#include "transcribe-meta.h"
+#include "transcribe-weights-util.h"
 
 #include <cstdio>
 
@@ -25,96 +24,213 @@ namespace {
 constexpr const char * kFamilyTag = "voxtral";
 }
 
-transcribe_status read_voxtral_hparams(const gguf_context * gguf,
-                                       VoxtralHParams &     hp)
-{
+transcribe_status read_voxtral_hparams(const gguf_context * gguf, VoxtralHParams & hp) {
     if (gguf == nullptr) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
 
     // Audio encoder.
-    if (auto st = read_required_u32_kv(gguf, "stt.voxtral.encoder.n_layers", kFamilyTag, hp.enc_n_layers); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.voxtral.encoder.d_model", kFamilyTag, hp.enc_d_model); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.voxtral.encoder.n_heads", kFamilyTag, hp.enc_n_heads); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.voxtral.encoder.head_dim", kFamilyTag, hp.enc_head_dim); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.voxtral.encoder.ffn_dim", kFamilyTag, hp.enc_ffn_dim); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.voxtral.encoder.num_mel_bins", kFamilyTag, hp.enc_num_mel_bins); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.voxtral.encoder.max_source_positions", kFamilyTag, hp.enc_max_source_positions); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.voxtral.encoder.activation", kFamilyTag, hp.enc_activation); st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_u32_kv(gguf, "stt.voxtral.encoder.n_layers", kFamilyTag, hp.enc_n_layers);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.voxtral.encoder.d_model", kFamilyTag, hp.enc_d_model);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.voxtral.encoder.n_heads", kFamilyTag, hp.enc_n_heads);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.voxtral.encoder.head_dim", kFamilyTag, hp.enc_head_dim);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.voxtral.encoder.ffn_dim", kFamilyTag, hp.enc_ffn_dim);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.voxtral.encoder.num_mel_bins", kFamilyTag, hp.enc_num_mel_bins);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.voxtral.encoder.max_source_positions", kFamilyTag,
+                                       hp.enc_max_source_positions);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_string_kv(gguf, "stt.voxtral.encoder.activation", kFamilyTag, hp.enc_activation);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Projector.
-    if (auto st = read_required_u32_kv(gguf, "stt.voxtral.projector.downsample_factor", kFamilyTag, hp.proj_downsample); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.voxtral.projector.input_dim", kFamilyTag, hp.proj_in); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.voxtral.projector.hidden_act", kFamilyTag, hp.proj_hidden_act); st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_u32_kv(gguf, "stt.voxtral.projector.downsample_factor", kFamilyTag, hp.proj_downsample);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.voxtral.projector.input_dim", kFamilyTag, hp.proj_in);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_string_kv(gguf, "stt.voxtral.projector.hidden_act", kFamilyTag, hp.proj_hidden_act);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Text LM.
-    if (auto st = read_required_u32_kv(gguf, "stt.voxtral.decoder.n_layers", kFamilyTag, hp.dec_n_layers); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.voxtral.decoder.hidden_size", kFamilyTag, hp.dec_hidden); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.voxtral.decoder.intermediate_size", kFamilyTag, hp.dec_intermediate); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.voxtral.decoder.n_heads", kFamilyTag, hp.dec_n_heads); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.voxtral.decoder.n_kv_heads", kFamilyTag, hp.dec_n_kv_heads); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.voxtral.decoder.head_dim", kFamilyTag, hp.dec_head_dim); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.voxtral.decoder.hidden_act", kFamilyTag, hp.dec_hidden_act); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf, "stt.voxtral.decoder.rms_norm_eps", kFamilyTag, hp.dec_rms_norm_eps); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf, "stt.voxtral.decoder.rope_theta", kFamilyTag, hp.dec_rope_theta); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.voxtral.decoder.max_position_embeddings", kFamilyTag, hp.dec_max_position_embeddings); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_bool_kv(gguf, "stt.voxtral.decoder.tie_word_embeddings", kFamilyTag, false, hp.dec_tie_word_embeddings); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.voxtral.decoder.vocab_size", kFamilyTag, hp.dec_vocab_size); st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_u32_kv(gguf, "stt.voxtral.decoder.n_layers", kFamilyTag, hp.dec_n_layers);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.voxtral.decoder.hidden_size", kFamilyTag, hp.dec_hidden);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.voxtral.decoder.intermediate_size", kFamilyTag, hp.dec_intermediate);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.voxtral.decoder.n_heads", kFamilyTag, hp.dec_n_heads);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.voxtral.decoder.n_kv_heads", kFamilyTag, hp.dec_n_kv_heads);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.voxtral.decoder.head_dim", kFamilyTag, hp.dec_head_dim);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_string_kv(gguf, "stt.voxtral.decoder.hidden_act", kFamilyTag, hp.dec_hidden_act);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.voxtral.decoder.rms_norm_eps", kFamilyTag, hp.dec_rms_norm_eps);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.voxtral.decoder.rope_theta", kFamilyTag, hp.dec_rope_theta);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.voxtral.decoder.max_position_embeddings", kFamilyTag,
+                                       hp.dec_max_position_embeddings);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_bool_kv(gguf, "stt.voxtral.decoder.tie_word_embeddings", kFamilyTag, false,
+                                        hp.dec_tie_word_embeddings);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.voxtral.decoder.vocab_size", kFamilyTag, hp.dec_vocab_size);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Audio-token injection id.
-    if (auto st = read_required_u32_kv(gguf, "stt.voxtral.audio_token_id", kFamilyTag, hp.audio_token_id); st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_u32_kv(gguf, "stt.voxtral.audio_token_id", kFamilyTag, hp.audio_token_id);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Frontend.
-    if (auto st = read_required_string_kv(gguf, "stt.frontend.type", kFamilyTag, hp.fe_type); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.frontend.num_mels", kFamilyTag, hp.fe_num_mels); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.frontend.sample_rate", kFamilyTag, hp.fe_sample_rate); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.frontend.n_fft", kFamilyTag, hp.fe_n_fft); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.frontend.win_length", kFamilyTag, hp.fe_win_length); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.frontend.hop_length", kFamilyTag, hp.fe_hop_length); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.frontend.window", kFamilyTag, hp.fe_window); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.frontend.normalize", kFamilyTag, hp.fe_normalize); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf, "stt.frontend.dither", kFamilyTag, hp.fe_dither); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf, "stt.frontend.pre_emphasis", kFamilyTag, hp.fe_pre_emphasis); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf, "stt.frontend.f_min", kFamilyTag, hp.fe_f_min); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf, "stt.frontend.f_max", kFamilyTag, hp.fe_f_max); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_string_kv(gguf, "stt.frontend.pad_mode", kFamilyTag, "reflect", hp.fe_pad_mode); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_string_kv(gguf, "stt.frontend.mel_norm", kFamilyTag, "slaney", hp.fe_mel_norm); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_bool_kv(gguf, "stt.frontend.center", kFamilyTag, true, hp.fe_center); st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_string_kv(gguf, "stt.frontend.type", kFamilyTag, hp.fe_type); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.num_mels", kFamilyTag, hp.fe_num_mels);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.sample_rate", kFamilyTag, hp.fe_sample_rate);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.n_fft", kFamilyTag, hp.fe_n_fft); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.win_length", kFamilyTag, hp.fe_win_length);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.hop_length", kFamilyTag, hp.fe_hop_length);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_string_kv(gguf, "stt.frontend.window", kFamilyTag, hp.fe_window); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_string_kv(gguf, "stt.frontend.normalize", kFamilyTag, hp.fe_normalize);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.frontend.dither", kFamilyTag, hp.fe_dither); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.frontend.pre_emphasis", kFamilyTag, hp.fe_pre_emphasis);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.frontend.f_min", kFamilyTag, hp.fe_f_min); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.frontend.f_max", kFamilyTag, hp.fe_f_max); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_string_kv(gguf, "stt.frontend.pad_mode", kFamilyTag, "reflect", hp.fe_pad_mode);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_string_kv(gguf, "stt.frontend.mel_norm", kFamilyTag, "slaney", hp.fe_mel_norm);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_bool_kv(gguf, "stt.frontend.center", kFamilyTag, true, hp.fe_center);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
     {
         const auto read_optional = [&](const char * key, int32_t & dst) -> transcribe_status {
             uint32_t tmp = 0;
             switch (read_uint32_kv(gguf, key, tmp)) {
-                case KvResult::Ok:      dst = static_cast<int32_t>(tmp); return TRANSCRIBE_OK;
-                case KvResult::Absent:                                    return TRANSCRIBE_OK;
+                case KvResult::Ok:
+                    dst = static_cast<int32_t>(tmp);
+                    return TRANSCRIBE_OK;
+                case KvResult::Absent:
+                    return TRANSCRIBE_OK;
                 case KvResult::BadType:
                     log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral: \"%s\" has wrong type", key);
                     return TRANSCRIBE_ERR_GGUF;
             }
             return TRANSCRIBE_ERR_GGUF;
         };
-        if (auto st = read_optional("stt.frontend.chunk_length",  hp.fe_chunk_length ); st != TRANSCRIBE_OK) return st;
-        if (auto st = read_optional("stt.frontend.n_samples",     hp.fe_n_samples    ); st != TRANSCRIBE_OK) return st;
-        if (auto st = read_optional("stt.frontend.nb_max_frames", hp.fe_nb_max_frames); st != TRANSCRIBE_OK) return st;
+        if (auto st = read_optional("stt.frontend.chunk_length", hp.fe_chunk_length); st != TRANSCRIBE_OK) {
+            return st;
+        }
+        if (auto st = read_optional("stt.frontend.n_samples", hp.fe_n_samples); st != TRANSCRIBE_OK) {
+            return st;
+        }
+        if (auto st = read_optional("stt.frontend.nb_max_frames", hp.fe_nb_max_frames); st != TRANSCRIBE_OK) {
+            return st;
+        }
     }
 
     // Cross-field invariants.
-    if (hp.enc_n_layers <= 0 || hp.enc_d_model <= 0 || hp.enc_n_heads <= 0 ||
-        hp.enc_ffn_dim <= 0 || hp.enc_num_mel_bins <= 0 ||
-        hp.enc_max_source_positions <= 0)
-    {
+    if (hp.enc_n_layers <= 0 || hp.enc_d_model <= 0 || hp.enc_n_heads <= 0 || hp.enc_ffn_dim <= 0 ||
+        hp.enc_num_mel_bins <= 0 || hp.enc_max_source_positions <= 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral: encoder hparams must be positive");
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.enc_d_model % hp.enc_n_heads != 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "voxtral: encoder d_model (%d) not divisible by n_heads (%d)",
-                     hp.enc_d_model, hp.enc_n_heads);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral: encoder d_model (%d) not divisible by n_heads (%d)",
+                hp.enc_d_model, hp.enc_n_heads);
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.enc_head_dim != hp.enc_d_model / hp.enc_n_heads) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "voxtral: encoder head_dim (%d) != d_model/n_heads (%d)",
-                     hp.enc_head_dim, hp.enc_d_model / hp.enc_n_heads);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral: encoder head_dim (%d) != d_model/n_heads (%d)", hp.enc_head_dim,
+                hp.enc_d_model / hp.enc_n_heads);
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.proj_downsample <= 0 || hp.proj_in <= 0) {
@@ -122,50 +238,42 @@ transcribe_status read_voxtral_hparams(const gguf_context * gguf,
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.proj_in != hp.enc_d_model * hp.proj_downsample) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "voxtral: projector input_dim (%d) != enc_d_model*downsample (%d)",
-                     hp.proj_in, hp.enc_d_model * hp.proj_downsample);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral: projector input_dim (%d) != enc_d_model*downsample (%d)",
+                hp.proj_in, hp.enc_d_model * hp.proj_downsample);
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.enc_max_source_positions % hp.proj_downsample != 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "voxtral: max_source_positions (%d) not divisible by downsample (%d)",
-                     hp.enc_max_source_positions, hp.proj_downsample);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral: max_source_positions (%d) not divisible by downsample (%d)",
+                hp.enc_max_source_positions, hp.proj_downsample);
         return TRANSCRIBE_ERR_GGUF;
     }
-    if (hp.dec_n_layers <= 0 || hp.dec_hidden <= 0 || hp.dec_n_heads <= 0 ||
-        hp.dec_n_kv_heads <= 0 || hp.dec_head_dim <= 0 || hp.dec_intermediate <= 0)
-    {
+    if (hp.dec_n_layers <= 0 || hp.dec_hidden <= 0 || hp.dec_n_heads <= 0 || hp.dec_n_kv_heads <= 0 ||
+        hp.dec_head_dim <= 0 || hp.dec_intermediate <= 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral: decoder hparams must be positive");
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.dec_n_heads % hp.dec_n_kv_heads != 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "voxtral: n_heads (%d) not divisible by n_kv_heads (%d)",
-                     hp.dec_n_heads, hp.dec_n_kv_heads);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral: n_heads (%d) not divisible by n_kv_heads (%d)", hp.dec_n_heads,
+                hp.dec_n_kv_heads);
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.dec_hidden_act != "silu" && hp.dec_hidden_act != "swish") {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "voxtral: unsupported decoder hidden_act \"%s\" (only silu/swish)",
-                     hp.dec_hidden_act.c_str());
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral: unsupported decoder hidden_act \"%s\" (only silu/swish)",
+                hp.dec_hidden_act.c_str());
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.enc_activation != "gelu") {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "voxtral: unsupported encoder activation \"%s\" (only gelu)",
-                     hp.enc_activation.c_str());
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral: unsupported encoder activation \"%s\" (only gelu)",
+                hp.enc_activation.c_str());
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.proj_hidden_act != "gelu") {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "voxtral: unsupported projector hidden_act \"%s\" (only gelu)",
-                     hp.proj_hidden_act.c_str());
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral: unsupported projector hidden_act \"%s\" (only gelu)",
+                hp.proj_hidden_act.c_str());
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.fe_type != "mel") {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral: unsupported frontend type \"%s\"",
-                     hp.fe_type.c_str());
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral: unsupported frontend type \"%s\"", hp.fe_type.c_str());
         return TRANSCRIBE_ERR_GGUF;
     }
     return TRANSCRIBE_OK;
@@ -180,36 +288,36 @@ namespace {
 using transcribe::weights::lname;
 constexpr const char * kTag = kFamilyTag;
 
-#define GET_F32(slot, name, ...) \
-    do { \
-        ggml_tensor * _t = transcribe::weights::find_tensor( \
-            ctx_meta, (name), {GGML_TYPE_F32}, {__VA_ARGS__}, kTag); \
-        if (_t == nullptr) return TRANSCRIBE_ERR_GGUF; \
-        (slot) = _t; \
+#define GET_F32(slot, name, ...)                                                                          \
+    do {                                                                                                  \
+        ggml_tensor * _t =                                                                                \
+            transcribe::weights::find_tensor(ctx_meta, (name), { GGML_TYPE_F32 }, { __VA_ARGS__ }, kTag); \
+        if (_t == nullptr)                                                                                \
+            return TRANSCRIBE_ERR_GGUF;                                                                   \
+        (slot) = _t;                                                                                      \
     } while (0)
 
-#define GET_CONV(slot, name, ...) \
-    do { \
-        ggml_tensor * _t = transcribe::weights::find_tensor( \
-            ctx_meta, (name), {TRANSCRIBE_QUANT_CONV_TYPES}, {__VA_ARGS__}, kTag); \
-        if (_t == nullptr) return TRANSCRIBE_ERR_GGUF; \
-        (slot) = _t; \
+#define GET_CONV(slot, name, ...)                                                                              \
+    do {                                                                                                       \
+        ggml_tensor * _t = transcribe::weights::find_tensor(ctx_meta, (name), { TRANSCRIBE_QUANT_CONV_TYPES }, \
+                                                            { __VA_ARGS__ }, kTag);                            \
+        if (_t == nullptr)                                                                                     \
+            return TRANSCRIBE_ERR_GGUF;                                                                        \
+        (slot) = _t;                                                                                           \
     } while (0)
 
-#define GET_LIN(slot, name, ...) \
-    do { \
-        ggml_tensor * _t = transcribe::weights::find_tensor( \
-            ctx_meta, (name), {TRANSCRIBE_QUANT_LINEAR_TYPES}, {__VA_ARGS__}, kTag); \
-        if (_t == nullptr) return TRANSCRIBE_ERR_GGUF; \
-        (slot) = _t; \
+#define GET_LIN(slot, name, ...)                                                                                 \
+    do {                                                                                                         \
+        ggml_tensor * _t = transcribe::weights::find_tensor(ctx_meta, (name), { TRANSCRIBE_QUANT_LINEAR_TYPES }, \
+                                                            { __VA_ARGS__ }, kTag);                              \
+        if (_t == nullptr)                                                                                       \
+            return TRANSCRIBE_ERR_GGUF;                                                                          \
+        (slot) = _t;                                                                                             \
     } while (0)
 
-} // namespace
+}  // namespace
 
-transcribe_status build_voxtral_weights(ggml_context *         ctx_meta,
-                                        const VoxtralHParams & hp,
-                                        VoxtralWeights &       weights)
-{
+transcribe_status build_voxtral_weights(ggml_context * ctx_meta, const VoxtralHParams & hp, VoxtralWeights & weights) {
     if (ctx_meta == nullptr) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
@@ -221,74 +329,72 @@ transcribe_status build_voxtral_weights(ggml_context *         ctx_meta,
 
     // ----- encoder conv stem -----
     // Conv1d kernels: PyTorch [out, in, K] -> ggml ne=[K, in, out]. F16.
-    GET_CONV(weights.enc_stem.conv0_w, "enc.conv.0.weight", 3, n_mel,   d_model);
-    GET_F32 (weights.enc_stem.conv0_b, "enc.conv.0.bias",   d_model);
+    GET_CONV(weights.enc_stem.conv0_w, "enc.conv.0.weight", 3, n_mel, d_model);
+    GET_F32(weights.enc_stem.conv0_b, "enc.conv.0.bias", d_model);
     GET_CONV(weights.enc_stem.conv1_w, "enc.conv.1.weight", 3, d_model, d_model);
-    GET_F32 (weights.enc_stem.conv1_b, "enc.conv.1.bias",   d_model);
+    GET_F32(weights.enc_stem.conv1_b, "enc.conv.1.bias", d_model);
 
     // ----- encoder top (sinusoidal pos emb + final LN) -----
     GET_F32(weights.enc_top.pos_emb_w, "enc.pos_emb.weight", d_model, src_pos);
     GET_F32(weights.enc_top.ln_post_w, "enc.ln_post.weight", d_model);
-    GET_F32(weights.enc_top.ln_post_b, "enc.ln_post.bias",   d_model);
+    GET_F32(weights.enc_top.ln_post_b, "enc.ln_post.bias", d_model);
 
     // ----- encoder blocks (q/v/out bias, k no bias) -----
     weights.enc_blocks.assign(hp.enc_n_layers, VoxtralEncBlock{});
     for (int i = 0; i < hp.enc_n_layers; ++i) {
         auto & b = weights.enc_blocks[i];
         GET_F32(b.norm_attn_w, lname("enc.blocks.%d.norm_attn.weight", i), d_model);
-        GET_F32(b.norm_attn_b, lname("enc.blocks.%d.norm_attn.bias",   i), d_model);
-        GET_LIN(b.attn_q_w,    lname("enc.blocks.%d.attn.q.weight",    i), d_model, d_model);
-        GET_F32(b.attn_q_b,    lname("enc.blocks.%d.attn.q.bias",      i), d_model);
-        GET_LIN(b.attn_k_w,    lname("enc.blocks.%d.attn.k.weight",    i), d_model, d_model);
+        GET_F32(b.norm_attn_b, lname("enc.blocks.%d.norm_attn.bias", i), d_model);
+        GET_LIN(b.attn_q_w, lname("enc.blocks.%d.attn.q.weight", i), d_model, d_model);
+        GET_F32(b.attn_q_b, lname("enc.blocks.%d.attn.q.bias", i), d_model);
+        GET_LIN(b.attn_k_w, lname("enc.blocks.%d.attn.k.weight", i), d_model, d_model);
         // attn.k has NO bias.
-        GET_LIN(b.attn_v_w,    lname("enc.blocks.%d.attn.v.weight",    i), d_model, d_model);
-        GET_F32(b.attn_v_b,    lname("enc.blocks.%d.attn.v.bias",      i), d_model);
-        GET_LIN(b.attn_out_w,  lname("enc.blocks.%d.attn.out.weight",  i), d_model, d_model);
-        GET_F32(b.attn_out_b,  lname("enc.blocks.%d.attn.out.bias",    i), d_model);
-        GET_F32(b.norm_ffn_w,  lname("enc.blocks.%d.norm_ffn.weight",  i), d_model);
-        GET_F32(b.norm_ffn_b,  lname("enc.blocks.%d.norm_ffn.bias",    i), d_model);
-        GET_LIN(b.fc1_w,       lname("enc.blocks.%d.ffn.fc1.weight",   i), d_model, enc_ff);
-        GET_F32(b.fc1_b,       lname("enc.blocks.%d.ffn.fc1.bias",     i), enc_ff);
-        GET_LIN(b.fc2_w,       lname("enc.blocks.%d.ffn.fc2.weight",   i), enc_ff,  d_model);
-        GET_F32(b.fc2_b,       lname("enc.blocks.%d.ffn.fc2.bias",     i), d_model);
+        GET_LIN(b.attn_v_w, lname("enc.blocks.%d.attn.v.weight", i), d_model, d_model);
+        GET_F32(b.attn_v_b, lname("enc.blocks.%d.attn.v.bias", i), d_model);
+        GET_LIN(b.attn_out_w, lname("enc.blocks.%d.attn.out.weight", i), d_model, d_model);
+        GET_F32(b.attn_out_b, lname("enc.blocks.%d.attn.out.bias", i), d_model);
+        GET_F32(b.norm_ffn_w, lname("enc.blocks.%d.norm_ffn.weight", i), d_model);
+        GET_F32(b.norm_ffn_b, lname("enc.blocks.%d.norm_ffn.bias", i), d_model);
+        GET_LIN(b.fc1_w, lname("enc.blocks.%d.ffn.fc1.weight", i), d_model, enc_ff);
+        GET_F32(b.fc1_b, lname("enc.blocks.%d.ffn.fc1.bias", i), enc_ff);
+        GET_LIN(b.fc2_w, lname("enc.blocks.%d.ffn.fc2.weight", i), enc_ff, d_model);
+        GET_F32(b.fc2_b, lname("enc.blocks.%d.ffn.fc2.bias", i), d_model);
     }
 
     // ----- projector (no biases) -----
     const int64_t proj_in = hp.proj_in;
     const int64_t dec_h   = hp.dec_hidden;
     GET_LIN(weights.proj.linear_1_w, "proj.linear_1.weight", proj_in, dec_h);
-    GET_LIN(weights.proj.linear_2_w, "proj.linear_2.weight", dec_h,   dec_h);
+    GET_LIN(weights.proj.linear_2_w, "proj.linear_2.weight", dec_h, dec_h);
 
     // ----- text LM: embedding + UNTIED output -----
-    GET_LIN(weights.dec_embed.token_w,  "dec.token_embd.weight", dec_h, hp.dec_vocab_size);
-    GET_LIN(weights.dec_embed.output_w, "dec.output.weight",     dec_h, hp.dec_vocab_size);
+    GET_LIN(weights.dec_embed.token_w, "dec.token_embd.weight", dec_h, hp.dec_vocab_size);
+    GET_LIN(weights.dec_embed.output_w, "dec.output.weight", dec_h, hp.dec_vocab_size);
 
     // ----- text LM: blocks (Llama; no biases, no Q/K norm) -----
     const int64_t dec_nh  = hp.dec_n_heads;
     const int64_t dec_nkv = hp.dec_n_kv_heads;
     const int64_t dec_hd  = hp.dec_head_dim;
     const int64_t dec_im  = hp.dec_intermediate;
-    const int64_t q_out   = dec_nh  * dec_hd;
+    const int64_t q_out   = dec_nh * dec_hd;
     const int64_t kv_out  = dec_nkv * dec_hd;
 
     weights.dec_blocks.assign(hp.dec_n_layers, VoxtralDecBlock{});
     for (int i = 0; i < hp.dec_n_layers; ++i) {
         auto & b = weights.dec_blocks[i];
         GET_F32(b.norm_attn_w, lname("dec.blocks.%d.norm_attn.weight", i), dec_h);
-        GET_F32(b.norm_ffn_w,  lname("dec.blocks.%d.norm_ffn.weight",  i), dec_h);
-        GET_LIN(b.attn_q_w,    lname("dec.blocks.%d.attn.q.weight", i), dec_h, q_out);
-        GET_LIN(b.attn_k_w,    lname("dec.blocks.%d.attn.k.weight", i), dec_h, kv_out);
-        GET_LIN(b.attn_v_w,    lname("dec.blocks.%d.attn.v.weight", i), dec_h, kv_out);
-        GET_LIN(b.attn_o_w,    lname("dec.blocks.%d.attn.o.weight", i), q_out, dec_h);
-        GET_LIN(b.ffn_gate_w,  lname("dec.blocks.%d.ffn.gate.weight", i), dec_h, dec_im);
-        GET_LIN(b.ffn_up_w,    lname("dec.blocks.%d.ffn.up.weight",   i), dec_h, dec_im);
-        GET_LIN(b.ffn_down_w,  lname("dec.blocks.%d.ffn.down.weight", i), dec_im, dec_h);
+        GET_F32(b.norm_ffn_w, lname("dec.blocks.%d.norm_ffn.weight", i), dec_h);
+        GET_LIN(b.attn_q_w, lname("dec.blocks.%d.attn.q.weight", i), dec_h, q_out);
+        GET_LIN(b.attn_k_w, lname("dec.blocks.%d.attn.k.weight", i), dec_h, kv_out);
+        GET_LIN(b.attn_v_w, lname("dec.blocks.%d.attn.v.weight", i), dec_h, kv_out);
+        GET_LIN(b.attn_o_w, lname("dec.blocks.%d.attn.o.weight", i), q_out, dec_h);
+        GET_LIN(b.ffn_gate_w, lname("dec.blocks.%d.ffn.gate.weight", i), dec_h, dec_im);
+        GET_LIN(b.ffn_up_w, lname("dec.blocks.%d.ffn.up.weight", i), dec_h, dec_im);
+        GET_LIN(b.ffn_down_w, lname("dec.blocks.%d.ffn.down.weight", i), dec_im, dec_h);
 
         if (b.ffn_gate_w->type != b.ffn_up_w->type) {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "voxtral: ffn gate/up dtype mismatch at layer %d (%d vs %d)",
-                         i, static_cast<int>(b.ffn_gate_w->type),
-                         static_cast<int>(b.ffn_up_w->type));
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral: ffn gate/up dtype mismatch at layer %d (%d vs %d)", i,
+                    static_cast<int>(b.ffn_gate_w->type), static_cast<int>(b.ffn_up_w->type));
             return TRANSCRIBE_ERR_GGUF;
         }
     }
@@ -299,4 +405,4 @@ transcribe_status build_voxtral_weights(ggml_context *         ctx_meta,
     return TRANSCRIBE_OK;
 }
 
-} // namespace transcribe::voxtral
+}  // namespace transcribe::voxtral
diff --git a/src/arch/voxtral/weights.h b/src/arch/voxtral/weights.h
index 5d1776bb..ca533d6b 100644
--- a/src/arch/voxtral/weights.h
+++ b/src/arch/voxtral/weights.h
@@ -38,33 +38,33 @@ namespace transcribe::voxtral {
 
 struct VoxtralHParams {
     // Audio encoder (Whisper-large-v3 encoder).
-    int32_t enc_n_layers            = 0;
-    int32_t enc_d_model             = 0;
-    int32_t enc_n_heads             = 0;
-    int32_t enc_head_dim            = 0;
-    int32_t enc_ffn_dim             = 0;
-    int32_t enc_num_mel_bins        = 0;
-    int32_t enc_max_source_positions = 0;  // 1500
-    std::string enc_activation;             // "gelu"
+    int32_t     enc_n_layers             = 0;
+    int32_t     enc_d_model              = 0;
+    int32_t     enc_n_heads              = 0;
+    int32_t     enc_head_dim             = 0;
+    int32_t     enc_ffn_dim              = 0;
+    int32_t     enc_num_mel_bins         = 0;
+    int32_t     enc_max_source_positions = 0;  // 1500
+    std::string enc_activation;                // "gelu"
 
     // Projector (multi-modal).
-    int32_t proj_downsample = 0;  // 4x frame grouping
-    int32_t proj_in         = 0;  // enc_d_model * downsample (5120)
-    std::string proj_hidden_act;  // "gelu"
+    int32_t     proj_downsample = 0;  // 4x frame grouping
+    int32_t     proj_in         = 0;  // enc_d_model * downsample (5120)
+    std::string proj_hidden_act;      // "gelu"
 
     // Text LM (Llama / Ministral).
-    int32_t dec_n_layers            = 0;
-    int32_t dec_hidden              = 0;
-    int32_t dec_intermediate        = 0;
-    int32_t dec_n_heads             = 0;
-    int32_t dec_n_kv_heads          = 0;
-    int32_t dec_head_dim            = 0;
+    int32_t     dec_n_layers     = 0;
+    int32_t     dec_hidden       = 0;
+    int32_t     dec_intermediate = 0;
+    int32_t     dec_n_heads      = 0;
+    int32_t     dec_n_kv_heads   = 0;
+    int32_t     dec_head_dim     = 0;
     std::string dec_hidden_act;  // "silu"
-    float   dec_rms_norm_eps        = 0.0f;
-    float   dec_rope_theta          = 0.0f;
-    int32_t dec_max_position_embeddings = 0;
-    bool    dec_tie_word_embeddings = false;  // UNTIED for Voxtral
-    int32_t dec_vocab_size          = 0;
+    float       dec_rms_norm_eps            = 0.0f;
+    float       dec_rope_theta              = 0.0f;
+    int32_t     dec_max_position_embeddings = 0;
+    bool        dec_tie_word_embeddings     = false;  // UNTIED for Voxtral
+    int32_t     dec_vocab_size              = 0;
 
     // Audio-token injection id.
     int32_t audio_token_id = 0;  // [AUDIO] placeholder (24)
@@ -77,38 +77,34 @@ struct VoxtralHParams {
 
     // Frontend (Whisper feature extractor).
     std::string fe_type;
-    int32_t     fe_num_mels      = 0;
-    int32_t     fe_sample_rate   = 0;
-    int32_t     fe_n_fft         = 0;
-    int32_t     fe_win_length    = 0;
-    int32_t     fe_hop_length    = 0;
+    int32_t     fe_num_mels    = 0;
+    int32_t     fe_sample_rate = 0;
+    int32_t     fe_n_fft       = 0;
+    int32_t     fe_win_length  = 0;
+    int32_t     fe_hop_length  = 0;
     std::string fe_window;
     std::string fe_normalize;
-    float       fe_dither        = 0.0f;
-    float       fe_pre_emphasis  = 0.0f;
-    float       fe_f_min         = 0.0f;
-    float       fe_f_max         = 0.0f;
+    float       fe_dither       = 0.0f;
+    float       fe_pre_emphasis = 0.0f;
+    float       fe_f_min        = 0.0f;
+    float       fe_f_max        = 0.0f;
     std::string fe_pad_mode;
-    bool        fe_center        = true;
+    bool        fe_center = true;
     std::string fe_mel_norm;
-    int32_t     fe_chunk_length  = 0;   // 30 (seconds)
-    int32_t     fe_n_samples     = 0;   // 480000
-    int32_t     fe_nb_max_frames = 0;   // 3000
+    int32_t     fe_chunk_length  = 0;  // 30 (seconds)
+    int32_t     fe_n_samples     = 0;  // 480000
+    int32_t     fe_nb_max_frames = 0;  // 3000
 
     // Derived.
-    int32_t enc_head_dim_calc() const {
-        return enc_n_heads > 0 ? enc_d_model / enc_n_heads : 0;
-    }
+    int32_t enc_head_dim_calc() const { return enc_n_heads > 0 ? enc_d_model / enc_n_heads : 0; }
+
     // Audio tokens produced per 30 s chunk: enc frames (1500) / downsample.
     int32_t audio_tokens_per_chunk() const {
-        return (enc_max_source_positions > 0 && proj_downsample > 0)
-                   ? enc_max_source_positions / proj_downsample
-                   : 0;
+        return (enc_max_source_positions > 0 && proj_downsample > 0) ? enc_max_source_positions / proj_downsample : 0;
     }
 };
 
-transcribe_status read_voxtral_hparams(const gguf_context * gguf,
-                                       VoxtralHParams &     hp);
+transcribe_status read_voxtral_hparams(const gguf_context * gguf, VoxtralHParams & hp);
 
 // ---------------------------------------------------------------------------
 // Weight slots - audio encoder (Whisper-large-v3)
@@ -123,9 +119,9 @@ struct VoxtralEncStem {
 };
 
 struct VoxtralEncTop {
-    ggml_tensor * pos_emb_w  = nullptr;  // [d_model, max_source_positions] (F32)
-    ggml_tensor * ln_post_w  = nullptr;  // [d_model]
-    ggml_tensor * ln_post_b  = nullptr;  // [d_model]
+    ggml_tensor * pos_emb_w = nullptr;  // [d_model, max_source_positions] (F32)
+    ggml_tensor * ln_post_w = nullptr;  // [d_model]
+    ggml_tensor * ln_post_b = nullptr;  // [d_model]
 };
 
 // One encoder transformer block. q/v/out carry bias; k does NOT.
@@ -163,13 +159,13 @@ struct VoxtralDecEmbed {
 };
 
 struct VoxtralDecBlock {
-    ggml_tensor * norm_attn_w = nullptr;  // input_layernorm (RMSNorm)
-    ggml_tensor * norm_ffn_w  = nullptr;  // post_attention_layernorm
+    ggml_tensor * norm_attn_w   = nullptr;  // input_layernorm (RMSNorm)
+    ggml_tensor * norm_ffn_w    = nullptr;  // post_attention_layernorm
     // GQA projections; no biases, NO per-head Q/K norm (Llama, not Qwen3).
-    ggml_tensor * attn_q_w    = nullptr;  // [hidden, n_heads * head_dim]
-    ggml_tensor * attn_k_w    = nullptr;  // [hidden, n_kv_heads * head_dim]
-    ggml_tensor * attn_v_w    = nullptr;  // [hidden, n_kv_heads * head_dim]
-    ggml_tensor * attn_o_w    = nullptr;  // [n_heads * head_dim, hidden]
+    ggml_tensor * attn_q_w      = nullptr;  // [hidden, n_heads * head_dim]
+    ggml_tensor * attn_k_w      = nullptr;  // [hidden, n_kv_heads * head_dim]
+    ggml_tensor * attn_v_w      = nullptr;  // [hidden, n_kv_heads * head_dim]
+    ggml_tensor * attn_o_w      = nullptr;  // [n_heads * head_dim, hidden]
     // SwiGLU MLP.
     ggml_tensor * ffn_gate_w    = nullptr;  // [hidden, intermediate]
     ggml_tensor * ffn_up_w      = nullptr;  // [hidden, intermediate]
@@ -180,7 +176,7 @@ struct VoxtralDecBlock {
 };
 
 struct VoxtralDecFinal {
-    ggml_tensor * norm_w = nullptr;   // dec.output_norm.weight (RMSNorm)
+    ggml_tensor * norm_w = nullptr;  // dec.output_norm.weight (RMSNorm)
 };
 
 struct VoxtralWeights {
@@ -188,15 +184,13 @@ struct VoxtralWeights {
     VoxtralEncTop                enc_top;
     std::vector<VoxtralEncBlock> enc_blocks;
 
-    VoxtralProjector             proj;
+    VoxtralProjector proj;
 
     VoxtralDecEmbed              dec_embed;
     std::vector<VoxtralDecBlock> dec_blocks;
     VoxtralDecFinal              dec_final;
 };
 
-transcribe_status build_voxtral_weights(ggml_context *         ctx_meta,
-                                        const VoxtralHParams & hp,
-                                        VoxtralWeights &       weights);
+transcribe_status build_voxtral_weights(ggml_context * ctx_meta, const VoxtralHParams & hp, VoxtralWeights & weights);
 
-} // namespace transcribe::voxtral
+}  // namespace transcribe::voxtral
diff --git a/src/arch/voxtral_realtime/capabilities.cpp b/src/arch/voxtral_realtime/capabilities.cpp
index 5f877ea1..0a5a6763 100644
--- a/src/arch/voxtral_realtime/capabilities.cpp
+++ b/src/arch/voxtral_realtime/capabilities.cpp
@@ -29,4 +29,4 @@ void apply_family_invariants(transcribe_model & model) {
     transcribe::set_feature(&model, TRANSCRIBE_FEATURE_CANCELLATION, true);
 }
 
-} // namespace transcribe::voxtral_realtime
+}  // namespace transcribe::voxtral_realtime
diff --git a/src/arch/voxtral_realtime/decoder.cpp b/src/arch/voxtral_realtime/decoder.cpp
index a950d795..5dfd7f36 100644
--- a/src/arch/voxtral_realtime/decoder.cpp
+++ b/src/arch/voxtral_realtime/decoder.cpp
@@ -8,11 +8,10 @@
 #include "decoder.h"
 
 #include "causal_lm/causal_lm.h"
+#include "ggml.h"
 #include "transcribe-debug.h"
 #include "transcribe-log.h"
 
-#include "ggml.h"
-
 #include <cstdio>
 
 namespace transcribe::voxtral_realtime {
@@ -20,7 +19,9 @@ namespace transcribe::voxtral_realtime {
 namespace {
 
 ggml_tensor * named(ggml_tensor * t, const char * name) {
-    if (t != nullptr && name != nullptr) ggml_set_name(t, name);
+    if (t != nullptr && name != nullptr) {
+        ggml_set_name(t, name);
+    }
     return t;
 }
 
@@ -29,7 +30,7 @@ ggml_tensor * named(ggml_tensor * t, const char * name) {
 // rms_norm(·weight) apply the ada scale — no separate per-layer ggml_mul. Null
 // falls back to the raw FFN-norm weight (ada not yet computed).
 causal_lm::BlockView to_block_view(const DecBlock & b, ggml_tensor * ffn_norm_folded) {
-    causal_lm::BlockView v {};
+    causal_lm::BlockView v{};
     v.norm_attn_w   = b.norm_attn_w;
     v.norm_ffn_w    = (ffn_norm_folded != nullptr) ? ffn_norm_folded : b.norm_ffn_w;
     v.attn_q_w      = b.attn_q_w;
@@ -45,7 +46,7 @@ causal_lm::BlockView to_block_view(const DecBlock & b, ggml_tensor * ffn_norm_fo
 }
 
 causal_lm::BlockParams to_block_params(const HParams & hp) {
-    causal_lm::BlockParams p {};
+    causal_lm::BlockParams p{};
     p.n_heads      = hp.dec_n_heads;
     p.n_kv_heads   = hp.dec_n_kv_heads;
     p.head_dim     = hp.dec_head_dim;
@@ -56,35 +57,36 @@ causal_lm::BlockParams to_block_params(const HParams & hp) {
 }
 
 // Per-layer ffn_scale view into ada_scale_all [hidden, n_layers].
-ggml_tensor * ada_scale_for(ggml_context * ctx, ggml_tensor * ada_scale_all,
-                            int64_t hidden, int layer) {
-    if (ada_scale_all == nullptr) return nullptr;
+ggml_tensor * ada_scale_for(ggml_context * ctx, ggml_tensor * ada_scale_all, int64_t hidden, int layer) {
+    if (ada_scale_all == nullptr) {
+        return nullptr;
+    }
     return ggml_view_1d(ctx, ada_scale_all, hidden,
                         ggml_element_size(ada_scale_all) * hidden * static_cast<size_t>(layer));
 }
 
-} // namespace
+}  // namespace
 
-PrefillBuild build_prefill_graph(ggml_context *                  ctx,
-                                 const Weights &                 weights,
-                                 const HParams &                 hp,
+PrefillBuild build_prefill_graph(ggml_context *                   ctx,
+                                 const Weights &                  weights,
+                                 const HParams &                  hp,
                                  transcribe::causal_lm::KvCache & kv_cache,
-                                 ggml_tensor *                   ada_scale_all,
-                                 int                             T,
-                                 bool                            use_flash,
-                                 bool                            want_all_logits) {
-    PrefillBuild pb {};
+                                 ggml_tensor *                    ada_scale_all,
+                                 int                              T,
+                                 bool                             use_flash,
+                                 bool                             want_all_logits) {
+    PrefillBuild pb{};
     pb.T = T;
     if (ctx == nullptr || T <= 0 || kv_cache.self_k == nullptr || T > kv_cache.n_ctx) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral_realtime prefill: invalid arg (T=%d)", T);
         return pb;
     }
 
-    const int64_t hidden  = hp.dec_hidden;
-    const int64_t vocab   = hp.dec_vocab_size;
-    const int     n_layer = hp.dec_n_layers;
-    const float   rms_eps = hp.dec_rms_norm_eps;
-    const auto block_params = to_block_params(hp);
+    const int64_t hidden       = hp.dec_hidden;
+    const int64_t vocab        = hp.dec_vocab_size;
+    const int     n_layer      = hp.dec_n_layers;
+    const float   rms_eps      = hp.dec_rms_norm_eps;
+    const auto    block_params = to_block_params(hp);
 
     pb.input_ids_in = ggml_new_tensor_1d(ctx, GGML_TYPE_I32, T);
     named(pb.input_ids_in, "dec.input_ids");
@@ -103,7 +105,10 @@ PrefillBuild build_prefill_graph(ggml_context *                  ctx,
     ggml_set_input(pb.mask_in);
 
     ggml_cgraph * gf = ggml_new_graph_custom(ctx, /*size=*/16384, /*grads=*/false);
-    if (gf == nullptr) { log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral_realtime prefill: graph alloc failed"); return pb; }
+    if (gf == nullptr) {
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral_realtime prefill: graph alloc failed");
+        return pb;
+    }
     pb.graph = gf;
 
     // Token embedding + additive audio overlay.
@@ -118,22 +123,26 @@ PrefillBuild build_prefill_graph(ggml_context *                  ctx,
     transcribe::debug::mark_tensor_for_dump(x);
 
     for (int il = 0; il < n_layer; ++il) {
-        causal_lm::BlockOpts opts {};
-        opts.use_flash = use_flash;
+        causal_lm::BlockOpts opts{};
+        opts.use_flash      = use_flash;
         ggml_tensor * scale = ada_scale_for(ctx, ada_scale_all, hidden, il);
-        x = causal_lm::block_prefill(ctx, gf, x, to_block_view(weights.dec_blocks[il], scale),
-                                    block_params, kv_cache, il, T,
-                                    pb.mask_in, pb.positions_in, opts);
+        x = causal_lm::block_prefill(ctx, gf, x, to_block_view(weights.dec_blocks[il], scale), block_params, kv_cache,
+                                     il, T, pb.mask_in, pb.positions_in, opts);
         if (il == 0) {
-            named(x, "dec.block.0.out"); pb.dumps.block_0_out = x;
+            named(x, "dec.block.0.out");
+            pb.dumps.block_0_out = x;
             transcribe::debug::mark_tensor_for_dump(x);
         } else if (il == n_layer / 2) {
-            char nm[64]; std::snprintf(nm, sizeof(nm), "dec.block.%d.out", il);
-            named(x, nm); pb.dumps.block_mid_out = x;
+            char nm[64];
+            std::snprintf(nm, sizeof(nm), "dec.block.%d.out", il);
+            named(x, nm);
+            pb.dumps.block_mid_out = x;
             transcribe::debug::mark_tensor_for_dump(x);
         } else if (il == n_layer - 1) {
-            char nm[64]; std::snprintf(nm, sizeof(nm), "dec.block.%d.out", il);
-            named(x, nm); pb.dumps.block_last_out = x;
+            char nm[64];
+            std::snprintf(nm, sizeof(nm), "dec.block.%d.out", il);
+            named(x, nm);
+            pb.dumps.block_last_out = x;
             transcribe::debug::mark_tensor_for_dump(x);
         }
     }
@@ -150,47 +159,58 @@ PrefillBuild build_prefill_graph(ggml_context *                  ctx,
         named(logits, "dec.logits_all");
         pb.dumps.logits_all = logits;
     } else {
-        ggml_tensor * last_x = ggml_view_2d(ctx, x, hidden, 1,
-                                            ggml_element_size(x) * hidden,
+        ggml_tensor * last_x = ggml_view_2d(ctx, x, hidden, 1, ggml_element_size(x) * hidden,
                                             ggml_element_size(x) * hidden * static_cast<size_t>(T - 1));
-        last_x = ggml_cont(ctx, last_x);
-        logits = ggml_mul_mat(ctx, weights.dec_embed.token_w, last_x);
-        logits = ggml_reshape_1d(ctx, logits, vocab);
+        last_x               = ggml_cont(ctx, last_x);
+        logits               = ggml_mul_mat(ctx, weights.dec_embed.token_w, last_x);
+        logits               = ggml_reshape_1d(ctx, logits, vocab);
         named(logits, "dec.logits_raw");
     }
     pb.out = logits;
     ggml_set_output(pb.out);
 
     ggml_build_forward_expand(gf, pb.out);
-    if (pb.dumps.token_emb)       ggml_build_forward_expand(gf, pb.dumps.token_emb);
-    if (pb.dumps.audio_injected)  ggml_build_forward_expand(gf, pb.dumps.audio_injected);
-    if (pb.dumps.block_0_out)     ggml_build_forward_expand(gf, pb.dumps.block_0_out);
-    if (pb.dumps.block_mid_out)   ggml_build_forward_expand(gf, pb.dumps.block_mid_out);
-    if (pb.dumps.block_last_out)  ggml_build_forward_expand(gf, pb.dumps.block_last_out);
-    if (pb.dumps.out_before_head) ggml_build_forward_expand(gf, pb.dumps.out_before_head);
+    if (pb.dumps.token_emb) {
+        ggml_build_forward_expand(gf, pb.dumps.token_emb);
+    }
+    if (pb.dumps.audio_injected) {
+        ggml_build_forward_expand(gf, pb.dumps.audio_injected);
+    }
+    if (pb.dumps.block_0_out) {
+        ggml_build_forward_expand(gf, pb.dumps.block_0_out);
+    }
+    if (pb.dumps.block_mid_out) {
+        ggml_build_forward_expand(gf, pb.dumps.block_mid_out);
+    }
+    if (pb.dumps.block_last_out) {
+        ggml_build_forward_expand(gf, pb.dumps.block_last_out);
+    }
+    if (pb.dumps.out_before_head) {
+        ggml_build_forward_expand(gf, pb.dumps.out_before_head);
+    }
 
     return pb;
 }
 
-StepBuild build_step_graph(ggml_context *                  ctx,
-                           const Weights &                 weights,
-                           const HParams &                 hp,
+StepBuild build_step_graph(ggml_context *                   ctx,
+                           const Weights &                  weights,
+                           const HParams &                  hp,
                            transcribe::causal_lm::KvCache & kv_cache,
-                           ggml_tensor *                   ada_scale_all,
-                           int                             max_n_kv,
-                           bool                            use_flash) {
-    StepBuild sb {};
+                           ggml_tensor *                    ada_scale_all,
+                           int                              max_n_kv,
+                           bool                             use_flash) {
+    StepBuild sb{};
     sb.max_n_kv = max_n_kv;
     if (ctx == nullptr || max_n_kv <= 0 || kv_cache.self_k == nullptr || max_n_kv > kv_cache.n_ctx) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral_realtime step: invalid arg (max_n_kv=%d)", max_n_kv);
         return sb;
     }
 
-    const int64_t hidden  = hp.dec_hidden;
-    const int64_t vocab   = hp.dec_vocab_size;
-    const int     n_layer = hp.dec_n_layers;
-    const float   rms_eps = hp.dec_rms_norm_eps;
-    const auto block_params = to_block_params(hp);
+    const int64_t hidden       = hp.dec_hidden;
+    const int64_t vocab        = hp.dec_vocab_size;
+    const int     n_layer      = hp.dec_n_layers;
+    const float   rms_eps      = hp.dec_rms_norm_eps;
+    const auto    block_params = to_block_params(hp);
 
     sb.input_id_in = ggml_new_tensor_1d(ctx, GGML_TYPE_I32, 1);
     ggml_set_name(sb.input_id_in, "step.input_id");
@@ -209,22 +229,24 @@ StepBuild build_step_graph(ggml_context *                  ctx,
     ggml_set_input(sb.mask_in);
 
     ggml_cgraph * gf = ggml_new_graph_custom(ctx, /*size=*/8192, /*grads=*/false);
-    if (gf == nullptr) { log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral_realtime step: graph alloc failed"); return sb; }
+    if (gf == nullptr) {
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral_realtime step: graph alloc failed");
+        return sb;
+    }
     sb.graph = gf;
 
     ggml_tensor * x = ggml_get_rows(ctx, weights.dec_embed.token_w, sb.input_id_in);
-    x = ggml_add(ctx, x, sb.audio_in);
+    x               = ggml_add(ctx, x, sb.audio_in);
 
     for (int il = 0; il < n_layer; ++il) {
         ggml_tensor * scale = ada_scale_for(ctx, ada_scale_all, hidden, il);
-        x = causal_lm::block_step(ctx, gf, x, to_block_view(weights.dec_blocks[il], scale),
-                                 block_params, kv_cache, il, max_n_kv,
-                                 sb.mask_in, sb.position_in, sb.kv_idx_in, use_flash);
+        x = causal_lm::block_step(ctx, gf, x, to_block_view(weights.dec_blocks[il], scale), block_params, kv_cache, il,
+                                  max_n_kv, sb.mask_in, sb.position_in, sb.kv_idx_in, use_flash);
     }
 
-    x = ggml_mul(ctx, ggml_rms_norm(ctx, x, rms_eps), weights.dec_final.norm_w);
+    x                    = ggml_mul(ctx, ggml_rms_norm(ctx, x, rms_eps), weights.dec_final.norm_w);
     ggml_tensor * logits = ggml_mul_mat(ctx, weights.dec_embed.token_w, x);
-    logits = ggml_reshape_1d(ctx, logits, vocab);
+    logits               = ggml_reshape_1d(ctx, logits, vocab);
     ggml_set_name(logits, "step.logits");
     ggml_set_output(logits);
     sb.logits = logits;
@@ -238,29 +260,28 @@ StepBuild build_step_graph(ggml_context *                  ctx,
     return sb;
 }
 
-VerifyBuild build_verify_graph(ggml_context *                  ctx,
-                               const Weights &                 weights,
-                               const HParams &                 hp,
+VerifyBuild build_verify_graph(ggml_context *                   ctx,
+                               const Weights &                  weights,
+                               const HParams &                  hp,
                                transcribe::causal_lm::KvCache & kv_cache,
-                               ggml_tensor *                   ada_scale_all,
-                               int                             T_verify,
-                               int                             max_n_kv,
-                               bool                            use_flash) {
-    VerifyBuild vb {};
+                               ggml_tensor *                    ada_scale_all,
+                               int                              T_verify,
+                               int                              max_n_kv,
+                               bool                             use_flash) {
+    VerifyBuild vb{};
     vb.T_verify = T_verify;
     vb.max_n_kv = max_n_kv;
-    if (ctx == nullptr || T_verify <= 0 || max_n_kv <= 0 ||
-        kv_cache.self_k == nullptr || max_n_kv > kv_cache.n_ctx) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral_realtime verify: invalid arg (T_verify=%d max_n_kv=%d)",
-                     T_verify, max_n_kv);
+    if (ctx == nullptr || T_verify <= 0 || max_n_kv <= 0 || kv_cache.self_k == nullptr || max_n_kv > kv_cache.n_ctx) {
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral_realtime verify: invalid arg (T_verify=%d max_n_kv=%d)", T_verify,
+                max_n_kv);
         return vb;
     }
 
-    const int64_t hidden  = hp.dec_hidden;
-    const int64_t vocab   = hp.dec_vocab_size;
-    const int     n_layer = hp.dec_n_layers;
-    const float   rms_eps = hp.dec_rms_norm_eps;
-    const auto block_params = to_block_params(hp);
+    const int64_t hidden       = hp.dec_hidden;
+    const int64_t vocab        = hp.dec_vocab_size;
+    const int     n_layer      = hp.dec_n_layers;
+    const float   rms_eps      = hp.dec_rms_norm_eps;
+    const auto    block_params = to_block_params(hp);
 
     vb.input_ids_in = ggml_new_tensor_1d(ctx, GGML_TYPE_I32, T_verify);
     ggml_set_name(vb.input_ids_in, "verify.input_ids");
@@ -286,17 +307,15 @@ VerifyBuild build_verify_graph(ggml_context *                  ctx,
     vb.graph = gf;
 
     ggml_tensor * x = ggml_get_rows(ctx, weights.dec_embed.token_w, vb.input_ids_in);
-    x = ggml_add(ctx, x, vb.audio_in);
+    x               = ggml_add(ctx, x, vb.audio_in);
 
     for (int il = 0; il < n_layer; ++il) {
         ggml_tensor * scale = ada_scale_for(ctx, ada_scale_all, hidden, il);
-        x = causal_lm::block_step_n(ctx, gf, x,
-                                   to_block_view(weights.dec_blocks[il], scale),
-                                   block_params, kv_cache, il, T_verify, max_n_kv,
-                                   vb.mask_in, vb.positions_in, vb.kv_idx_in, use_flash);
+        x = causal_lm::block_step_n(ctx, gf, x, to_block_view(weights.dec_blocks[il], scale), block_params, kv_cache,
+                                    il, T_verify, max_n_kv, vb.mask_in, vb.positions_in, vb.kv_idx_in, use_flash);
     }
 
-    x = ggml_mul(ctx, ggml_rms_norm(ctx, x, rms_eps), weights.dec_final.norm_w);
+    x                    = ggml_mul(ctx, ggml_rms_norm(ctx, x, rms_eps), weights.dec_final.norm_w);
     ggml_tensor * logits = ggml_mul_mat(ctx, weights.dec_embed.token_w, x);
     ggml_set_name(logits, "verify.logits");
     ggml_set_output(logits);
@@ -315,38 +334,35 @@ VerifyBuild build_verify_graph(ggml_context *                  ctx,
 // Batched prefill / step (offline transcribe_run_batch)
 // ---------------------------------------------------------------------------
 
-PrefillBuildBatched build_prefill_graph_batched(
-    ggml_context *                  ctx,
-    const Weights &                 weights,
-    const HParams &                 hp,
-    transcribe::causal_lm::KvCache & kv_cache,
-    ggml_tensor *                   ada_scale_all,
-    int                             T_prompt,
-    int                             n_batch,
-    bool                            use_flash) {
-    PrefillBuildBatched pb {};
+PrefillBuildBatched build_prefill_graph_batched(ggml_context *                   ctx,
+                                                const Weights &                  weights,
+                                                const HParams &                  hp,
+                                                transcribe::causal_lm::KvCache & kv_cache,
+                                                ggml_tensor *                    ada_scale_all,
+                                                int                              T_prompt,
+                                                int                              n_batch,
+                                                bool                             use_flash) {
+    PrefillBuildBatched pb{};
     pb.T_prompt = T_prompt;
     pb.n_batch  = n_batch;
-    if (ctx == nullptr || T_prompt <= 0 || n_batch <= 0 || !use_flash ||
-        kv_cache.self_k == nullptr || kv_cache.n_batch != n_batch ||
-        T_prompt > kv_cache.n_ctx) {
+    if (ctx == nullptr || T_prompt <= 0 || n_batch <= 0 || !use_flash || kv_cache.self_k == nullptr ||
+        kv_cache.n_batch != n_batch || T_prompt > kv_cache.n_ctx) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral_realtime prefill(batched): invalid arg (T_prompt=%d, n_batch=%d)",
-                     T_prompt, n_batch);
+                T_prompt, n_batch);
         return pb;
     }
 
-    const int64_t hidden  = hp.dec_hidden;
-    const int64_t vocab   = hp.dec_vocab_size;
-    const int     n_layer = hp.dec_n_layers;
-    const float   rms_eps = hp.dec_rms_norm_eps;
-    const int     B       = n_batch;
-    const auto block_params = to_block_params(hp);
+    const int64_t hidden       = hp.dec_hidden;
+    const int64_t vocab        = hp.dec_vocab_size;
+    const int     n_layer      = hp.dec_n_layers;
+    const float   rms_eps      = hp.dec_rms_norm_eps;
+    const int     B            = n_batch;
+    const auto    block_params = to_block_params(hp);
 
     pb.input_ids_in = ggml_new_tensor_2d(ctx, GGML_TYPE_I32, T_prompt, B);
     named(pb.input_ids_in, "dec.batched.input_ids");
     ggml_set_input(pb.input_ids_in);
-    pb.audio_dense_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, hidden,
-                                           static_cast<int64_t>(T_prompt) * B);
+    pb.audio_dense_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, hidden, static_cast<int64_t>(T_prompt) * B);
     named(pb.audio_dense_in, "dec.batched.audio_dense");
     ggml_set_input(pb.audio_dense_in);
     pb.positions_in = ggml_new_tensor_1d(ctx, GGML_TYPE_I32, T_prompt);
@@ -363,35 +379,39 @@ PrefillBuildBatched build_prefill_graph_batched(
     ggml_set_input(pb.last_idx_in);
 
     ggml_cgraph * gf = ggml_new_graph_custom(ctx, /*size=*/16384, /*grads=*/false);
-    if (gf == nullptr) { log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral_realtime prefill(batched): graph alloc failed"); return pb; }
+    if (gf == nullptr) {
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral_realtime prefill(batched): graph alloc failed");
+        return pb;
+    }
     pb.graph = gf;
 
     // Token-embed the (rectangular) prompt rows, then ADD the audio embeds at
     // every position. Pure additive fusion, no keep_mask: the realtime prompt is
     // all placeholder tokens and the projector audio overlays every position.
-    ggml_tensor * ids_flat = ggml_reshape_1d(ctx, pb.input_ids_in,
-                                             static_cast<int64_t>(T_prompt) * B);
-    ggml_tensor * x = ggml_get_rows(ctx, weights.dec_embed.token_w, ids_flat);  // [hidden, T_prompt*B]
-    x = ggml_add(ctx, x, pb.audio_dense_in);
-    x = ggml_reshape_3d(ctx, x, hidden, T_prompt, B);
+    ggml_tensor * ids_flat = ggml_reshape_1d(ctx, pb.input_ids_in, static_cast<int64_t>(T_prompt) * B);
+    ggml_tensor * x        = ggml_get_rows(ctx, weights.dec_embed.token_w, ids_flat);  // [hidden, T_prompt*B]
+    x                      = ggml_add(ctx, x, pb.audio_dense_in);
+    x                      = ggml_reshape_3d(ctx, x, hidden, T_prompt, B);
 
     for (int il = 0; il < n_layer; ++il) {
         ggml_tensor * scale = ada_scale_for(ctx, ada_scale_all, hidden, il);
-        x = causal_lm::block_prefill_batched(
-            ctx, gf, x, to_block_view(weights.dec_blocks[il], scale),
-            block_params, kv_cache, il, T_prompt, B,
-            pb.mask_in, pb.positions_in, pb.kv_idx_in, use_flash);
-        if (x == nullptr) { pb.graph = nullptr; return pb; }
+        x = causal_lm::block_prefill_batched(ctx, gf, x, to_block_view(weights.dec_blocks[il], scale), block_params,
+                                             kv_cache, il, T_prompt, B, pb.mask_in, pb.positions_in, pb.kv_idx_in,
+                                             use_flash);
+        if (x == nullptr) {
+            pb.graph = nullptr;
+            return pb;
+        }
     }
 
     // Gather each row's last real position (= T_prompt-1), final RMSNorm, TIED head.
     ggml_tensor * x_last = ggml_get_rows(ctx, x, pb.last_idx_in);
-    x_last = ggml_reshape_2d(ctx, x_last, hidden, B);
-    x_last = ggml_mul(ctx, ggml_rms_norm(ctx, x_last, rms_eps), weights.dec_final.norm_w);
+    x_last               = ggml_reshape_2d(ctx, x_last, hidden, B);
+    x_last               = ggml_mul(ctx, ggml_rms_norm(ctx, x_last, rms_eps), weights.dec_final.norm_w);
     ggml_tensor * logits = ggml_mul_mat(ctx, weights.dec_embed.token_w, x_last);  // TIED
-    logits = ggml_reshape_2d(ctx, logits, vocab, B);
-    pb.logits = logits;
-    pb.out = ggml_argmax(ctx, logits);
+    logits               = ggml_reshape_2d(ctx, logits, vocab, B);
+    pb.logits            = logits;
+    pb.out               = ggml_argmax(ctx, logits);
     named(pb.out, "dec.batched.argmax");
     ggml_set_output(pb.out);
     ggml_build_forward_expand(gf, pb.out);
@@ -399,32 +419,30 @@ PrefillBuildBatched build_prefill_graph_batched(
     return pb;
 }
 
-StepBuildBatched build_step_graph_batched(
-    ggml_context *                  ctx,
-    const Weights &                 weights,
-    const HParams &                 hp,
-    transcribe::causal_lm::KvCache & kv_cache,
-    ggml_tensor *                   ada_scale_all,
-    int                             max_n_kv,
-    int                             n_batch,
-    bool                            use_flash) {
-    StepBuildBatched sb {};
+StepBuildBatched build_step_graph_batched(ggml_context *                   ctx,
+                                          const Weights &                  weights,
+                                          const HParams &                  hp,
+                                          transcribe::causal_lm::KvCache & kv_cache,
+                                          ggml_tensor *                    ada_scale_all,
+                                          int                              max_n_kv,
+                                          int                              n_batch,
+                                          bool                             use_flash) {
+    StepBuildBatched sb{};
     sb.max_n_kv = max_n_kv;
     sb.n_batch  = n_batch;
-    if (ctx == nullptr || max_n_kv <= 0 || n_batch <= 0 || !use_flash ||
-        kv_cache.self_k == nullptr || kv_cache.n_batch != n_batch ||
-        max_n_kv > kv_cache.n_ctx) {
+    if (ctx == nullptr || max_n_kv <= 0 || n_batch <= 0 || !use_flash || kv_cache.self_k == nullptr ||
+        kv_cache.n_batch != n_batch || max_n_kv > kv_cache.n_ctx) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral_realtime step(batched): invalid arg (max_n_kv=%d, n_batch=%d)",
-                     max_n_kv, n_batch);
+                max_n_kv, n_batch);
         return sb;
     }
 
-    const int64_t hidden  = hp.dec_hidden;
-    const int64_t vocab   = hp.dec_vocab_size;
-    const int     n_layer = hp.dec_n_layers;
-    const float   rms_eps = hp.dec_rms_norm_eps;
-    const int     B       = n_batch;
-    const auto block_params = to_block_params(hp);
+    const int64_t hidden       = hp.dec_hidden;
+    const int64_t vocab        = hp.dec_vocab_size;
+    const int     n_layer      = hp.dec_n_layers;
+    const float   rms_eps      = hp.dec_rms_norm_eps;
+    const int     B            = n_batch;
+    const auto    block_params = to_block_params(hp);
 
     sb.input_ids_in = ggml_new_tensor_1d(ctx, GGML_TYPE_I32, B);
     named(sb.input_ids_in, "step.batched.input_ids");
@@ -443,26 +461,31 @@ StepBuildBatched build_step_graph_batched(
     ggml_set_input(sb.mask_in);
 
     ggml_cgraph * gf = ggml_new_graph_custom(ctx, /*size=*/8192, /*grads=*/false);
-    if (gf == nullptr) { log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral_realtime step(batched): graph alloc failed"); return sb; }
+    if (gf == nullptr) {
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral_realtime step(batched): graph alloc failed");
+        return sb;
+    }
     sb.graph = gf;
 
     ggml_tensor * x = ggml_get_rows(ctx, weights.dec_embed.token_w, sb.input_ids_in);  // [hidden, B]
-    x = ggml_add(ctx, x, sb.audio_in);  // per-step additive audio overlay (1 frame/row)
+    x               = ggml_add(ctx, x, sb.audio_in);  // per-step additive audio overlay (1 frame/row)
 
     for (int il = 0; il < n_layer; ++il) {
         ggml_tensor * scale = ada_scale_for(ctx, ada_scale_all, hidden, il);
-        x = causal_lm::block_step_batched(
-            ctx, gf, x, to_block_view(weights.dec_blocks[il], scale),
-            block_params, kv_cache, il, max_n_kv, B,
-            sb.mask_in, sb.position_in, sb.kv_idx_in, use_flash);
-        if (x == nullptr) { sb.graph = nullptr; return sb; }
+        x = causal_lm::block_step_batched(ctx, gf, x, to_block_view(weights.dec_blocks[il], scale), block_params,
+                                          kv_cache, il, max_n_kv, B, sb.mask_in, sb.position_in, sb.kv_idx_in,
+                                          use_flash);
+        if (x == nullptr) {
+            sb.graph = nullptr;
+            return sb;
+        }
     }
 
-    x = ggml_mul(ctx, ggml_rms_norm(ctx, x, rms_eps), weights.dec_final.norm_w);
+    x                    = ggml_mul(ctx, ggml_rms_norm(ctx, x, rms_eps), weights.dec_final.norm_w);
     ggml_tensor * logits = ggml_mul_mat(ctx, weights.dec_embed.token_w, x);  // TIED
-    logits = ggml_reshape_2d(ctx, logits, vocab, B);
-    sb.logits = logits;
-    sb.out = ggml_argmax(ctx, logits);
+    logits               = ggml_reshape_2d(ctx, logits, vocab, B);
+    sb.logits            = logits;
+    sb.out               = ggml_argmax(ctx, logits);
     named(sb.out, "step.batched.argmax");
     ggml_set_output(sb.out);
     ggml_build_forward_expand(gf, sb.out);
@@ -470,4 +493,4 @@ StepBuildBatched build_step_graph_batched(
     return sb;
 }
 
-} // namespace transcribe::voxtral_realtime
+}  // namespace transcribe::voxtral_realtime
diff --git a/src/arch/voxtral_realtime/decoder.h b/src/arch/voxtral_realtime/decoder.h
index ba277e46..7008d59d 100644
--- a/src/arch/voxtral_realtime/decoder.h
+++ b/src/arch/voxtral_realtime/decoder.h
@@ -11,11 +11,10 @@
 
 #pragma once
 
-#include "voxtral_realtime.h"
 #include "causal_lm/causal_lm.h"
-#include "weights.h"
-
 #include "ggml.h"
+#include "voxtral_realtime.h"
+#include "weights.h"
 
 struct ggml_context;
 struct ggml_cgraph;
@@ -39,22 +38,22 @@ struct PrefillBuild {
     ggml_tensor * positions_in = nullptr;  // [T] i32
     ggml_tensor * mask_in      = nullptr;  // [T, T] f16 causal
     ggml_tensor * out          = nullptr;  // logits ([vocab] last pos, or [vocab,T])
-    DecoderDumps  dumps {};
-    ggml_cgraph * graph        = nullptr;
-    int T = 0;
+    DecoderDumps  dumps{};
+    ggml_cgraph * graph = nullptr;
+    int           T     = 0;
 };
 
 // Teacher-forced / prompt prefill over T positions with additive audio overlay.
 // want_all_logits=true exposes logits for every position (dump path: read
 // gen0/gen8 columns); false slices the last position (autoregressive prefill).
-PrefillBuild build_prefill_graph(ggml_context *                  ctx,
-                                 const Weights &                 weights,
-                                 const HParams &                 hp,
+PrefillBuild build_prefill_graph(ggml_context *                   ctx,
+                                 const Weights &                  weights,
+                                 const HParams &                  hp,
                                  transcribe::causal_lm::KvCache & kv_cache,
-                                 ggml_tensor *                   ada_scale_all,
-                                 int                             T,
-                                 bool                            use_flash,
-                                 bool                            want_all_logits);
+                                 ggml_tensor *                    ada_scale_all,
+                                 int                              T,
+                                 bool                             use_flash,
+                                 bool                             want_all_logits);
 
 struct StepBuild {
     ggml_tensor * input_id_in = nullptr;  // [1] i32
@@ -65,16 +64,16 @@ struct StepBuild {
     ggml_tensor * out         = nullptr;  // [1] i32 argmax
     ggml_tensor * logits      = nullptr;  // [vocab] f32
     ggml_cgraph * graph       = nullptr;
-    int max_n_kv = 0;
+    int           max_n_kv    = 0;
 };
 
-StepBuild build_step_graph(ggml_context *                  ctx,
-                           const Weights &                 weights,
-                           const HParams &                 hp,
+StepBuild build_step_graph(ggml_context *                   ctx,
+                           const Weights &                  weights,
+                           const HParams &                  hp,
                            transcribe::causal_lm::KvCache & kv_cache,
-                           ggml_tensor *                   ada_scale_all,
-                           int                             max_n_kv,
-                           bool                            use_flash);
+                           ggml_tensor *                    ada_scale_all,
+                           int                              max_n_kv,
+                           bool                             use_flash);
 
 // ---------------------------------------------------------------------------
 // Multi-position verify (speculative decode)
@@ -94,18 +93,18 @@ struct VerifyBuild {
     ggml_tensor * out          = nullptr;  // [T_verify] i32 argmax
     ggml_tensor * logits       = nullptr;  // [vocab, T_verify] f32
     ggml_cgraph * graph        = nullptr;
-    int T_verify = 0;
-    int max_n_kv = 0;
+    int           T_verify     = 0;
+    int           max_n_kv     = 0;
 };
 
-VerifyBuild build_verify_graph(ggml_context *                  ctx,
-                               const Weights &                 weights,
-                               const HParams &                 hp,
+VerifyBuild build_verify_graph(ggml_context *                   ctx,
+                               const Weights &                  weights,
+                               const HParams &                  hp,
                                transcribe::causal_lm::KvCache & kv_cache,
-                               ggml_tensor *                   ada_scale_all,
-                               int                             T_verify,
-                               int                             max_n_kv,
-                               bool                            use_flash);
+                               ggml_tensor *                    ada_scale_all,
+                               int                              T_verify,
+                               int                              max_n_kv,
+                               bool                             use_flash);
 
 // ---------------------------------------------------------------------------
 // Batched prefill / step (offline transcribe_run_batch)
@@ -129,19 +128,18 @@ struct PrefillBuildBatched {
     ggml_tensor * out            = nullptr;  // [B] i32 argmax (first generated token)
     ggml_tensor * logits         = nullptr;  // [vocab, B] f32
     ggml_cgraph * graph          = nullptr;
-    int T_prompt = 0;
-    int n_batch  = 0;
+    int           T_prompt       = 0;
+    int           n_batch        = 0;
 };
 
-PrefillBuildBatched build_prefill_graph_batched(
-    ggml_context *                  ctx,
-    const Weights &                 weights,
-    const HParams &                 hp,
-    transcribe::causal_lm::KvCache & kv_cache,
-    ggml_tensor *                   ada_scale_all,
-    int                             T_prompt,
-    int                             n_batch,
-    bool                            use_flash);
+PrefillBuildBatched build_prefill_graph_batched(ggml_context *                   ctx,
+                                                const Weights &                  weights,
+                                                const HParams &                  hp,
+                                                transcribe::causal_lm::KvCache & kv_cache,
+                                                ggml_tensor *                    ada_scale_all,
+                                                int                              T_prompt,
+                                                int                              n_batch,
+                                                bool                             use_flash);
 
 struct StepBuildBatched {
     ggml_tensor * input_ids_in = nullptr;  // [B] i32
@@ -152,18 +150,17 @@ struct StepBuildBatched {
     ggml_tensor * out          = nullptr;  // [B] i32 argmax
     ggml_tensor * logits       = nullptr;  // [vocab, B] f32
     ggml_cgraph * graph        = nullptr;
-    int max_n_kv = 0;
-    int n_batch  = 0;
+    int           max_n_kv     = 0;
+    int           n_batch      = 0;
 };
 
-StepBuildBatched build_step_graph_batched(
-    ggml_context *                  ctx,
-    const Weights &                 weights,
-    const HParams &                 hp,
-    transcribe::causal_lm::KvCache & kv_cache,
-    ggml_tensor *                   ada_scale_all,
-    int                             max_n_kv,
-    int                             n_batch,
-    bool                            use_flash);
-
-} // namespace transcribe::voxtral_realtime
+StepBuildBatched build_step_graph_batched(ggml_context *                   ctx,
+                                          const Weights &                  weights,
+                                          const HParams &                  hp,
+                                          transcribe::causal_lm::KvCache & kv_cache,
+                                          ggml_tensor *                    ada_scale_all,
+                                          int                              max_n_kv,
+                                          int                              n_batch,
+                                          bool                             use_flash);
+
+}  // namespace transcribe::voxtral_realtime
diff --git a/src/arch/voxtral_realtime/encoder.cpp b/src/arch/voxtral_realtime/encoder.cpp
index a24b9e52..fcf242ae 100644
--- a/src/arch/voxtral_realtime/encoder.cpp
+++ b/src/arch/voxtral_realtime/encoder.cpp
@@ -18,13 +18,11 @@
 
 #include "encoder.h"
 
-#include "weights.h"
-
 #include "conformer/conformer.h"
+#include "ggml.h"
 #include "transcribe-debug.h"
 #include "transcribe-log.h"
-
-#include "ggml.h"
+#include "weights.h"
 
 #include <cmath>
 #include <cstdio>
@@ -34,8 +32,8 @@ namespace transcribe::voxtral_realtime {
 namespace {
 
 namespace conf = transcribe::conformer;
-using conf::named;
 using conf::conv_1d_f32;
+using conf::named;
 
 ggml_tensor * rms_norm(ggml_context * ctx, ggml_tensor * x, ggml_tensor * w, float eps) {
     return ggml_mul(ctx, ggml_rms_norm(ctx, x, eps), w);
@@ -43,43 +41,51 @@ ggml_tensor * rms_norm(ggml_context * ctx, ggml_tensor * x, ggml_tensor * w, flo
 
 // Reshape a 1D conv bias [Cout] into [1, Cout, 1, 1] so it broadcasts across T.
 ggml_tensor * add_conv1d_bias(ggml_context * ctx, ggml_tensor * conv_out, ggml_tensor * bias_1d) {
-    if (bias_1d == nullptr) return conv_out;
+    if (bias_1d == nullptr) {
+        return conv_out;
+    }
     ggml_tensor * b4 = ggml_reshape_4d(ctx, bias_1d, 1, bias_1d->ne[0], 1, 1);
     return ggml_add(ctx, conv_out, b4);
 }
 
 // Left-pad the time axis (ne[0]) by `lp` zeros, then conv with padding=0:
 // causal Conv1d (output position t sees only inputs <= t).
-ggml_tensor * causal_conv(ggml_context * ctx, ggml_tensor * kernel, ggml_tensor * x,
-                          int stride, int left_pad) {
+ggml_tensor * causal_conv(ggml_context * ctx, ggml_tensor * kernel, ggml_tensor * x, int stride, int left_pad) {
     ggml_tensor * xp = ggml_pad_ext(ctx, x, left_pad, 0, 0, 0, 0, 0, 0, 0);
     return conv_1d_f32(ctx, kernel, xp, stride, /*padding=*/0, /*dilation=*/1);
 }
 
 // Full-MHA self-attention with NEOX RoPE + host-prepared sliding-window-causal
 // mask. x:[d_model, T]; q/v/out bias, k none.
-ggml_tensor * mha(ggml_context * ctx, ggml_tensor * x,
-                  const EncBlock & b, ggml_tensor * positions, ggml_tensor * mask,
-                  int n_heads, int head_dim, int d_model, float rope_theta,
-                  int max_pos, bool use_flash) {
+ggml_tensor * mha(ggml_context *   ctx,
+                  ggml_tensor *    x,
+                  const EncBlock & b,
+                  ggml_tensor *    positions,
+                  ggml_tensor *    mask,
+                  int              n_heads,
+                  int              head_dim,
+                  int              d_model,
+                  float            rope_theta,
+                  int              max_pos,
+                  bool             use_flash) {
     const int64_t T     = x->ne[1];
     const int64_t q_dim = static_cast<int64_t>(n_heads) * head_dim;
     const float   scale = 1.0f / std::sqrt(static_cast<float>(head_dim));
 
     ggml_tensor * Q = ggml_mul_mat(ctx, b.attn_q_w, x);
-    Q = ggml_add(ctx, Q, b.attn_q_b);
-    ggml_tensor * K = ggml_mul_mat(ctx, b.attn_k_w, x);   // no bias
+    Q               = ggml_add(ctx, Q, b.attn_q_b);
+    ggml_tensor * K = ggml_mul_mat(ctx, b.attn_k_w, x);  // no bias
     ggml_tensor * V = ggml_mul_mat(ctx, b.attn_v_w, x);
-    V = ggml_add(ctx, V, b.attn_v_b);
+    V               = ggml_add(ctx, V, b.attn_v_b);
 
     Q = ggml_reshape_4d(ctx, Q, head_dim, n_heads, T, 1);
     K = ggml_reshape_4d(ctx, K, head_dim, n_heads, T, 1);
     V = ggml_reshape_4d(ctx, V, head_dim, n_heads, T, 1);
 
-    Q = ggml_rope_ext(ctx, Q, positions, nullptr, head_dim, GGML_ROPE_TYPE_NEOX,
-                      max_pos, rope_theta, 1.0f, 0.0f, 1.0f, 32.0f, 1.0f);
-    K = ggml_rope_ext(ctx, K, positions, nullptr, head_dim, GGML_ROPE_TYPE_NEOX,
-                      max_pos, rope_theta, 1.0f, 0.0f, 1.0f, 32.0f, 1.0f);
+    Q = ggml_rope_ext(ctx, Q, positions, nullptr, head_dim, GGML_ROPE_TYPE_NEOX, max_pos, rope_theta, 1.0f, 0.0f, 1.0f,
+                      32.0f, 1.0f);
+    K = ggml_rope_ext(ctx, K, positions, nullptr, head_dim, GGML_ROPE_TYPE_NEOX, max_pos, rope_theta, 1.0f, 0.0f, 1.0f,
+                      32.0f, 1.0f);
 
     // [D, H, T, 1] -> [D, T, H, 1]
     ggml_tensor * Q_att = ggml_cont(ctx, ggml_permute(ctx, Q, 0, 2, 1, 3));
@@ -94,9 +100,9 @@ ggml_tensor * mha(ggml_context * ctx, ggml_tensor * x,
         ggml_tensor * kq      = ggml_mul_mat(ctx, K_att, Q_att);
         ggml_tensor * kq_soft = ggml_soft_max_ext(ctx, kq, mask, scale, 0.0f);
         ggml_tensor * V_t     = ggml_cont(ctx, ggml_permute(ctx, V_att, 1, 0, 2, 3));
-        o = ggml_mul_mat(ctx, V_t, kq_soft);
-        o = ggml_cont(ctx, ggml_permute(ctx, o, 0, 2, 1, 3));
-        o = ggml_reshape_2d(ctx, o, q_dim, T);
+        o                     = ggml_mul_mat(ctx, V_t, kq_soft);
+        o                     = ggml_cont(ctx, ggml_permute(ctx, o, 0, 2, 1, 3));
+        o                     = ggml_reshape_2d(ctx, o, q_dim, T);
     }
 
     o = ggml_mul_mat(ctx, b.attn_out_w, o);
@@ -108,17 +114,24 @@ ggml_tensor * mha(ggml_context * ctx, ggml_tensor * x,
 // sw-causal `mask [T, T]` are SHARED across the batch (the encoder is causal, so
 // right-pad rows are numerically isolated and need no per-row mask). Mirrors
 // `mha` with the batch riding ne[2] of x (ne[3] of the per-head tensors).
-ggml_tensor * mha_batched(ggml_context * ctx, ggml_tensor * x,
-                          const EncBlock & b, ggml_tensor * positions, ggml_tensor * mask,
-                          int n_heads, int head_dim, int /*d_model*/, float rope_theta,
-                          int max_pos, bool use_flash) {
+ggml_tensor * mha_batched(ggml_context *   ctx,
+                          ggml_tensor *    x,
+                          const EncBlock & b,
+                          ggml_tensor *    positions,
+                          ggml_tensor *    mask,
+                          int              n_heads,
+                          int              head_dim,
+                          int /*d_model*/,
+                          float rope_theta,
+                          int   max_pos,
+                          bool  use_flash) {
     const int64_t T     = x->ne[1];
     const int64_t B     = x->ne[2];
     const int64_t q_dim = static_cast<int64_t>(n_heads) * head_dim;
     const float   scale = 1.0f / std::sqrt(static_cast<float>(head_dim));
 
     ggml_tensor * Q = ggml_add(ctx, ggml_mul_mat(ctx, b.attn_q_w, x), b.attn_q_b);
-    ggml_tensor * K = ggml_mul_mat(ctx, b.attn_k_w, x);   // no bias
+    ggml_tensor * K = ggml_mul_mat(ctx, b.attn_k_w, x);  // no bias
     ggml_tensor * V = ggml_add(ctx, ggml_mul_mat(ctx, b.attn_v_w, x), b.attn_v_b);
 
     Q = ggml_reshape_4d(ctx, Q, head_dim, n_heads, T, B);
@@ -126,10 +139,10 @@ ggml_tensor * mha_batched(ggml_context * ctx, ggml_tensor * x,
     V = ggml_reshape_4d(ctx, V, head_dim, n_heads, T, B);
 
     // positions[T] indexes ne[2]=T; the batch rides ne[3]=B (shared positions).
-    Q = ggml_rope_ext(ctx, Q, positions, nullptr, head_dim, GGML_ROPE_TYPE_NEOX,
-                      max_pos, rope_theta, 1.0f, 0.0f, 1.0f, 32.0f, 1.0f);
-    K = ggml_rope_ext(ctx, K, positions, nullptr, head_dim, GGML_ROPE_TYPE_NEOX,
-                      max_pos, rope_theta, 1.0f, 0.0f, 1.0f, 32.0f, 1.0f);
+    Q = ggml_rope_ext(ctx, Q, positions, nullptr, head_dim, GGML_ROPE_TYPE_NEOX, max_pos, rope_theta, 1.0f, 0.0f, 1.0f,
+                      32.0f, 1.0f);
+    K = ggml_rope_ext(ctx, K, positions, nullptr, head_dim, GGML_ROPE_TYPE_NEOX, max_pos, rope_theta, 1.0f, 0.0f, 1.0f,
+                      32.0f, 1.0f);
 
     // [D, H, T, B] -> [D, T, H, B]
     ggml_tensor * Q_att = ggml_cont(ctx, ggml_permute(ctx, Q, 0, 2, 1, 3));
@@ -143,12 +156,12 @@ ggml_tensor * mha_batched(ggml_context * ctx, ggml_tensor * x,
         o = ggml_flash_attn_ext(ctx, Q_att, K_att, V_att, mask, scale, 0.0f, 0.0f);
         o = ggml_reshape_3d(ctx, o, q_dim, T, B);
     } else {
-        ggml_tensor * kq      = ggml_mul_mat(ctx, K_att, Q_att);             // [T, T, H, B]
+        ggml_tensor * kq      = ggml_mul_mat(ctx, K_att, Q_att);                       // [T, T, H, B]
         ggml_tensor * kq_soft = ggml_soft_max_ext(ctx, kq, mask, scale, 0.0f);
         ggml_tensor * V_t     = ggml_cont(ctx, ggml_permute(ctx, V_att, 1, 0, 2, 3));  // [T, D, H, B]
-        o = ggml_mul_mat(ctx, V_t, kq_soft);                                // [D, T, H, B]
-        o = ggml_cont(ctx, ggml_permute(ctx, o, 0, 2, 1, 3));               // [D, H, T, B]
-        o = ggml_reshape_3d(ctx, o, q_dim, T, B);
+        o                     = ggml_mul_mat(ctx, V_t, kq_soft);                       // [D, T, H, B]
+        o                     = ggml_cont(ctx, ggml_permute(ctx, o, 0, 2, 1, 3));      // [D, H, T, B]
+        o                     = ggml_reshape_3d(ctx, o, q_dim, T, B);
     }
 
     o = ggml_add(ctx, ggml_mul_mat(ctx, b.attn_out_w, o), b.attn_out_b);
@@ -161,7 +174,7 @@ ggml_tensor * mlp(ggml_context * ctx, ggml_tensor * x, const EncBlock & b) {
     ggml_tensor * u = ggml_mul_mat(ctx, b.ffn_up_w, x);
     ggml_tensor * h = ggml_mul(ctx, ggml_silu(ctx, g), u);
     ggml_tensor * o = ggml_mul_mat(ctx, b.ffn_down_w, h);
-    o = ggml_add(ctx, o, b.ffn_down_b);
+    o               = ggml_add(ctx, o, b.ffn_down_b);
     return o;
 }
 
@@ -171,12 +184,23 @@ ggml_tensor * mlp(ggml_context * ctx, ggml_tensor * x, const EncBlock & b) {
 // window under the host sliding-window-causal `mask` [read_len, n_new] (built
 // from ABSOLUTE positions by the caller). MHA (n_kv_heads==n_heads), so no GQA
 // repeat. q/v/out carry bias; k none. NEOX RoPE at absolute positions.
-ggml_tensor * mha_cached(ggml_context * ctx, ggml_cgraph * gf, ggml_tensor * x,
-                         const EncBlock & b, ggml_tensor * positions, ggml_tensor * mask,
-                         transcribe::causal_lm::KvCache & kv, int layer,
-                         int n_new, int write_slot, int read_start, int read_len,
-                         int n_heads, int head_dim, float rope_theta,
-                         int max_pos, bool use_flash) {
+ggml_tensor * mha_cached(ggml_context *                   ctx,
+                         ggml_cgraph *                    gf,
+                         ggml_tensor *                    x,
+                         const EncBlock &                 b,
+                         ggml_tensor *                    positions,
+                         ggml_tensor *                    mask,
+                         transcribe::causal_lm::KvCache & kv,
+                         int                              layer,
+                         int                              n_new,
+                         int                              write_slot,
+                         int                              read_start,
+                         int                              read_len,
+                         int                              n_heads,
+                         int                              head_dim,
+                         float                            rope_theta,
+                         int                              max_pos,
+                         bool                             use_flash) {
     const int64_t q_dim  = static_cast<int64_t>(n_heads) * head_dim;
     const int64_t kv_dim = static_cast<int64_t>(n_heads) * head_dim;  // MHA
     const int     n_ctx  = kv.n_ctx;
@@ -185,39 +209,37 @@ ggml_tensor * mha_cached(ggml_context * ctx, ggml_cgraph * gf, ggml_tensor * x,
     const size_t  v_elem = ggml_element_size(kv.self_v);
 
     ggml_tensor * Q = ggml_add(ctx, ggml_mul_mat(ctx, b.attn_q_w, x), b.attn_q_b);
-    ggml_tensor * K = ggml_mul_mat(ctx, b.attn_k_w, x);   // no bias
+    ggml_tensor * K = ggml_mul_mat(ctx, b.attn_k_w, x);  // no bias
     ggml_tensor * V = ggml_add(ctx, ggml_mul_mat(ctx, b.attn_v_w, x), b.attn_v_b);
 
     Q = ggml_reshape_4d(ctx, Q, head_dim, n_heads, n_new, 1);
     K = ggml_reshape_4d(ctx, K, head_dim, n_heads, n_new, 1);
     V = ggml_reshape_4d(ctx, V, head_dim, n_heads, n_new, 1);
 
-    Q = ggml_rope_ext(ctx, Q, positions, nullptr, head_dim, GGML_ROPE_TYPE_NEOX,
-                      max_pos, rope_theta, 1.0f, 0.0f, 1.0f, 32.0f, 1.0f);
-    K = ggml_rope_ext(ctx, K, positions, nullptr, head_dim, GGML_ROPE_TYPE_NEOX,
-                      max_pos, rope_theta, 1.0f, 0.0f, 1.0f, 32.0f, 1.0f);
+    Q = ggml_rope_ext(ctx, Q, positions, nullptr, head_dim, GGML_ROPE_TYPE_NEOX, max_pos, rope_theta, 1.0f, 0.0f, 1.0f,
+                      32.0f, 1.0f);
+    K = ggml_rope_ext(ctx, K, positions, nullptr, head_dim, GGML_ROPE_TYPE_NEOX, max_pos, rope_theta, 1.0f, 0.0f, 1.0f,
+                      32.0f, 1.0f);
 
     // Write K/V into the cache ring at rows [write_slot, write_slot + n_new). K/V
     // memory order (fastest->slowest) is D,H,T == position-major within the slab.
-    const size_t write_off =
-        (static_cast<size_t>(layer) * n_ctx + static_cast<size_t>(write_slot)) * kv_dim;
+    const size_t write_off = (static_cast<size_t>(layer) * n_ctx + static_cast<size_t>(write_slot)) * kv_dim;
     // The cache read views below are graph LEAVES (views of self_k/self_v), so
     // the cpy writes are not their ancestors — root them in the graph directly.
     {
-        const size_t n_elem = static_cast<size_t>(n_new) * kv_dim;
-        ggml_tensor * k_dst = ggml_view_1d(ctx, kv.self_k, n_elem, k_elem * write_off);
-        ggml_tensor * v_dst = ggml_view_1d(ctx, kv.self_v, n_elem, v_elem * write_off);
+        const size_t  n_elem = static_cast<size_t>(n_new) * kv_dim;
+        ggml_tensor * k_dst  = ggml_view_1d(ctx, kv.self_k, n_elem, k_elem * write_off);
+        ggml_tensor * v_dst  = ggml_view_1d(ctx, kv.self_v, n_elem, v_elem * write_off);
         ggml_build_forward_expand(gf, ggml_cpy(ctx, K, k_dst));
         ggml_build_forward_expand(gf, ggml_cpy(ctx, V, v_dst));
     }
 
     // Read the [read_start, read_start + read_len) window for this layer.
-    const size_t read_off =
-        (static_cast<size_t>(layer) * n_ctx + static_cast<size_t>(read_start)) * kv_dim;
-    ggml_tensor * K_att = ggml_view_3d(ctx, kv.self_k, head_dim, read_len, n_heads,
-                                       k_elem * kv_dim, k_elem * head_dim, k_elem * read_off);
-    ggml_tensor * V_att = ggml_view_3d(ctx, kv.self_v, head_dim, read_len, n_heads,
-                                       v_elem * kv_dim, v_elem * head_dim, v_elem * read_off);
+    const size_t  read_off = (static_cast<size_t>(layer) * n_ctx + static_cast<size_t>(read_start)) * kv_dim;
+    ggml_tensor * K_att = ggml_view_3d(ctx, kv.self_k, head_dim, read_len, n_heads, k_elem * kv_dim, k_elem * head_dim,
+                                       k_elem * read_off);
+    ggml_tensor * V_att = ggml_view_3d(ctx, kv.self_v, head_dim, read_len, n_heads, v_elem * kv_dim, v_elem * head_dim,
+                                       v_elem * read_off);
 
     ggml_tensor * Q_att = ggml_cont(ctx, ggml_permute(ctx, Q, 0, 2, 1, 3));  // [D, n_new, H]
 
@@ -227,26 +249,26 @@ ggml_tensor * mha_cached(ggml_context * ctx, ggml_cgraph * gf, ggml_tensor * x,
         o = ggml_reshape_2d(ctx, o, q_dim, n_new);
     } else {
         ggml_tensor * K_att_c = ggml_cont(ctx, K_att);
-        ggml_tensor * kq      = ggml_mul_mat(ctx, K_att_c, Q_att);          // [n_kv, n_new, H]
+        ggml_tensor * kq      = ggml_mul_mat(ctx, K_att_c, Q_att);                     // [n_kv, n_new, H]
         ggml_tensor * kq_soft = ggml_soft_max_ext(ctx, kq, mask, scale, 0.0f);
         ggml_tensor * V_t     = ggml_cont(ctx, ggml_permute(ctx, V_att, 1, 0, 2, 3));  // [n_kv, D, H]
-        o = ggml_mul_mat(ctx, V_t, kq_soft);                                // [D, n_new, H]
-        o = ggml_cont(ctx, ggml_permute(ctx, o, 0, 2, 1, 3));               // [D, H, n_new]
-        o = ggml_reshape_2d(ctx, o, q_dim, n_new);
+        o                     = ggml_mul_mat(ctx, V_t, kq_soft);                       // [D, n_new, H]
+        o                     = ggml_cont(ctx, ggml_permute(ctx, o, 0, 2, 1, 3));      // [D, H, n_new]
+        o                     = ggml_reshape_2d(ctx, o, q_dim, n_new);
     }
 
     o = ggml_add(ctx, ggml_mul_mat(ctx, b.attn_out_w, o), b.attn_out_b);
     return o;
 }
 
-} // namespace
+}  // namespace
 
-EncoderBuild build_encoder_graph(ggml_context * ctx,
+EncoderBuild build_encoder_graph(ggml_context *  ctx,
                                  const Weights & w,
                                  const HParams & hp,
                                  int             n_mel_frames,
                                  bool            use_flash) {
-    EncoderBuild eb {};
+    EncoderBuild eb{};
 
     if (ctx == nullptr || n_mel_frames <= 4) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral_realtime encoder: invalid n_mel_frames=%d", n_mel_frames);
@@ -265,7 +287,7 @@ EncoderBuild build_encoder_graph(ggml_context * ctx,
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral_realtime encoder: T_enc=%d too small", T_enc);
         return eb;
     }
-    eb.T_enc = T_enc;
+    eb.T_enc   = T_enc;
     eb.n_audio = n_audio;
 
     // ---- inputs ----
@@ -283,13 +305,13 @@ EncoderBuild build_encoder_graph(ggml_context * ctx,
 
     // ---- causal conv stem ----
     ggml_tensor * x = ggml_cont(ctx, ggml_transpose(ctx, eb.mel_in));  // [T_mel, n_mels]
-    x = causal_conv(ctx, w.enc_stem.conv0_w, x, /*stride=*/1, /*left_pad=*/2);
-    x = add_conv1d_bias(ctx, x, w.enc_stem.conv0_b);
-    x = ggml_gelu_erf(ctx, x);                                          // [T_mel, d_model]
-    x = causal_conv(ctx, w.enc_stem.conv1_w, x, /*stride=*/2, /*left_pad=*/1);
-    x = add_conv1d_bias(ctx, x, w.enc_stem.conv1_b);
-    x = ggml_gelu_erf(ctx, x);                                          // [T_enc, d_model]
-    x = ggml_cont(ctx, ggml_transpose(ctx, x));                         // [d_model, T_enc]
+    x               = causal_conv(ctx, w.enc_stem.conv0_w, x, /*stride=*/1, /*left_pad=*/2);
+    x               = add_conv1d_bias(ctx, x, w.enc_stem.conv0_b);
+    x               = ggml_gelu_erf(ctx, x);  // [T_mel, d_model]
+    x               = causal_conv(ctx, w.enc_stem.conv1_w, x, /*stride=*/2, /*left_pad=*/1);
+    x               = add_conv1d_bias(ctx, x, w.enc_stem.conv1_b);
+    x               = ggml_gelu_erf(ctx, x);                   // [T_enc, d_model]
+    x               = ggml_cont(ctx, ggml_transpose(ctx, x));  // [d_model, T_enc]
     named(x, "enc.embedder.out");
     eb.dumps.embedder_out = x;
     transcribe::debug::mark_tensor_for_dump(x);
@@ -301,14 +323,14 @@ EncoderBuild build_encoder_graph(ggml_context * ctx,
         const EncBlock & b = w.enc_blocks[i];
         {
             ggml_tensor * y = rms_norm(ctx, x, b.norm_attn_w, hp.enc_rms_norm_eps);
-            y = mha(ctx, y, b, eb.positions_in, eb.mask_in,
-                    n_heads, head_dim, d_model, hp.enc_rope_theta, hp.enc_max_pos, use_flash);
-            x = ggml_add(ctx, x, y);
+            y               = mha(ctx, y, b, eb.positions_in, eb.mask_in, n_heads, head_dim, d_model, hp.enc_rope_theta,
+                                  hp.enc_max_pos, use_flash);
+            x               = ggml_add(ctx, x, y);
         }
         {
             ggml_tensor * y = rms_norm(ctx, x, b.norm_ffn_w, hp.enc_rms_norm_eps);
-            y = mlp(ctx, y, b);
-            x = ggml_add(ctx, x, y);
+            y               = mlp(ctx, y, b);
+            x               = ggml_add(ctx, x, y);
         }
         char bname[64];
         std::snprintf(bname, sizeof(bname), "enc.block.%d.out", i);
@@ -332,9 +354,9 @@ EncoderBuild build_encoder_graph(ggml_context * ctx,
         xc = ggml_cont(ctx, xc);
     }
     ggml_tensor * grouped = ggml_reshape_2d(ctx, xc, hp.proj_in, n_audio);
-    ggml_tensor * p = ggml_mul_mat(ctx, w.proj.linear_1_w, grouped);
-    p = ggml_gelu_erf(ctx, p);
-    p = ggml_mul_mat(ctx, w.proj.linear_2_w, p);
+    ggml_tensor * p       = ggml_mul_mat(ctx, w.proj.linear_1_w, grouped);
+    p                     = ggml_gelu_erf(ctx, p);
+    p                     = ggml_mul_mat(ctx, w.proj.linear_2_w, p);
     named(p, "proj.out");
     eb.dumps.proj_out = p;
     transcribe::debug::mark_tensor_for_dump(p);
@@ -348,26 +370,32 @@ EncoderBuild build_encoder_graph(ggml_context * ctx,
         return eb;
     }
     ggml_build_forward_expand(eb.graph, eb.out);
-    if (eb.dumps.embedder_out) ggml_build_forward_expand(eb.graph, eb.dumps.embedder_out);
-    if (eb.dumps.enc_out)      ggml_build_forward_expand(eb.graph, eb.dumps.enc_out);
-    for (ggml_tensor * t : eb.dumps.block_outs) ggml_build_forward_expand(eb.graph, t);
+    if (eb.dumps.embedder_out) {
+        ggml_build_forward_expand(eb.graph, eb.dumps.embedder_out);
+    }
+    if (eb.dumps.enc_out) {
+        ggml_build_forward_expand(eb.graph, eb.dumps.enc_out);
+    }
+    for (ggml_tensor * t : eb.dumps.block_outs) {
+        ggml_build_forward_expand(eb.graph, t);
+    }
 
     return eb;
 }
 
-EncoderBuildBatched build_encoder_graph_batched(ggml_context * ctx,
+EncoderBuildBatched build_encoder_graph_batched(ggml_context *  ctx,
                                                 const Weights & w,
                                                 const HParams & hp,
                                                 int             n_mel_frames,
                                                 int             n_batch,
                                                 bool            use_flash) {
-    EncoderBuildBatched eb {};
+    EncoderBuildBatched eb{};
 
     if (ctx == nullptr || n_mel_frames <= 4 || n_batch <= 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "voxtral_realtime encoder(batched): invalid arg "
-                     "(n_mel_frames=%d, n_batch=%d)",
-                     n_mel_frames, n_batch);
+                "voxtral_realtime encoder(batched): invalid arg "
+                "(n_mel_frames=%d, n_batch=%d)",
+                n_mel_frames, n_batch);
         return eb;
     }
 
@@ -401,13 +429,13 @@ EncoderBuildBatched build_encoder_graph_batched(ggml_context * ctx,
 
     // ---- causal conv stem (batch rides ne[2]; conv_1d_f32 N>1 path) ----
     ggml_tensor * x = ggml_cont(ctx, ggml_transpose(ctx, eb.mel_in));  // [T_mel, n_mels, B]
-    x = causal_conv(ctx, w.enc_stem.conv0_w, x, /*stride=*/1, /*left_pad=*/2);
-    x = add_conv1d_bias(ctx, x, w.enc_stem.conv0_b);
-    x = ggml_gelu_erf(ctx, x);                                          // [T_mel, d_model, B]
-    x = causal_conv(ctx, w.enc_stem.conv1_w, x, /*stride=*/2, /*left_pad=*/1);
-    x = add_conv1d_bias(ctx, x, w.enc_stem.conv1_b);
-    x = ggml_gelu_erf(ctx, x);                                          // [T_enc, d_model, B]
-    x = ggml_cont(ctx, ggml_transpose(ctx, x));                         // [d_model, T_enc, B]
+    x               = causal_conv(ctx, w.enc_stem.conv0_w, x, /*stride=*/1, /*left_pad=*/2);
+    x               = add_conv1d_bias(ctx, x, w.enc_stem.conv0_b);
+    x               = ggml_gelu_erf(ctx, x);  // [T_mel, d_model, B]
+    x               = causal_conv(ctx, w.enc_stem.conv1_w, x, /*stride=*/2, /*left_pad=*/1);
+    x               = add_conv1d_bias(ctx, x, w.enc_stem.conv1_b);
+    x               = ggml_gelu_erf(ctx, x);                   // [T_enc, d_model, B]
+    x               = ggml_cont(ctx, ggml_transpose(ctx, x));  // [d_model, T_enc, B]
 
     // ---- transformer blocks ----
     const int n_blocks = static_cast<int>(w.enc_blocks.size());
@@ -415,15 +443,14 @@ EncoderBuildBatched build_encoder_graph_batched(ggml_context * ctx,
         const EncBlock & b = w.enc_blocks[i];
         {
             ggml_tensor * y = rms_norm(ctx, x, b.norm_attn_w, hp.enc_rms_norm_eps);
-            y = mha_batched(ctx, y, b, eb.positions_in, eb.mask_in,
-                            n_heads, head_dim, d_model, hp.enc_rope_theta, hp.enc_max_pos,
-                            use_flash);
+            y = mha_batched(ctx, y, b, eb.positions_in, eb.mask_in, n_heads, head_dim, d_model, hp.enc_rope_theta,
+                            hp.enc_max_pos, use_flash);
             x = ggml_add(ctx, x, y);
         }
         {
             ggml_tensor * y = rms_norm(ctx, x, b.norm_ffn_w, hp.enc_rms_norm_eps);
-            y = mlp(ctx, y, b);
-            x = ggml_add(ctx, x, y);
+            y               = mlp(ctx, y, b);
+            x               = ggml_add(ctx, x, y);
         }
     }
 
@@ -434,15 +461,14 @@ EncoderBuildBatched build_encoder_graph_batched(ggml_context * ctx,
     // Drop the trailing T_enc%4 frames of each row before the group-of-4 reshape.
     ggml_tensor * xc = ggml_cont(ctx, x);
     if (T_enc != n_audio * hp.proj_downsample) {
-        xc = ggml_view_3d(ctx, xc, d_model,
-                          static_cast<int64_t>(n_audio) * hp.proj_downsample, B,
-                          xc->nb[1], xc->nb[2], 0);
+        xc = ggml_view_3d(ctx, xc, d_model, static_cast<int64_t>(n_audio) * hp.proj_downsample, B, xc->nb[1], xc->nb[2],
+                          0);
         xc = ggml_cont(ctx, xc);
     }
     ggml_tensor * grouped = ggml_reshape_3d(ctx, xc, hp.proj_in, n_audio, B);
-    ggml_tensor * p = ggml_mul_mat(ctx, w.proj.linear_1_w, grouped);     // [H, n_audio, B]
-    p = ggml_gelu_erf(ctx, p);
-    p = ggml_mul_mat(ctx, w.proj.linear_2_w, p);                        // [dec_h, n_audio, B]
+    ggml_tensor * p       = ggml_mul_mat(ctx, w.proj.linear_1_w, grouped);  // [H, n_audio, B]
+    p                     = ggml_gelu_erf(ctx, p);
+    p                     = ggml_mul_mat(ctx, w.proj.linear_2_w, p);        // [dec_h, n_audio, B]
     named(p, "proj.out.batched");
 
     eb.out = p;
@@ -458,85 +484,90 @@ EncoderBuildBatched build_encoder_graph_batched(ggml_context * ctx,
     return eb;
 }
 
-EmbedderBuild build_embedder_graph(ggml_context * ctx,
-                                   const Weights & w,
-                                   const HParams & hp,
-                                   int             n_mel_frames) {
-    EmbedderBuild eb {};
+EmbedderBuild build_embedder_graph(ggml_context * ctx, const Weights & w, const HParams & hp, int n_mel_frames) {
+    EmbedderBuild eb{};
     if (ctx == nullptr || n_mel_frames <= 4) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral_realtime embedder: invalid n_mel_frames=%d", n_mel_frames);
         return eb;
     }
     const int n_mels = hp.enc_num_mel_bins;
-    eb.T_enc = (n_mel_frames - 2) / 2 + 1;
+    eb.T_enc         = (n_mel_frames - 2) / 2 + 1;
 
     eb.mel_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, n_mels, n_mel_frames);
     named(eb.mel_in, "enc.mel.in");
     ggml_set_input(eb.mel_in);
 
-    ggml_tensor * x = ggml_cont(ctx, ggml_transpose(ctx, eb.mel_in));   // [T_mel, n_mels]
-    x = causal_conv(ctx, w.enc_stem.conv0_w, x, /*stride=*/1, /*left_pad=*/2);
-    x = add_conv1d_bias(ctx, x, w.enc_stem.conv0_b);
-    x = ggml_gelu_erf(ctx, x);
-    x = causal_conv(ctx, w.enc_stem.conv1_w, x, /*stride=*/2, /*left_pad=*/1);
-    x = add_conv1d_bias(ctx, x, w.enc_stem.conv1_b);
-    x = ggml_gelu_erf(ctx, x);
-    x = ggml_cont(ctx, ggml_transpose(ctx, x));                         // [d_model, T_enc]
+    ggml_tensor * x = ggml_cont(ctx, ggml_transpose(ctx, eb.mel_in));  // [T_mel, n_mels]
+    x               = causal_conv(ctx, w.enc_stem.conv0_w, x, /*stride=*/1, /*left_pad=*/2);
+    x               = add_conv1d_bias(ctx, x, w.enc_stem.conv0_b);
+    x               = ggml_gelu_erf(ctx, x);
+    x               = causal_conv(ctx, w.enc_stem.conv1_w, x, /*stride=*/2, /*left_pad=*/1);
+    x               = add_conv1d_bias(ctx, x, w.enc_stem.conv1_b);
+    x               = ggml_gelu_erf(ctx, x);
+    x               = ggml_cont(ctx, ggml_transpose(ctx, x));  // [d_model, T_enc]
     named(x, "enc.embedder.out");
     eb.out = x;
     ggml_set_output(eb.out);
 
     eb.graph = ggml_new_graph_custom(ctx, /*size=*/2048, /*grads=*/false);
-    if (eb.graph == nullptr) { log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral_realtime embedder: graph alloc failed"); return eb; }
+    if (eb.graph == nullptr) {
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral_realtime embedder: graph alloc failed");
+        return eb;
+    }
     ggml_build_forward_expand(eb.graph, eb.out);
     return eb;
 }
 
-EmbedderChunkBuild build_embedder_chunk_graph(ggml_context * ctx,
+EmbedderChunkBuild build_embedder_chunk_graph(ggml_context *  ctx,
                                               const Weights & w,
                                               const HParams & hp,
                                               int             n_new_mel) {
-    EmbedderChunkBuild eb {};
+    EmbedderChunkBuild eb{};
     if (ctx == nullptr || n_new_mel < 2 || (n_new_mel % 2) != 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral_realtime embedder chunk: invalid n_new_mel=%d", n_new_mel);
         return eb;
     }
     const int n_mels  = hp.enc_num_mel_bins;
     const int d_model = hp.enc_d_model;
-    eb.M_emb = n_new_mel / 2;
+    eb.M_emb          = n_new_mel / 2;
 
     eb.mel_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, n_mels, n_new_mel);
-    named(eb.mel_in, "enc.mel.chunk.in");  ggml_set_input(eb.mel_in);
-    eb.cache1_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, n_mels, 2);   // conv0 left_pad
-    named(eb.cache1_in, "enc.conv0.cache"); ggml_set_input(eb.cache1_in);
+    named(eb.mel_in, "enc.mel.chunk.in");
+    ggml_set_input(eb.mel_in);
+    eb.cache1_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, n_mels, 2);  // conv0 left_pad
+    named(eb.cache1_in, "enc.conv0.cache");
+    ggml_set_input(eb.cache1_in);
     eb.cache2_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, d_model, 1);  // conv1 left_pad
-    named(eb.cache2_in, "enc.conv1.cache"); ggml_set_input(eb.cache2_in);
+    named(eb.cache2_in, "enc.conv1.cache");
+    ggml_set_input(eb.cache2_in);
 
     // conv0 (k3 s1, left_pad 2): prepend the 2 cached mel frames instead of zeros.
     // mel layout [n_mels, frames]; concat along frames (ne[1]), then transpose to
     // time-major [frames, n_mels] for conv_1d_f32 (matches build_embedder_graph).
-    ggml_tensor * mel_full = ggml_concat(ctx, eb.cache1_in, eb.mel_in, /*dim=*/1);   // [n_mels, 2+M]
-    ggml_tensor * x = ggml_cont(ctx, ggml_transpose(ctx, mel_full));                 // [2+M, n_mels]
-    x = conv_1d_f32(ctx, w.enc_stem.conv0_w, x, /*stride=*/1, /*padding=*/0, /*dilation=*/1); // [M, d_model]
+    ggml_tensor * mel_full = ggml_concat(ctx, eb.cache1_in, eb.mel_in, /*dim=*/1);             // [n_mels, 2+M]
+    ggml_tensor * x        = ggml_cont(ctx, ggml_transpose(ctx, mel_full));                    // [2+M, n_mels]
+    x = conv_1d_f32(ctx, w.enc_stem.conv0_w, x, /*stride=*/1, /*padding=*/0, /*dilation=*/1);  // [M, d_model]
     x = add_conv1d_bias(ctx, x, w.enc_stem.conv0_b);
     x = ggml_gelu_erf(ctx, x);
-    ggml_tensor * conv0_out = x;                                                     // [M, d_model] time-major
+    ggml_tensor * conv0_out = x;  // [M, d_model] time-major
 
     // Next conv1 cache = the chunk's last conv0-output frame (post-GELU), as [d_model,1].
-    ggml_tensor * c0_last = ggml_view_2d(ctx, conv0_out, 1, d_model,
-                                         conv0_out->nb[1],
-                                         static_cast<size_t>(n_new_mel - 1) * conv0_out->nb[0]); // [1, d_model]
-    eb.cache2_out = ggml_cont(ctx, ggml_transpose(ctx, c0_last));                    // [d_model, 1]
-    named(eb.cache2_out, "enc.conv1.cache.next"); ggml_set_output(eb.cache2_out);
+    ggml_tensor * c0_last = ggml_view_2d(ctx, conv0_out, 1, d_model, conv0_out->nb[1],
+                                         static_cast<size_t>(n_new_mel - 1) * conv0_out->nb[0]);  // [1, d_model]
+    eb.cache2_out         = ggml_cont(ctx, ggml_transpose(ctx, c0_last));                         // [d_model, 1]
+    named(eb.cache2_out, "enc.conv1.cache.next");
+    ggml_set_output(eb.cache2_out);
 
     // conv1 (k3 s2, left_pad 1): prepend the 1 cached conv0-output frame.
-    ggml_tensor * cache2_tm  = ggml_cont(ctx, ggml_transpose(ctx, eb.cache2_in));    // [1, d_model]
-    ggml_tensor * conv0_full = ggml_concat(ctx, cache2_tm, conv0_out, /*dim=*/0);    // [1+M, d_model]
-    x = conv_1d_f32(ctx, w.enc_stem.conv1_w, conv0_full, /*stride=*/2, /*padding=*/0, /*dilation=*/1); // [M/2, d_model]
-    x = add_conv1d_bias(ctx, x, w.enc_stem.conv1_b);
-    x = ggml_gelu_erf(ctx, x);
-    eb.out = ggml_cont(ctx, ggml_transpose(ctx, x));                                 // [d_model, M_emb]
-    named(eb.out, "enc.embedder.chunk.out"); ggml_set_output(eb.out);
+    ggml_tensor * cache2_tm  = ggml_cont(ctx, ggml_transpose(ctx, eb.cache2_in));  // [1, d_model]
+    ggml_tensor * conv0_full = ggml_concat(ctx, cache2_tm, conv0_out, /*dim=*/0);  // [1+M, d_model]
+    x                        = conv_1d_f32(ctx, w.enc_stem.conv1_w, conv0_full, /*stride=*/2, /*padding=*/0,
+                                           /*dilation=*/1);                        // [M/2, d_model]
+    x                        = add_conv1d_bias(ctx, x, w.enc_stem.conv1_b);
+    x                        = ggml_gelu_erf(ctx, x);
+    eb.out                   = ggml_cont(ctx, ggml_transpose(ctx, x));  // [d_model, M_emb]
+    named(eb.out, "enc.embedder.chunk.out");
+    ggml_set_output(eb.out);
 
     eb.graph = ggml_new_graph_custom(ctx, /*size=*/2048, /*grads=*/false);
     if (eb.graph == nullptr) {
@@ -548,30 +579,32 @@ EmbedderChunkBuild build_embedder_chunk_graph(ggml_context * ctx,
     return eb;
 }
 
-EncoderChunkBuild build_encoder_chunk_graph(ggml_context *                  ctx,
-                                            const Weights &                 w,
-                                            const HParams &                 hp,
+EncoderChunkBuild build_encoder_chunk_graph(ggml_context *                   ctx,
+                                            const Weights &                  w,
+                                            const HParams &                  hp,
                                             transcribe::causal_lm::KvCache & enc_kv,
-                                            int                             n_new,
-                                            int                             write_slot,
-                                            int                             read_start,
-                                            int                             read_len,
-                                            bool                            use_flash) {
-    EncoderChunkBuild cb {};
-    const int down = hp.proj_downsample;
-    if (ctx == nullptr || n_new <= 0 || (n_new % down) != 0 || write_slot < 0 ||
-        read_start < 0 || read_len <= 0 || read_start + read_len > enc_kv.n_ctx ||
-        write_slot + n_new > enc_kv.n_ctx || enc_kv.self_k == nullptr) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral_realtime enc-chunk: invalid arg (n_new=%d write_slot=%d "
-                     "read_start=%d read_len=%d n_ctx=%d)",
-                     n_new, write_slot, read_start, read_len, enc_kv.n_ctx);
+                                            int                              n_new,
+                                            int                              write_slot,
+                                            int                              read_start,
+                                            int                              read_len,
+                                            bool                             use_flash) {
+    EncoderChunkBuild cb{};
+    const int         down = hp.proj_downsample;
+    if (ctx == nullptr || n_new <= 0 || (n_new % down) != 0 || write_slot < 0 || read_start < 0 || read_len <= 0 ||
+        read_start + read_len > enc_kv.n_ctx || write_slot + n_new > enc_kv.n_ctx || enc_kv.self_k == nullptr) {
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
+                "voxtral_realtime enc-chunk: invalid arg (n_new=%d write_slot=%d "
+                "read_start=%d read_len=%d n_ctx=%d)",
+                n_new, write_slot, read_start, read_len, enc_kv.n_ctx);
         return cb;
     }
-    const int d_model = hp.enc_d_model;
-    const int n_heads = hp.enc_n_heads;
+    const int d_model  = hp.enc_d_model;
+    const int n_heads  = hp.enc_n_heads;
     const int head_dim = hp.enc_head_dim;
-    const int n_audio = n_new / down;
-    cb.n_new = n_new; cb.read_len = read_len; cb.n_audio_new = n_audio;
+    const int n_audio  = n_new / down;
+    cb.n_new           = n_new;
+    cb.read_len        = read_len;
+    cb.n_audio_new     = n_audio;
 
     cb.embed_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, d_model, n_new);
     named(cb.embed_in, "enc.chunk.embed_in");
@@ -584,24 +617,26 @@ EncoderChunkBuild build_encoder_chunk_graph(ggml_context *                  ctx,
     ggml_set_input(cb.mask_in);
 
     ggml_cgraph * gf = ggml_new_graph_custom(ctx, /*size=*/8192, /*grads=*/false);
-    if (gf == nullptr) { log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral_realtime enc-chunk: graph alloc failed"); return cb; }
+    if (gf == nullptr) {
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral_realtime enc-chunk: graph alloc failed");
+        return cb;
+    }
     cb.graph = gf;
 
-    ggml_tensor * x = cb.embed_in;  // [d_model, n_new]
-    const int n_blocks = static_cast<int>(w.enc_blocks.size());
+    ggml_tensor * x        = cb.embed_in;  // [d_model, n_new]
+    const int     n_blocks = static_cast<int>(w.enc_blocks.size());
     for (int i = 0; i < n_blocks; ++i) {
         const EncBlock & b = w.enc_blocks[i];
         {
             ggml_tensor * y = rms_norm(ctx, x, b.norm_attn_w, hp.enc_rms_norm_eps);
-            y = mha_cached(ctx, gf, y, b, cb.positions_in, cb.mask_in, enc_kv, i,
-                           n_new, write_slot, read_start, read_len, n_heads, head_dim,
-                           hp.enc_rope_theta, hp.enc_max_pos, use_flash);
+            y = mha_cached(ctx, gf, y, b, cb.positions_in, cb.mask_in, enc_kv, i, n_new, write_slot, read_start,
+                           read_len, n_heads, head_dim, hp.enc_rope_theta, hp.enc_max_pos, use_flash);
             x = ggml_add(ctx, x, y);
         }
         {
             ggml_tensor * y = rms_norm(ctx, x, b.norm_ffn_w, hp.enc_rms_norm_eps);
-            y = mlp(ctx, y, b);
-            x = ggml_add(ctx, x, y);
+            y               = mlp(ctx, y, b);
+            x               = ggml_add(ctx, x, y);
         }
     }
 
@@ -610,11 +645,11 @@ EncoderChunkBuild build_encoder_chunk_graph(ggml_context *                  ctx,
     cb.enc_out = x;
 
     // Projector: group `down` consecutive frames -> [proj_in, n_audio].
-    ggml_tensor * xc = ggml_cont(ctx, x);
+    ggml_tensor * xc      = ggml_cont(ctx, x);
     ggml_tensor * grouped = ggml_reshape_2d(ctx, xc, hp.proj_in, n_audio);
-    ggml_tensor * p = ggml_mul_mat(ctx, w.proj.linear_1_w, grouped);
-    p = ggml_gelu_erf(ctx, p);
-    p = ggml_mul_mat(ctx, w.proj.linear_2_w, p);
+    ggml_tensor * p       = ggml_mul_mat(ctx, w.proj.linear_1_w, grouped);
+    p                     = ggml_gelu_erf(ctx, p);
+    p                     = ggml_mul_mat(ctx, w.proj.linear_2_w, p);
     named(p, "enc.chunk.proj_out");
     cb.out = p;
     ggml_set_output(cb.out);
@@ -624,4 +659,4 @@ EncoderChunkBuild build_encoder_chunk_graph(ggml_context *                  ctx,
     return cb;
 }
 
-} // namespace transcribe::voxtral_realtime
+}  // namespace transcribe::voxtral_realtime
diff --git a/src/arch/voxtral_realtime/encoder.h b/src/arch/voxtral_realtime/encoder.h
index 5765aa66..67ecabc5 100644
--- a/src/arch/voxtral_realtime/encoder.h
+++ b/src/arch/voxtral_realtime/encoder.h
@@ -13,7 +13,6 @@
 #pragma once
 
 #include "causal_lm/causal_lm.h"
-
 #include "ggml.h"
 
 #include <vector>
@@ -28,10 +27,10 @@ struct HParams;
 struct Weights;
 
 struct EncoderDumps {
-    ggml_tensor * embedder_out = nullptr;  // conv stem output [d_model, T_enc]
-    ggml_tensor * enc_out      = nullptr;  // final RMSNorm output
-    ggml_tensor * proj_out     = nullptr;  // projector output (audio embeds)
-    std::vector<ggml_tensor *> block_outs; // per-block residual outputs
+    ggml_tensor *              embedder_out = nullptr;  // conv stem output [d_model, T_enc]
+    ggml_tensor *              enc_out      = nullptr;  // final RMSNorm output
+    ggml_tensor *              proj_out     = nullptr;  // projector output (audio embeds)
+    std::vector<ggml_tensor *> block_outs;              // per-block residual outputs
 };
 
 struct EncoderBuild {
@@ -39,8 +38,8 @@ struct EncoderBuild {
     ggml_tensor * positions_in = nullptr;  // [T_enc] i32 RoPE positions
     ggml_tensor * mask_in      = nullptr;  // [T_enc, T_enc] f16 sw-causal mask
     ggml_tensor * out          = nullptr;  // proj.out [dec_hidden, n_audio]
-    EncoderDumps  dumps {};
-    ggml_cgraph * graph        = nullptr;
+    EncoderDumps  dumps{};
+    ggml_cgraph * graph = nullptr;
 
     int T_enc   = 0;
     int n_audio = 0;
@@ -48,7 +47,7 @@ struct EncoderBuild {
 
 // Build the encoder+projector forward graph for `n_mel_frames` mel frames.
 // The stride-2 causal conv2 yields T_enc = conv-out frames; n_audio = T_enc/4.
-EncoderBuild build_encoder_graph(ggml_context * ctx,
+EncoderBuild build_encoder_graph(ggml_context *  ctx,
                                  const Weights & weights,
                                  const HParams & hp,
                                  int             n_mel_frames,
@@ -78,7 +77,7 @@ struct EncoderBuildBatched {
     int n_batch = 0;
 };
 
-EncoderBuildBatched build_encoder_graph_batched(ggml_context * ctx,
+EncoderBuildBatched build_encoder_graph_batched(ggml_context *  ctx,
                                                 const Weights & weights,
                                                 const HParams & hp,
                                                 int             n_mel_frames,
@@ -104,14 +103,11 @@ struct EmbedderBuild {
     ggml_tensor * mel_in = nullptr;  // [n_mels, n_mel_frames] input
     ggml_tensor * out    = nullptr;  // [d_model, T_enc] embedder frames
     ggml_cgraph * graph  = nullptr;
-    int T_enc = 0;
+    int           T_enc  = 0;
 };
 
 // Conv stem only (no transformer). T_enc = (n_mel_frames - 2)/2 + 1.
-EmbedderBuild build_embedder_graph(ggml_context * ctx,
-                                   const Weights & weights,
-                                   const HParams & hp,
-                                   int             n_mel_frames);
+EmbedderBuild build_embedder_graph(ggml_context * ctx, const Weights & weights, const HParams & hp, int n_mel_frames);
 
 // Conv stem with the streaming PADDING CACHE. Feeds only `n_new_mel` NEW mel
 // frames; the conv left-context comes from host-carried caches instead of zero
@@ -126,10 +122,10 @@ struct EmbedderChunkBuild {
     ggml_tensor * out        = nullptr;  // [d_model, M_emb] new embedder frames
     ggml_tensor * cache2_out = nullptr;  // [d_model, 1] new last conv1-out frame (next cache2)
     ggml_cgraph * graph      = nullptr;
-    int M_emb = 0;
+    int           M_emb      = 0;
 };
 
-EmbedderChunkBuild build_embedder_chunk_graph(ggml_context * ctx,
+EmbedderChunkBuild build_embedder_chunk_graph(ggml_context *  ctx,
                                               const Weights & weights,
                                               const HParams & hp,
                                               int             n_new_mel);
@@ -137,13 +133,13 @@ EmbedderChunkBuild build_embedder_chunk_graph(ggml_context * ctx,
 struct EncoderChunkBuild {
     ggml_tensor * embed_in     = nullptr;  // [d_model, n_new] new embedder frames
     ggml_tensor * positions_in = nullptr;  // [n_new] i32 ABSOLUTE enc-frame pos
-    ggml_tensor * mask_in       = nullptr; // [read_len, n_new] f16 sw-causal
-    ggml_tensor * out           = nullptr; // proj.out audio embeds [dec_hidden, n_audio_new]
-    ggml_tensor * enc_out       = nullptr; // [d_model, n_new] final-normed enc frames
-    ggml_cgraph * graph         = nullptr;
-    int n_new       = 0;
-    int read_len    = 0;
-    int n_audio_new = 0;
+    ggml_tensor * mask_in      = nullptr;  // [read_len, n_new] f16 sw-causal
+    ggml_tensor * out          = nullptr;  // proj.out audio embeds [dec_hidden, n_audio_new]
+    ggml_tensor * enc_out      = nullptr;  // [d_model, n_new] final-normed enc frames
+    ggml_cgraph * graph        = nullptr;
+    int           n_new        = 0;
+    int           read_len     = 0;
+    int           n_audio_new  = 0;
 };
 
 // Build one incremental encoder chunk against the encoder KV cache ring. Writes
@@ -152,14 +148,14 @@ struct EncoderChunkBuild {
 // host mask enforces the 750-frame sliding window using ABSOLUTE positions). The
 // caller owns the ring (compaction + slot bookkeeping). `n_new` must be a
 // multiple of proj_downsample (4) so projector groups never straddle chunks.
-EncoderChunkBuild build_encoder_chunk_graph(ggml_context *                  ctx,
-                                            const Weights &                 weights,
-                                            const HParams &                 hp,
+EncoderChunkBuild build_encoder_chunk_graph(ggml_context *                   ctx,
+                                            const Weights &                  weights,
+                                            const HParams &                  hp,
                                             transcribe::causal_lm::KvCache & enc_kv,
-                                            int                             n_new,
-                                            int                             write_slot,
-                                            int                             read_start,
-                                            int                             read_len,
-                                            bool                            use_flash);
+                                            int                              n_new,
+                                            int                              write_slot,
+                                            int                              read_start,
+                                            int                              read_len,
+                                            bool                             use_flash);
 
-} // namespace transcribe::voxtral_realtime
+}  // namespace transcribe::voxtral_realtime
diff --git a/src/arch/voxtral_realtime/model.cpp b/src/arch/voxtral_realtime/model.cpp
index 799d4720..e2a985b7 100644
--- a/src/arch/voxtral_realtime/model.cpp
+++ b/src/arch/voxtral_realtime/model.cpp
@@ -6,14 +6,12 @@
 // audio embeddings are ADDED onto every sequence position. Greedy decode is
 // clamped to ceil(mel_frames / audio_length_per_tok) positions.
 
-#include "voxtral_realtime.h"
-#include "transcribe/voxtral_realtime.h"  // public stream-ext surface
-
+#include "causal_lm/causal_lm.h"
 #include "decoder.h"
 #include "encoder.h"
-#include "weights.h"
-
-#include "causal_lm/causal_lm.h"
+#include "ggml-backend.h"
+#include "ggml.h"
+#include "gguf.h"
 #include "transcribe-arch.h"
 #include "transcribe-batch-util.h"
 #include "transcribe-debug.h"
@@ -24,18 +22,17 @@
 #include "transcribe-log.h"
 #include "transcribe-mel.h"
 #include "transcribe-meta.h"
-
-#include "ggml.h"
-#include "ggml-backend.h"
-#include "gguf.h"
+#include "transcribe/voxtral_realtime.h"  // public stream-ext surface
+#include "voxtral_realtime.h"
+#include "weights.h"
 
 #include <algorithm>
 #include <cctype>
+#include <cmath>
 #include <cstdint>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
-#include <cmath>
 #include <functional>
 #include <memory>
 #include <string>
@@ -48,7 +45,7 @@ namespace transcribe::voxtral_realtime {
 
 extern const Arch arch;
 
-static_assert(std::is_base_of_v<transcribe_model,   Model>);
+static_assert(std::is_base_of_v<transcribe_model, Model>);
 static_assert(std::is_base_of_v<transcribe_session, Session>);
 
 Session::~Session() {
@@ -56,15 +53,33 @@ Session::~Session() {
     kv_cache_batch.free();
     enc_kv.free();
     ada_scale.clear();
-    if (ada_buffer != nullptr) { ggml_backend_buffer_free(ada_buffer); ada_buffer = nullptr; }
-    if (ada_ctx != nullptr)    { ggml_free(ada_ctx); ada_ctx = nullptr; }
-    if (sched != nullptr)      { ggml_backend_sched_free(sched); sched = nullptr; }
-    if (compute_ctx != nullptr){ ggml_free(compute_ctx); compute_ctx = nullptr; }
+    if (ada_buffer != nullptr) {
+        ggml_backend_buffer_free(ada_buffer);
+        ada_buffer = nullptr;
+    }
+    if (ada_ctx != nullptr) {
+        ggml_free(ada_ctx);
+        ada_ctx = nullptr;
+    }
+    if (sched != nullptr) {
+        ggml_backend_sched_free(sched);
+        sched = nullptr;
+    }
+    if (compute_ctx != nullptr) {
+        ggml_free(compute_ctx);
+        compute_ctx = nullptr;
+    }
 }
 
 Model::~Model() {
-    if (ctx_meta != nullptr) { ggml_free(ctx_meta); ctx_meta = nullptr; }
-    if (backend_buffer != nullptr) { ggml_backend_buffer_free(backend_buffer); backend_buffer = nullptr; }
+    if (ctx_meta != nullptr) {
+        ggml_free(ctx_meta);
+        ctx_meta = nullptr;
+    }
+    if (backend_buffer != nullptr) {
+        ggml_backend_buffer_free(backend_buffer);
+        backend_buffer = nullptr;
+    }
     packed_gate_up.free();
     for (auto it = plan.scheduler_list.rbegin(); it != plan.scheduler_list.rend(); ++it) {
         ggml_backend_free(*it);
@@ -79,12 +94,11 @@ namespace {
 constexpr const char k_default_variant[] = "voxtral-mini-4b-realtime-2602";
 
 // Resolve BOS / STREAMING_PAD / EOS against the loaded tokenizer.
-transcribe_status resolve_specials(const transcribe::Tokenizer & tok,
-                                   const HParams & hp, PromptSpecials & out) {
-    out.bos          = tok.bos_id();
-    out.eos          = tok.eos_id();
+transcribe_status resolve_specials(const transcribe::Tokenizer & tok, const HParams & hp, PromptSpecials & out) {
+    out.bos           = tok.bos_id();
+    out.eos           = tok.eos_id();
     out.streaming_pad = hp.streaming_pad_token_id;
-    out.n_left_pad   = 32;  // tekken streaming_n_left_pad_tokens
+    out.n_left_pad    = 32;  // tekken streaming_n_left_pad_tokens
     if (out.bos < 0 || out.eos < 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral_realtime: tokenizer missing bos/eos id");
         return TRANSCRIBE_ERR_GGUF;
@@ -103,24 +117,30 @@ void apply_threads(ggml_backend_sched_t sched, int n_threads) {
 #ifdef TRANSCRIBE_ENABLE_VALIDATION_HOOKS
 // Read a reference enc.mel.in.f32 ([n_mels, n_frames] mel-major) for numerical
 // isolation. Returns true and fills mel_buf (mel-major) + n_frames on success.
-bool read_ref_mel(const std::string & dir, int n_mels,
-                  std::vector<float> & mel_buf, int & n_frames) {
+bool read_ref_mel(const std::string & dir, int n_mels, std::vector<float> & mel_buf, int & n_frames) {
     const std::string path = dir + "/enc.mel.in.f32";
-    FILE * f = std::fopen(path.c_str(), "rb");
-    if (f == nullptr) return false;
+    FILE *            f    = std::fopen(path.c_str(), "rb");
+    if (f == nullptr) {
+        return false;
+    }
     std::fseek(f, 0, SEEK_END);
     const long bytes = std::ftell(f);
     std::fseek(f, 0, SEEK_SET);
     const long n = bytes / static_cast<long>(sizeof(float));
-    if (n <= 0 || (n % n_mels) != 0) { std::fclose(f); return false; }
+    if (n <= 0 || (n % n_mels) != 0) {
+        std::fclose(f);
+        return false;
+    }
     mel_buf.resize(static_cast<size_t>(n));
     const size_t got = std::fread(mel_buf.data(), sizeof(float), static_cast<size_t>(n), f);
     std::fclose(f);
-    if (got != static_cast<size_t>(n)) return false;
+    if (got != static_cast<size_t>(n)) {
+        return false;
+    }
     n_frames = static_cast<int>(n / n_mels);
     return true;
 }
-#endif // TRANSCRIBE_ENABLE_VALIDATION_HOOKS
+#endif  // TRANSCRIBE_ENABLE_VALIDATION_HOOKS
 
 // Input-length contract (see docs/input-limits.md). Chunked/unbounded family:
 // the encoder is causal + sliding-window (750 frames) advanced on a
@@ -145,14 +165,12 @@ int64_t voxtral_realtime_max_audio_ms(const HParams & hp) {
     return 0;
 }
 
-} // namespace
+}  // namespace
 
-transcribe_status load(Loader & loader,
-                       const transcribe_model_load_params * params,
-                       transcribe_model ** out_model) {
+transcribe_status load(Loader & loader, const transcribe_model_load_params * params, transcribe_model ** out_model) {
     const int64_t t_load_start = ggml_time_us();
 
-    auto m = std::make_unique<Model>();
+    auto m       = std::make_unique<Model>();
     m->arch      = &arch;
     m->t_load_us = 0;
     m->variant   = loader.variant().empty() ? k_default_variant : loader.variant();
@@ -162,10 +180,18 @@ transcribe_status load(Loader & loader,
     m->caps.n_languages = 0;
     m->caps.languages   = nullptr;
 
-    if (auto st = read_capability_kv(loader.gguf(), m->caps); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_languages_kv(loader.gguf(), *m); st != TRANSCRIBE_OK) return st;
-    if (auto st = m->tok.load(loader.gguf()); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_hparams(loader.gguf(), m->hparams); st != TRANSCRIBE_OK) return st;
+    if (auto st = read_capability_kv(loader.gguf(), m->caps); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_languages_kv(loader.gguf(), *m); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = m->tok.load(loader.gguf()); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_hparams(loader.gguf(), m->hparams); st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Publish the input-length ceiling now that the decoder context window is
     // known (apply_family_invariants ran before hparams). Chunked/unbounded:
@@ -177,66 +203,71 @@ transcribe_status load(Loader & loader,
     m->hparams.eos_token_id = m->tok.eos_id();
     if (m->hparams.vocab_size != m->hparams.dec_vocab_size) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral_realtime: tokenizer vocab (%d) != decoder vocab_size (%d)",
-                     m->hparams.vocab_size, m->hparams.dec_vocab_size);
+                m->hparams.vocab_size, m->hparams.dec_vocab_size);
         return TRANSCRIBE_ERR_GGUF;
     }
-    if (auto st = resolve_specials(m->tok, m->hparams, m->specials); st != TRANSCRIBE_OK) return st;
+    if (auto st = resolve_specials(m->tok, m->hparams, m->specials); st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Mel frontend (streaming log-mel, fixed global max).
     {
-        transcribe::MelConfig cfg {};
-        cfg.sample_rate  = m->hparams.fe_sample_rate;
-        cfg.num_mels     = m->hparams.fe_num_mels;
-        cfg.n_fft        = m->hparams.fe_n_fft;
-        cfg.win_length   = m->hparams.fe_win_length;
-        cfg.hop_length   = m->hparams.fe_hop_length;
-        cfg.pre_emphasis = m->hparams.fe_pre_emphasis;
-        cfg.f_min        = m->hparams.fe_f_min;
-        cfg.f_max        = m->hparams.fe_f_max;
-        cfg.pad_mode     = m->hparams.fe_pad_mode;
-        cfg.window_type  = m->hparams.fe_window;     // "hann_periodic"
-        cfg.normalize    = m->hparams.fe_normalize;  // "global"
+        transcribe::MelConfig cfg{};
+        cfg.sample_rate        = m->hparams.fe_sample_rate;
+        cfg.num_mels           = m->hparams.fe_num_mels;
+        cfg.n_fft              = m->hparams.fe_n_fft;
+        cfg.win_length         = m->hparams.fe_win_length;
+        cfg.hop_length         = m->hparams.fe_hop_length;
+        cfg.pre_emphasis       = m->hparams.fe_pre_emphasis;
+        cfg.f_min              = m->hparams.fe_f_min;
+        cfg.f_max              = m->hparams.fe_f_max;
+        cfg.pad_mode           = m->hparams.fe_pad_mode;
+        cfg.window_type        = m->hparams.fe_window;     // "hann_periodic"
+        cfg.normalize          = m->hparams.fe_normalize;  // "global"
         cfg.global_log_mel_max = m->hparams.fe_global_log_mel_max;
 
-        using R = transcribe::load_common::ReadF32Result;
-        const size_t fb_elems =
-            static_cast<size_t>(cfg.num_mels) * static_cast<size_t>(cfg.n_fft / 2 + 1);
-        const auto fb_rc = transcribe::load_common::read_f32_tensor_checked(
-            loader.gguf(), loader.path(), "frontend.mel_filterbank", fb_elems,
-            "voxtral_realtime", cfg.filterbank);
-        if (fb_rc != R::Ok && fb_rc != R::Absent) return TRANSCRIBE_ERR_GGUF;
+        using R               = transcribe::load_common::ReadF32Result;
+        const size_t fb_elems = static_cast<size_t>(cfg.num_mels) * static_cast<size_t>(cfg.n_fft / 2 + 1);
+        const auto   fb_rc    = transcribe::load_common::read_f32_tensor_checked(
+            loader.gguf(), loader.path(), "frontend.mel_filterbank", fb_elems, "voxtral_realtime", cfg.filterbank);
+        if (fb_rc != R::Ok && fb_rc != R::Absent) {
+            return TRANSCRIBE_ERR_GGUF;
+        }
         const auto win_rc = transcribe::load_common::read_f32_tensor_checked(
-            loader.gguf(), loader.path(), "frontend.window",
-            static_cast<size_t>(cfg.win_length), "voxtral_realtime", cfg.window);
-        if (win_rc != R::Ok && win_rc != R::Absent) return TRANSCRIBE_ERR_GGUF;
+            loader.gguf(), loader.path(), "frontend.window", static_cast<size_t>(cfg.win_length), "voxtral_realtime",
+            cfg.window);
+        if (win_rc != R::Ok && win_rc != R::Absent) {
+            return TRANSCRIBE_ERR_GGUF;
+        }
 
         m->mel.emplace(cfg);
     }
 
     // Tensor catalog + backend alloc + data stream.
-    gguf_init_params init_params {};
-    init_params.no_alloc = true;
-    init_params.ctx      = &m->ctx_meta;
+    gguf_init_params init_params{};
+    init_params.no_alloc     = true;
+    init_params.ctx          = &m->ctx_meta;
     gguf_context * gguf_data = gguf_init_from_file(loader.path().c_str(), init_params);
-    if (gguf_data == nullptr) return TRANSCRIBE_ERR_GGUF;
+    if (gguf_data == nullptr) {
+        return TRANSCRIBE_ERR_GGUF;
+    }
 
     if (auto st = build_weights(m->ctx_meta, m->hparams, m->weights); st != TRANSCRIBE_OK) {
         gguf_free(gguf_data);
         return st;
     }
 
-    const transcribe_backend_request backend_req =
-        (params != nullptr) ? params->backend : TRANSCRIBE_BACKEND_AUTO;
-    if (auto st = transcribe::load_common::init_backends(backend_req, (params != nullptr) ? params->gpu_device : 0, "voxtral_realtime", m->plan);
+    const transcribe_backend_request backend_req = (params != nullptr) ? params->backend : TRANSCRIBE_BACKEND_AUTO;
+    if (auto st = transcribe::load_common::init_backends(backend_req, (params != nullptr) ? params->gpu_device : 0,
+                                                         "voxtral_realtime", m->plan);
         st != TRANSCRIBE_OK) {
         gguf_free(gguf_data);
         return st;
     }
-    m->backend = ggml_backend_name(m->plan.primary);
+    m->backend         = ggml_backend_name(m->plan.primary);
     m->primary_backend = m->plan.primary;
 
-    ggml_backend_buffer_t weights_buffer =
-        ggml_backend_alloc_ctx_tensors(m->ctx_meta, m->plan.primary);
+    ggml_backend_buffer_t weights_buffer = ggml_backend_alloc_ctx_tensors(m->ctx_meta, m->plan.primary);
     if (weights_buffer == nullptr) {
         gguf_free(gguf_data);
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral_realtime: ggml_backend_alloc_ctx_tensors failed");
@@ -245,8 +276,9 @@ transcribe_status load(Loader & loader,
     m->backend_buffer = weights_buffer;
     ggml_backend_buffer_set_usage(weights_buffer, GGML_BACKEND_BUFFER_USAGE_WEIGHTS);
 
-    if (auto st = transcribe::load_common::stream_tensor_data(
-            loader.path(), gguf_data, m->ctx_meta, "voxtral_realtime"); st != TRANSCRIBE_OK) {
+    if (auto st =
+            transcribe::load_common::stream_tensor_data(loader.path(), gguf_data, m->ctx_meta, "voxtral_realtime");
+        st != TRANSCRIBE_OK) {
         gguf_free(gguf_data);
         return st;
     }
@@ -258,27 +290,28 @@ transcribe_status load(Loader & loader,
         std::vector<transcribe::causal_lm::GateUpEntry> entries;
         entries.reserve(m->weights.dec_blocks.size());
         for (auto & b : m->weights.dec_blocks) {
-            entries.push_back({b.ffn_gate_w, b.ffn_up_w, &b.ffn_gate_up_w});
+            entries.push_back({ b.ffn_gate_w, b.ffn_up_w, &b.ffn_gate_up_w });
         }
-        if (!transcribe::causal_lm::pack_gate_up(
-                m->plan.primary, m->hparams.dec_hidden, m->hparams.dec_intermediate,
-                entries, m->packed_gate_up, "voxtral_realtime")) {
+        if (!transcribe::causal_lm::pack_gate_up(m->plan.primary, m->hparams.dec_hidden, m->hparams.dec_intermediate,
+                                                 entries, m->packed_gate_up, "voxtral_realtime")) {
             m->packed_gate_up.free();
             return TRANSCRIBE_ERR_GGUF;
         }
     }
 
     m->t_load_us = ggml_time_us() - t_load_start;
-    *out_model = m.release();
+    *out_model   = m.release();
     return TRANSCRIBE_OK;
 }
 
-transcribe_status init_context(transcribe_model * model,
+transcribe_status init_context(transcribe_model *                model,
                                const transcribe_session_params * params,
-                               transcribe_session ** out_ctx) {
-    if (model->arch != &arch) return TRANSCRIBE_ERR_INVALID_ARG;
+                               transcribe_session **             out_ctx) {
+    if (model->arch != &arch) {
+        return TRANSCRIBE_ERR_INVALID_ARG;
+    }
 
-    auto cc = std::make_unique<Session>();
+    auto cc       = std::make_unique<Session>();
     cc->model     = model;
     cc->n_threads = params->n_threads;
     cc->kv_type   = params->kv_type;
@@ -295,12 +328,11 @@ transcribe_status init_context(transcribe_model * model,
     transcribe::flash::apply_env_overrides(cc->encoder_use_flash, cc->decoder_use_flash);
 
     ggml_type kv_type = (cc->kv_type == TRANSCRIBE_KV_TYPE_F32) ? GGML_TYPE_F32 : GGML_TYPE_F16;
-    if (!transcribe::causal_lm::kv_init(cc->kv_cache, cm->plan.primary, /*n_ctx=*/2048,
-                                       cm->hparams.dec_n_kv_heads, cm->hparams.dec_head_dim,
-                                       cm->hparams.dec_n_layers, kv_type)) {
+    if (!transcribe::causal_lm::kv_init(cc->kv_cache, cm->plan.primary, /*n_ctx=*/2048, cm->hparams.dec_n_kv_heads,
+                                        cm->hparams.dec_head_dim, cm->hparams.dec_n_layers, kv_type)) {
         transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "voxtral_realtime init_context: KV cache allocation failed — "
-            "out of memory.");
+                            "voxtral_realtime init_context: KV cache allocation failed — "
+                            "out of memory.");
         return TRANSCRIBE_ERR_OOM;
     }
 
@@ -313,7 +345,9 @@ transcribe_status init_context(transcribe_model * model,
 // ada_l = linear2(gelu(linear1(t_cond))). Result stored in ada_scale_all
 // [dec_hidden, n_layers] (F32, persistent in the session).
 transcribe_status compute_ada_scales(Session * cc, Model * cm, int num_delay) {
-    if (cc->ada_scale_all != nullptr && cc->ada_num_delay == num_delay) return TRANSCRIBE_OK;
+    if (cc->ada_scale_all != nullptr && cc->ada_num_delay == num_delay) {
+        return TRANSCRIBE_OK;
+    }
 
     const int hidden  = cm->hparams.dec_hidden;
     const int n_layer = cm->hparams.dec_n_layers;
@@ -321,44 +355,51 @@ transcribe_status compute_ada_scales(Session * cc, Model * cm, int num_delay) {
 
     // inv_freq -> host -> t_cond.
     std::vector<float> inv_freq(static_cast<size_t>(half));
-    ggml_backend_tensor_get(cm->weights.time_inv_freq, inv_freq.data(), 0,
-                            inv_freq.size() * sizeof(float));
+    ggml_backend_tensor_get(cm->weights.time_inv_freq, inv_freq.data(), 0, inv_freq.size() * sizeof(float));
     std::vector<float> t_cond(static_cast<size_t>(hidden));
     for (int i = 0; i < half; ++i) {
-        const double e = static_cast<double>(num_delay) * static_cast<double>(inv_freq[i]);
+        const double e   = static_cast<double>(num_delay) * static_cast<double>(inv_freq[i]);
         t_cond[i]        = static_cast<float>(std::cos(e));
         t_cond[half + i] = static_cast<float>(std::sin(e));
     }
 
     // Persistent ada_scale_all.
-    if (cc->ada_buffer != nullptr) { ggml_backend_buffer_free(cc->ada_buffer); cc->ada_buffer = nullptr; }
-    if (cc->ada_ctx != nullptr)    { ggml_free(cc->ada_ctx); cc->ada_ctx = nullptr; }
+    if (cc->ada_buffer != nullptr) {
+        ggml_backend_buffer_free(cc->ada_buffer);
+        cc->ada_buffer = nullptr;
+    }
+    if (cc->ada_ctx != nullptr) {
+        ggml_free(cc->ada_ctx);
+        cc->ada_ctx = nullptr;
+    }
     {
-        ggml_init_params ip {};
+        ggml_init_params ip{};
         ip.mem_size = ggml_tensor_overhead() * 4;
         ip.no_alloc = true;
         cc->ada_ctx = ggml_init(ip);
         if (cc->ada_ctx == nullptr) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "voxtral_realtime: ada-scale context allocation failed — "
-                "out of memory.");
+                                "voxtral_realtime: ada-scale context allocation failed — "
+                                "out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
     }
     cc->ada_scale_all = ggml_new_tensor_2d(cc->ada_ctx, GGML_TYPE_F32, hidden, n_layer);
     ggml_set_name(cc->ada_scale_all, "ada.scale_all");
     cc->ada_buffer = ggml_backend_alloc_ctx_tensors(cc->ada_ctx, cm->plan.primary);
-    if (cc->ada_buffer == nullptr) return TRANSCRIBE_ERR_GGUF;
+    if (cc->ada_buffer == nullptr) {
+        return TRANSCRIBE_ERR_GGUF;
+    }
 
     // Build a one-shot compute graph: per layer ada_l = linear2(gelu(linear1(t))).
-    ggml_init_params cip {};
-    cip.mem_size = 16 * 1024 * 1024;
-    cip.no_alloc = true;
+    ggml_init_params cip{};
+    cip.mem_size       = 16 * 1024 * 1024;
+    cip.no_alloc       = true;
     ggml_context * ctx = ggml_init(cip);
     if (ctx == nullptr) {
         transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "voxtral_realtime: ada-scale compute context allocation failed — "
-            "out of memory.");
+                            "voxtral_realtime: ada-scale compute context allocation failed — "
+                            "out of memory.");
         return TRANSCRIBE_ERR_OOM;
     }
 
@@ -367,11 +408,11 @@ transcribe_status compute_ada_scales(Session * cc, Model * cm, int num_delay) {
     ggml_tensor * acc = nullptr;
     for (int il = 0; il < n_layer; ++il) {
         const DecBlock & b = cm->weights.dec_blocks[il];
-        ggml_tensor * a = ggml_mul_mat(ctx, b.ada_linear_1_w, t_in);   // [ada_hidden]
-        a = ggml_gelu_erf(ctx, a);
-        a = ggml_mul_mat(ctx, b.ada_linear_2_w, a);                    // [hidden]
-        a = ggml_reshape_2d(ctx, a, hidden, 1);
-        acc = (acc == nullptr) ? a : ggml_concat(ctx, acc, a, /*dim=*/1);
+        ggml_tensor *    a = ggml_mul_mat(ctx, b.ada_linear_1_w, t_in);  // [ada_hidden]
+        a                  = ggml_gelu_erf(ctx, a);
+        a                  = ggml_mul_mat(ctx, b.ada_linear_2_w, a);     // [hidden]
+        a                  = ggml_reshape_2d(ctx, a, hidden, 1);
+        acc                = (acc == nullptr) ? a : ggml_concat(ctx, acc, a, /*dim=*/1);
     }
     ggml_set_output(acc);
     ggml_cgraph * gf = ggml_new_graph(ctx);
@@ -379,27 +420,33 @@ transcribe_status compute_ada_scales(Session * cc, Model * cm, int num_delay) {
 
     if (cc->sched == nullptr) {
         cc->sched = ggml_backend_sched_new(cm->plan.scheduler_list.data(), nullptr,
-            static_cast<int>(cm->plan.scheduler_list.size()), 16384, false, true);
-        if (cc->sched == nullptr) { ggml_free(ctx); return TRANSCRIBE_ERR_GGUF; }
+                                           static_cast<int>(cm->plan.scheduler_list.size()), 16384, false, true);
+        if (cc->sched == nullptr) {
+            ggml_free(ctx);
+            return TRANSCRIBE_ERR_GGUF;
+        }
     }
     ggml_backend_sched_reset(cc->sched);
     if (!ggml_backend_sched_alloc_graph(cc->sched, gf)) {
         transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "voxtral_realtime: ada-scale graph allocation failed — "
-            "out of memory.");
+                            "voxtral_realtime: ada-scale graph allocation failed — "
+                            "out of memory.");
         ggml_free(ctx);
         return TRANSCRIBE_ERR_OOM;
     }
     ggml_backend_tensor_set(t_in, t_cond.data(), 0, t_cond.size() * sizeof(float));
     apply_threads(cc->sched, cc->n_threads);
     if (ggml_backend_sched_graph_compute(cc->sched, gf) != GGML_STATUS_SUCCESS) {
-        ggml_free(ctx); return TRANSCRIBE_ERR_GGUF;
+        ggml_free(ctx);
+        return TRANSCRIBE_ERR_GGUF;
     }
 
     std::vector<float> ada(static_cast<size_t>(hidden) * n_layer);
     ggml_backend_tensor_get(acc, ada.data(), 0, ada.size() * sizeof(float));
     ggml_free(ctx);
-    for (auto & v : ada) v += 1.0f;  // s_l = 1 + ada
+    for (auto & v : ada) {
+        v += 1.0f;  // s_l = 1 + ada
+    }
     // Fold the per-layer FFN-norm weight into the ada scale and store
     // (s_l ⊙ norm_ffn_w): the decode block passes this as the FFN-norm weight so
     // the fused rms_norm(·weight) kernel applies the ada scale with no separate
@@ -407,10 +454,11 @@ transcribe_status compute_ada_scales(Session * cc, Model * cm, int num_delay) {
     {
         std::vector<float> wbuf(static_cast<size_t>(hidden));
         for (int il = 0; il < n_layer; ++il) {
-            ggml_backend_tensor_get(cm->weights.dec_blocks[il].norm_ffn_w, wbuf.data(),
-                                    0, wbuf.size() * sizeof(float));
+            ggml_backend_tensor_get(cm->weights.dec_blocks[il].norm_ffn_w, wbuf.data(), 0, wbuf.size() * sizeof(float));
             float * s = ada.data() + static_cast<size_t>(il) * hidden;
-            for (int i = 0; i < hidden; ++i) s[i] *= wbuf[i];
+            for (int i = 0; i < hidden; ++i) {
+                s[i] *= wbuf[i];
+            }
         }
     }
     ggml_backend_tensor_set(cc->ada_scale_all, ada.data(), 0, ada.size() * sizeof(float));
@@ -424,10 +472,13 @@ transcribe_status compute_ada_scales(Session * cc, Model * cm, int num_delay) {
 // audio right-pad, the prompt length, and the adaptive-norm scales (they MUST
 // agree). On success out_text holds the trimmed transcript. Does not touch the
 // result snapshot (segments / full_text / has_result) — the caller owns that.
-transcribe_status forward_buffer(Session * cc, Model * cm,
-                                 const float * pcm, int n_samples,
-                                 int num_delay, bool dumps_on,
-                                 int k_drafts,
+transcribe_status forward_buffer(Session *     cc,
+                                 Model *       cm,
+                                 const float * pcm,
+                                 int           n_samples,
+                                 int           num_delay,
+                                 bool          dumps_on,
+                                 int           k_drafts,
                                  std::string & out_text) {
     if (!cm->mel.has_value()) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral_realtime run: model has no MelFrontend");
@@ -435,10 +486,10 @@ transcribe_status forward_buffer(Session * cc, Model * cm,
     }
 
     // ----- Mel (or reference-injected mel for numerical isolation) -----
-    const int n_mels = cm->hparams.enc_num_mel_bins;
-    int mel_n_frames = 0;
-    bool mel_from_ref = false;
-    const int64_t t_mel_start = ggml_time_us();
+    const int     n_mels       = cm->hparams.enc_num_mel_bins;
+    int           mel_n_frames = 0;
+    bool          mel_from_ref = false;
+    const int64_t t_mel_start  = ggml_time_us();
 #ifdef TRANSCRIBE_ENABLE_VALIDATION_HOOKS
     if (const char * ref_mel_dir = transcribe::env::str("TRANSCRIBE_MEL_FROM_REF")) {
         if (!read_ref_mel(ref_mel_dir, n_mels, cc->mel_buf, mel_n_frames)) {
@@ -454,22 +505,21 @@ transcribe_status forward_buffer(Session * cc, Model * cm,
         //   [n_left_pad zeros] + [raw rounded up to raw_per_tok] + [n_right zeros]
         // raw_per_tok = audio_length_per_tok * hop = 1280 (= sr / frame_rate);
         // n_right = num_delay + 1 (BOS) + OFFLINE_STREAMING_BUFFER_TOKENS(10).
-        const int raw_per_tok = cm->hparams.audio_length_per_tok * cm->hparams.fe_hop_length;
-        const int n_left_tok   = cm->specials.n_left_pad;
-        const int n_right_tok  = num_delay + 1 + 10;
-        const size_t left  = static_cast<size_t>(n_left_tok)  * raw_per_tok;
-        const size_t right = static_cast<size_t>(n_right_tok) * raw_per_tok;
-        const size_t raw_pad =
-            ((static_cast<size_t>(n_samples) + raw_per_tok - 1) / raw_per_tok) * raw_per_tok;
-        const size_t total = left + raw_pad + right;
+        const int          raw_per_tok = cm->hparams.audio_length_per_tok * cm->hparams.fe_hop_length;
+        const int          n_left_tok  = cm->specials.n_left_pad;
+        const int          n_right_tok = num_delay + 1 + 10;
+        const size_t       left        = static_cast<size_t>(n_left_tok) * raw_per_tok;
+        const size_t       right       = static_cast<size_t>(n_right_tok) * raw_per_tok;
+        const size_t       raw_pad = ((static_cast<size_t>(n_samples) + raw_per_tok - 1) / raw_per_tok) * raw_per_tok;
+        const size_t       total   = left + raw_pad + right;
         std::vector<float> padded(total, 0.0f);
         std::memcpy(padded.data() + left, pcm, static_cast<size_t>(n_samples) * sizeof(float));
 
         int mm = 0;
-        if (auto st = cm->mel->compute(padded.data(), total, cc->mel_buf,
-                                       mm, mel_n_frames, cc->n_threads); st != TRANSCRIBE_OK) {
+        if (auto st = cm->mel->compute(padded.data(), total, cc->mel_buf, mm, mel_n_frames, cc->n_threads);
+            st != TRANSCRIBE_OK) {
             log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral_realtime run: mel compute failed (%s)",
-                         transcribe_status_string(st));
+                    transcribe_status_string(st));
             return st;
         }
         if (mm != n_mels) {
@@ -481,68 +531,82 @@ transcribe_status forward_buffer(Session * cc, Model * cm,
 
     if (dumps_on) {
         const long long shape[2] = { n_mels, mel_n_frames };
-        transcribe::debug::dump_host_f32("enc.mel.in", cc->mel_buf.data(),
-            static_cast<long long>(cc->mel_buf.size()), shape, 2, "frontend.mel");
+        transcribe::debug::dump_host_f32("enc.mel.in", cc->mel_buf.data(), static_cast<long long>(cc->mel_buf.size()),
+                                         shape, 2, "frontend.mel");
     }
 
     // ----- Encoder + projector (whole clip) -----
     if (cc->sched == nullptr) {
         cc->sched = ggml_backend_sched_new(cm->plan.scheduler_list.data(), nullptr,
-            static_cast<int>(cm->plan.scheduler_list.size()), 16384, false, true);
-        if (cc->sched == nullptr) return TRANSCRIBE_ERR_GGUF;
+                                           static_cast<int>(cm->plan.scheduler_list.size()), 16384, false, true);
+        if (cc->sched == nullptr) {
+            return TRANSCRIBE_ERR_GGUF;
+        }
     }
 
-    const int dec_h = cm->hparams.dec_hidden;
-    int n_audio = 0;
+    const int     dec_h       = cm->hparams.dec_hidden;
+    int           n_audio     = 0;
     const int64_t t_enc_start = ggml_time_us();
     {
-        if (cc->compute_ctx != nullptr) { ggml_free(cc->compute_ctx); cc->compute_ctx = nullptr; }
-        ggml_init_params ip {};
-        ip.mem_size = 64 * 1024 * 1024;
-        ip.no_alloc = true;
+        if (cc->compute_ctx != nullptr) {
+            ggml_free(cc->compute_ctx);
+            cc->compute_ctx = nullptr;
+        }
+        ggml_init_params ip{};
+        ip.mem_size     = 64 * 1024 * 1024;
+        ip.no_alloc     = true;
         cc->compute_ctx = ggml_init(ip);
         if (cc->compute_ctx == nullptr) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "voxtral_realtime: compute context allocation failed — "
-                "out of memory.");
+                                "voxtral_realtime: compute context allocation failed — "
+                                "out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
 
-        EncoderBuild eb = build_encoder_graph(cc->compute_ctx, cm->weights, cm->hparams,
-                                              mel_n_frames, cc->encoder_use_flash);
-        if (eb.graph == nullptr || eb.out == nullptr) return TRANSCRIBE_ERR_GGUF;
+        EncoderBuild eb =
+            build_encoder_graph(cc->compute_ctx, cm->weights, cm->hparams, mel_n_frames, cc->encoder_use_flash);
+        if (eb.graph == nullptr || eb.out == nullptr) {
+            return TRANSCRIBE_ERR_GGUF;
+        }
         n_audio = eb.n_audio;
 
         ggml_backend_sched_reset(cc->sched);
         if (!ggml_backend_sched_alloc_graph(cc->sched, eb.graph)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "voxtral_realtime run: encoder graph allocation failed — "
-                "out of memory.");
+                                "voxtral_realtime run: encoder graph allocation failed — "
+                                "out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
 
         // mel_buf is mel-major [n_mels, n_frames]; the encoder input is
         // frame-major [n_mels, n_mel_frames] (ne[0]=n_mels innermost).
         std::vector<float> mel_frame_major(static_cast<size_t>(n_mels) * mel_n_frames);
-        for (int t = 0; t < mel_n_frames; ++t)
-            for (int mm = 0; mm < n_mels; ++mm)
+        for (int t = 0; t < mel_n_frames; ++t) {
+            for (int mm = 0; mm < n_mels; ++mm) {
                 mel_frame_major[static_cast<size_t>(t) * n_mels + mm] =
                     cc->mel_buf[static_cast<size_t>(mm) * mel_n_frames + t];
-        ggml_backend_tensor_set(eb.mel_in, mel_frame_major.data(), 0,
-                                mel_frame_major.size() * sizeof(float));
+            }
+        }
+        ggml_backend_tensor_set(eb.mel_in, mel_frame_major.data(), 0, mel_frame_major.size() * sizeof(float));
 
         std::vector<int32_t> positions(eb.T_enc);
-        for (int i = 0; i < eb.T_enc; ++i) positions[i] = i;
+        for (int i = 0; i < eb.T_enc; ++i) {
+            positions[i] = i;
+        }
         ggml_backend_tensor_set(eb.positions_in, positions.data(), 0, positions.size() * sizeof(int32_t));
 
         // Sliding-window-causal mask [T_enc(key), T_enc(query)] f16.
         {
-            const int T = eb.T_enc, win = cm->hparams.enc_sliding_window;
-            const ggml_fp16_t mz = ggml_fp32_to_fp16(0.0f), mn = ggml_fp32_to_fp16(-INFINITY);
+            const int                T = eb.T_enc, win = cm->hparams.enc_sliding_window;
+            const ggml_fp16_t        mz = ggml_fp32_to_fp16(0.0f), mn = ggml_fp32_to_fp16(-INFINITY);
             std::vector<ggml_fp16_t> mask(static_cast<size_t>(T) * T, mn);
-            for (int q = 0; q < T; ++q)
-                for (int k = 0; k <= q; ++k)
-                    if (q - k < win) mask[static_cast<size_t>(q) * T + k] = mz;
+            for (int q = 0; q < T; ++q) {
+                for (int k = 0; k <= q; ++k) {
+                    if (q - k < win) {
+                        mask[static_cast<size_t>(q) * T + k] = mz;
+                    }
+                }
+            }
             ggml_backend_tensor_set(eb.mask_in, mask.data(), 0, mask.size() * sizeof(ggml_fp16_t));
         }
         apply_threads(cc->sched, cc->n_threads);
@@ -553,12 +617,19 @@ transcribe_status forward_buffer(Session * cc, Model * cm,
 
         if (dumps_on) {
             for (size_t i = 0; i < eb.dumps.block_outs.size(); ++i) {
-                char nm[64]; std::snprintf(nm, sizeof(nm), "enc.block.%zu.out", i);
+                char nm[64];
+                std::snprintf(nm, sizeof(nm), "enc.block.%zu.out", i);
                 transcribe::debug::dump_tensor(nm, eb.dumps.block_outs[i], "enc.block");
             }
-            if (eb.dumps.embedder_out) transcribe::debug::dump_tensor("enc.embedder.out", eb.dumps.embedder_out, "enc");
-            if (eb.dumps.enc_out)      transcribe::debug::dump_tensor("enc.out", eb.dumps.enc_out, "enc");
-            if (eb.dumps.proj_out)     transcribe::debug::dump_tensor("proj.out", eb.dumps.proj_out, "proj");
+            if (eb.dumps.embedder_out) {
+                transcribe::debug::dump_tensor("enc.embedder.out", eb.dumps.embedder_out, "enc");
+            }
+            if (eb.dumps.enc_out) {
+                transcribe::debug::dump_tensor("enc.out", eb.dumps.enc_out, "enc");
+            }
+            if (eb.dumps.proj_out) {
+                transcribe::debug::dump_tensor("proj.out", eb.dumps.proj_out, "proj");
+            }
         }
 
         cc->enc_host.assign(static_cast<size_t>(dec_h) * n_audio, 0.0f);
@@ -567,20 +638,22 @@ transcribe_status forward_buffer(Session * cc, Model * cm,
     cc->t_encode_us = ggml_time_us() - t_enc_start;
 
     // ----- Adaptive-norm scales for the active delay -----
-    if (auto st = compute_ada_scales(cc, cm, num_delay); st != TRANSCRIBE_OK) return st;
+    if (auto st = compute_ada_scales(cc, cm, num_delay); st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // ----- Prompt: [BOS] + [STREAMING_PAD]*(n_left_pad + num_delay) -----
     const PromptSpecials & sp = cm->specials;
-    std::vector<int32_t> prompt_ids;
+    std::vector<int32_t>   prompt_ids;
     prompt_ids.push_back(sp.bos);
     const int n_pad = sp.n_left_pad + num_delay;
-    for (int i = 0; i < n_pad; ++i) prompt_ids.push_back(sp.streaming_pad);
+    for (int i = 0; i < n_pad; ++i) {
+        prompt_ids.push_back(sp.streaming_pad);
+    }
     const int T_prompt = static_cast<int>(prompt_ids.size());
     if (T_prompt >= n_audio) {
-        transcribe::log_msg(
-            TRANSCRIBE_LOG_LEVEL_ERROR,
-            "voxtral_realtime run: prompt %d >= n_audio %d (clip too short)",
-            T_prompt, n_audio);
+        transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
+                            "voxtral_realtime run: prompt %d >= n_audio %d (clip too short)", T_prompt, n_audio);
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
 
@@ -590,61 +663,79 @@ transcribe_status forward_buffer(Session * cc, Model * cm,
     const int abs_cap = voxtral_realtime_abs_position_cap(cm->hparams);
     if (n_audio + 1 > abs_cap) {
         transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "voxtral_realtime run: clip needs %d positions > model max %d "
-            "(dec_max_position, ~2.9 h). See transcribe_capabilities.max_audio_ms.",
-            n_audio + 1, abs_cap);
+                            "voxtral_realtime run: clip needs %d positions > model max %d "
+                            "(dec_max_position, ~2.9 h). See transcribe_capabilities.max_audio_ms.",
+                            n_audio + 1, abs_cap);
         return TRANSCRIBE_ERR_INPUT_TOO_LONG;
     }
 
     // Grow KV to fit n_audio positions.
     if (cc->kv_cache.n_ctx < n_audio + 1) {
         const ggml_type kv_type = (cc->kv_type == TRANSCRIBE_KV_TYPE_F32) ? GGML_TYPE_F32 : GGML_TYPE_F16;
-        int want = 2048; while (want < n_audio + 1) want *= 2;
+        int             want    = 2048;
+        while (want < n_audio + 1) {
+            want *= 2;
+        }
         cc->kv_cache.free();
-        if (!transcribe::causal_lm::kv_init(cc->kv_cache, cm->plan.primary, want,
-                cm->hparams.dec_n_kv_heads, cm->hparams.dec_head_dim,
-                cm->hparams.dec_n_layers, kv_type)) {
+        if (!transcribe::causal_lm::kv_init(cc->kv_cache, cm->plan.primary, want, cm->hparams.dec_n_kv_heads,
+                                            cm->hparams.dec_head_dim, cm->hparams.dec_n_layers, kv_type)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "voxtral_realtime run: KV cache allocation failed — "
-                "out of memory.");
+                                "voxtral_realtime run: KV cache allocation failed — "
+                                "out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
     }
 
-    const int vocab = cm->hparams.dec_vocab_size;
+    const int     vocab  = cm->hparams.dec_vocab_size;
     const int32_t eos_id = cm->hparams.eos_token_id;
-    auto argmax = [](const std::vector<float> & v) -> int32_t {
-        int32_t best = 0; float bv = v[0];
-        for (int32_t i = 1; i < static_cast<int32_t>(v.size()); ++i) if (v[i] > bv) { bv = v[i]; best = i; }
+    auto          argmax = [](const std::vector<float> & v) -> int32_t {
+        int32_t best = 0;
+        float   bv   = v[0];
+        for (int32_t i = 1; i < static_cast<int32_t>(v.size()); ++i) {
+            if (v[i] > bv) {
+                bv   = v[i];
+                best = i;
+            }
+        }
         return best;
     };
 
     // ----- Autoregressive generation (prompt prefill + steps) -----
     const int64_t t_dec_start = ggml_time_us();
-    if (cc->kv_cache.buffer != nullptr) ggml_backend_buffer_clear(cc->kv_cache.buffer, 0);
-    cc->kv_cache.n = 0; cc->kv_cache.head = 0;
+    if (cc->kv_cache.buffer != nullptr) {
+        ggml_backend_buffer_clear(cc->kv_cache.buffer, 0);
+    }
+    cc->kv_cache.n    = 0;
+    cc->kv_cache.head = 0;
 
     std::vector<int32_t> generated_ids;
     {
-        if (cc->compute_ctx != nullptr) { ggml_free(cc->compute_ctx); cc->compute_ctx = nullptr; }
-        ggml_init_params ip {}; ip.mem_size = 64 * 1024 * 1024; ip.no_alloc = true;
+        if (cc->compute_ctx != nullptr) {
+            ggml_free(cc->compute_ctx);
+            cc->compute_ctx = nullptr;
+        }
+        ggml_init_params ip{};
+        ip.mem_size     = 64 * 1024 * 1024;
+        ip.no_alloc     = true;
         cc->compute_ctx = ggml_init(ip);
         if (cc->compute_ctx == nullptr) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "voxtral_realtime: compute context allocation failed — "
-                "out of memory.");
+                                "voxtral_realtime: compute context allocation failed — "
+                                "out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
 
-        PrefillBuild pb = build_prefill_graph(cc->compute_ctx, cm->weights, cm->hparams,
-            cc->kv_cache, cc->ada_scale_all, T_prompt, cc->decoder_use_flash,
-            /*want_all_logits=*/false);
-        if (pb.graph == nullptr || pb.out == nullptr) return TRANSCRIBE_ERR_GGUF;
+        PrefillBuild pb = build_prefill_graph(cc->compute_ctx, cm->weights, cm->hparams, cc->kv_cache,
+                                              cc->ada_scale_all, T_prompt, cc->decoder_use_flash,
+                                              /*want_all_logits=*/false);
+        if (pb.graph == nullptr || pb.out == nullptr) {
+            return TRANSCRIBE_ERR_GGUF;
+        }
         ggml_backend_sched_reset(cc->sched);
         if (!ggml_backend_sched_alloc_graph(cc->sched, pb.graph)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "voxtral_realtime run: prefill graph allocation failed — "
-                "out of memory.");
+                                "voxtral_realtime run: prefill graph allocation failed — "
+                                "out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
 
@@ -652,13 +743,18 @@ transcribe_status forward_buffer(Session * cc, Model * cm,
         ggml_backend_tensor_set(pb.audio_in, cc->enc_host.data(), 0,
                                 static_cast<size_t>(dec_h) * T_prompt * sizeof(float));
         std::vector<int32_t> positions(T_prompt);
-        for (int i = 0; i < T_prompt; ++i) positions[i] = i;
+        for (int i = 0; i < T_prompt; ++i) {
+            positions[i] = i;
+        }
         ggml_backend_tensor_set(pb.positions_in, positions.data(), 0, positions.size() * sizeof(int32_t));
         {
-            const ggml_fp16_t mz = ggml_fp32_to_fp16(0.0f), mn = ggml_fp32_to_fp16(-INFINITY);
+            const ggml_fp16_t        mz = ggml_fp32_to_fp16(0.0f), mn = ggml_fp32_to_fp16(-INFINITY);
             std::vector<ggml_fp16_t> mask(static_cast<size_t>(T_prompt) * T_prompt, mn);
-            for (int r = 0; r < T_prompt; ++r) for (int c = 0; c <= r; ++c)
-                mask[static_cast<size_t>(r) * T_prompt + c] = mz;
+            for (int r = 0; r < T_prompt; ++r) {
+                for (int c = 0; c <= r; ++c) {
+                    mask[static_cast<size_t>(r) * T_prompt + c] = mz;
+                }
+            }
             ggml_backend_tensor_set(pb.mask_in, mask.data(), 0, mask.size() * sizeof(ggml_fp16_t));
         }
         apply_threads(cc->sched, cc->n_threads);
@@ -666,7 +762,8 @@ transcribe_status forward_buffer(Session * cc, Model * cm,
             log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral_realtime run: prefill compute failed");
             return TRANSCRIBE_ERR_GGUF;
         }
-        cc->kv_cache.n = T_prompt; cc->kv_cache.head = T_prompt;
+        cc->kv_cache.n    = T_prompt;
+        cc->kv_cache.head = T_prompt;
 
         std::vector<float> logits(vocab);
         ggml_backend_tensor_get(pb.out, logits.data(), 0, logits.size() * sizeof(float));
@@ -681,48 +778,59 @@ transcribe_status forward_buffer(Session * cc, Model * cm,
     {
         const int max_n_kv = n_audio;
 
-        if (cc->compute_ctx != nullptr) { ggml_free(cc->compute_ctx); cc->compute_ctx = nullptr; }
-        ggml_init_params ip {}; ip.mem_size = 128 * 1024 * 1024; ip.no_alloc = true;
+        if (cc->compute_ctx != nullptr) {
+            ggml_free(cc->compute_ctx);
+            cc->compute_ctx = nullptr;
+        }
+        ggml_init_params ip{};
+        ip.mem_size     = 128 * 1024 * 1024;
+        ip.no_alloc     = true;
         cc->compute_ctx = ggml_init(ip);
         if (cc->compute_ctx == nullptr) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "voxtral_realtime: compute context allocation failed — "
-                "out of memory.");
+                                "voxtral_realtime: compute context allocation failed — "
+                                "out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
 
         const ggml_fp16_t mz = ggml_fp32_to_fp16(0.0f), mn = ggml_fp32_to_fp16(-INFINITY);
 
         int32_t next_tok = generated_ids.back();
-        int cur_pos = T_prompt;
+        int     cur_pos  = T_prompt;
 
         if (k_drafts == 0) {
             // ---- Plain autoregression (zero spec overhead) ----
-            StepBuild sb = build_step_graph(cc->compute_ctx, cm->weights, cm->hparams,
-                cc->kv_cache, cc->ada_scale_all, max_n_kv, cc->decoder_use_flash);
-            if (sb.graph == nullptr || sb.out == nullptr) return TRANSCRIBE_ERR_GGUF;
+            StepBuild sb = build_step_graph(cc->compute_ctx, cm->weights, cm->hparams, cc->kv_cache, cc->ada_scale_all,
+                                            max_n_kv, cc->decoder_use_flash);
+            if (sb.graph == nullptr || sb.out == nullptr) {
+                return TRANSCRIBE_ERR_GGUF;
+            }
             ggml_backend_sched_reset(cc->sched);
             if (!ggml_backend_sched_alloc_graph(cc->sched, sb.graph)) {
                 transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                    "voxtral_realtime run: step graph allocation failed — "
-                    "out of memory.");
+                                    "voxtral_realtime run: step graph allocation failed — "
+                                    "out of memory.");
                 return TRANSCRIBE_ERR_OOM;
             }
             apply_threads(cc->sched, cc->n_threads);
 
             std::vector<ggml_fp16_t> step_mask(max_n_kv, mn);
             while (next_tok != eos_id && cur_pos < n_audio) {
-                if (cc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
+                if (cc->poll_abort()) {
+                    return TRANSCRIBE_ERR_ABORTED;
+                }
                 ggml_backend_tensor_set(sb.input_id_in, &next_tok, 0, sizeof(int32_t));
-                ggml_backend_tensor_set(sb.audio_in,
-                    cc->enc_host.data() + static_cast<size_t>(cur_pos) * dec_h, 0,
-                    static_cast<size_t>(dec_h) * sizeof(float));
+                ggml_backend_tensor_set(sb.audio_in, cc->enc_host.data() + static_cast<size_t>(cur_pos) * dec_h, 0,
+                                        static_cast<size_t>(dec_h) * sizeof(float));
                 const int32_t pos_val = cur_pos;
                 ggml_backend_tensor_set(sb.position_in, &pos_val, 0, sizeof(int32_t));
                 const int64_t kv_idx = cur_pos;
                 ggml_backend_tensor_set(sb.kv_idx_in, &kv_idx, 0, sizeof(int64_t));
-                if (cur_pos == T_prompt) std::fill(step_mask.begin(), step_mask.begin() + cur_pos + 1, mz);
-                else step_mask[cur_pos] = mz;
+                if (cur_pos == T_prompt) {
+                    std::fill(step_mask.begin(), step_mask.begin() + cur_pos + 1, mz);
+                } else {
+                    step_mask[cur_pos] = mz;
+                }
                 ggml_backend_tensor_set(sb.mask_in, step_mask.data(), 0,
                                         static_cast<size_t>(max_n_kv) * sizeof(ggml_fp16_t));
                 if (ggml_backend_sched_graph_compute(cc->sched, sb.graph) != GGML_STATUS_SUCCESS) {
@@ -733,8 +841,11 @@ transcribe_status forward_buffer(Session * cc, Model * cm,
                 ggml_backend_tensor_get(sb.out, &tok, 0, sizeof(int32_t));
                 next_tok = tok;
                 cur_pos += 1;
-                cc->kv_cache.n = cur_pos + 1; cc->kv_cache.head = cur_pos + 1;
-                if (next_tok == eos_id) break;
+                cc->kv_cache.n    = cur_pos + 1;
+                cc->kv_cache.head = cur_pos + 1;
+                if (next_tok == eos_id) {
+                    break;
+                }
                 generated_ids.push_back(next_tok);
             }
         } else {
@@ -747,14 +858,16 @@ transcribe_status forward_buffer(Session * cc, Model * cm,
             // garbage predictions at those columns are never committed.
             cc->enc_host.resize(static_cast<size_t>(dec_h) * (n_audio + K_DRAFTS), 0.0f);
 
-            VerifyBuild vb = build_verify_graph(cc->compute_ctx, cm->weights, cm->hparams,
-                cc->kv_cache, cc->ada_scale_all, T_verify, max_n_kv, cc->decoder_use_flash);
-            if (vb.graph == nullptr || vb.out == nullptr) return TRANSCRIBE_ERR_GGUF;
+            VerifyBuild vb = build_verify_graph(cc->compute_ctx, cm->weights, cm->hparams, cc->kv_cache,
+                                                cc->ada_scale_all, T_verify, max_n_kv, cc->decoder_use_flash);
+            if (vb.graph == nullptr || vb.out == nullptr) {
+                return TRANSCRIBE_ERR_GGUF;
+            }
             ggml_backend_sched_reset(cc->sched);
             if (!ggml_backend_sched_alloc_graph(cc->sched, vb.graph)) {
                 transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                    "voxtral_realtime run: verify graph allocation failed — "
-                    "out of memory.");
+                                    "voxtral_realtime run: verify graph allocation failed — "
+                                    "out of memory.");
                 return TRANSCRIBE_ERR_OOM;
             }
             apply_threads(cc->sched, cc->n_threads);
@@ -769,41 +882,46 @@ transcribe_status forward_buffer(Session * cc, Model * cm,
 
             std::unordered_map<int32_t, int> last_pos_by_tok;
             last_pos_by_tok.reserve(static_cast<size_t>(n_audio));
-            for (int p = 0; p < T_prompt; ++p) last_pos_by_tok[prompt_ids[p]] = p;
+            for (int p = 0; p < T_prompt; ++p) {
+                last_pos_by_tok[prompt_ids[p]] = p;
+            }
 
-            std::vector<int32_t>      in_ids(T_verify, 0);
-            std::vector<int32_t>      positions(T_verify, 0);
-            std::vector<int64_t>      kv_idxs(T_verify, 0);
-            std::vector<float>        audio_buf(static_cast<size_t>(dec_h) * T_verify);
-            std::vector<ggml_fp16_t>  verify_mask(static_cast<size_t>(max_n_kv) * T_verify, mn);
-            std::vector<int32_t>      predicted(T_verify, 0);
-            std::vector<int32_t>      draft(K_DRAFTS, 0);
+            std::vector<int32_t>     in_ids(T_verify, 0);
+            std::vector<int32_t>     positions(T_verify, 0);
+            std::vector<int64_t>     kv_idxs(T_verify, 0);
+            std::vector<float>       audio_buf(static_cast<size_t>(dec_h) * T_verify);
+            std::vector<ggml_fp16_t> verify_mask(static_cast<size_t>(max_n_kv) * T_verify, mn);
+            std::vector<int32_t>     predicted(T_verify, 0);
+            std::vector<int32_t>     draft(K_DRAFTS, 0);
 
             while (next_tok != eos_id && cur_pos < n_audio) {
-                if (cc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
+                if (cc->poll_abort()) {
+                    return TRANSCRIBE_ERR_ABORTED;
+                }
 
                 // Build draft via 1-gram suffix lookup. Fallback when no
                 // match: K copies of STREAMING_PAD (id 32), the dominant
                 // token in the stream — gives free acceptance during silence.
-                int draft_origin = -1;
-                auto it = last_pos_by_tok.find(next_tok);
-                if (it != last_pos_by_tok.end()) draft_origin = it->second;
+                int  draft_origin = -1;
+                auto it           = last_pos_by_tok.find(next_tok);
+                if (it != last_pos_by_tok.end()) {
+                    draft_origin = it->second;
+                }
                 for (int k = 0; k < K_DRAFTS; ++k) {
                     const int src = (draft_origin >= 0) ? (draft_origin + 1 + k) : -1;
-                    draft[k] = (src >= 0 && src < static_cast<int>(all_ids.size()))
-                        ? all_ids[src] : 32 /* STREAMING_PAD */;
+                    draft[k] =
+                        (src >= 0 && src < static_cast<int>(all_ids.size())) ? all_ids[src] : 32 /* STREAMING_PAD */;
                 }
 
-                in_ids[0] = next_tok;
+                in_ids[0]    = next_tok;
                 positions[0] = cur_pos;
-                kv_idxs[0] = cur_pos;
+                kv_idxs[0]   = cur_pos;
                 for (int c = 1; c < T_verify; ++c) {
-                    in_ids[c] = draft[c - 1];
+                    in_ids[c]    = draft[c - 1];
                     positions[c] = cur_pos + c;
-                    kv_idxs[c] = cur_pos + c;
+                    kv_idxs[c]   = cur_pos + c;
                 }
-                std::memcpy(audio_buf.data(),
-                            cc->enc_host.data() + static_cast<size_t>(cur_pos) * dec_h,
+                std::memcpy(audio_buf.data(), cc->enc_host.data() + static_cast<size_t>(cur_pos) * dec_h,
                             static_cast<size_t>(dec_h) * T_verify * sizeof(float));
 
                 // Per-column causal mask. Cheap to rebuild each iter
@@ -824,34 +942,36 @@ transcribe_status forward_buffer(Session * cc, Model * cm,
                                         static_cast<size_t>(T_verify) * sizeof(int32_t));
                 ggml_backend_tensor_set(vb.kv_idx_in, kv_idxs.data(), 0,
                                         static_cast<size_t>(T_verify) * sizeof(int64_t));
-                ggml_backend_tensor_set(vb.mask_in, verify_mask.data(), 0,
-                                        verify_mask.size() * sizeof(ggml_fp16_t));
+                ggml_backend_tensor_set(vb.mask_in, verify_mask.data(), 0, verify_mask.size() * sizeof(ggml_fp16_t));
 
                 if (ggml_backend_sched_graph_compute(cc->sched, vb.graph) != GGML_STATUS_SUCCESS) {
                     log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral_realtime run: verify compute failed");
                     return TRANSCRIBE_ERR_GGUF;
                 }
 
-                ggml_backend_tensor_get(vb.out, predicted.data(), 0,
-                                        static_cast<size_t>(T_verify) * sizeof(int32_t));
+                ggml_backend_tensor_get(vb.out, predicted.data(), 0, static_cast<size_t>(T_verify) * sizeof(int32_t));
 
                 // Accept the longest matched prefix; cap so we never commit
                 // a position past n_audio (matches the original step loop's
                 // horizon).
                 int n_accept = 0;
-                while (n_accept < K_DRAFTS
-                       && predicted[n_accept] == draft[n_accept]
-                       && (cur_pos + 1 + (n_accept + 1)) <= n_audio) {
+                while (n_accept < K_DRAFTS && predicted[n_accept] == draft[n_accept] &&
+                       (cur_pos + 1 + (n_accept + 1)) <= n_audio) {
                     n_accept++;
                 }
 
                 const int prev_size = static_cast<int>(all_ids.size());
-                bool hit_eos = false;
+                bool      hit_eos   = false;
                 for (int i = 0; i <= n_accept; ++i) {
                     const int32_t tok = predicted[i];
-                    const int pos = cur_pos + 1 + i;
-                    if (pos > n_audio) break;
-                    if (tok == eos_id) { hit_eos = true; break; }
+                    const int     pos = cur_pos + 1 + i;
+                    if (pos > n_audio) {
+                        break;
+                    }
+                    if (tok == eos_id) {
+                        hit_eos = true;
+                        break;
+                    }
                     all_ids.push_back(tok);
                     generated_ids.push_back(tok);
                     last_pos_by_tok[tok] = pos;
@@ -867,18 +987,22 @@ transcribe_status forward_buffer(Session * cc, Model * cm,
                 if (static_cast<int>(all_ids.size()) == prev_size) {
                     if (!hit_eos) {
                         log_msg(TRANSCRIBE_LOG_LEVEL_INFO,
-                            "voxtral_realtime spec: no commit at cur_pos=%d "
-                            "(n_audio=%d, predicted[0]=%d) — breaking",
-                            cur_pos, n_audio, predicted[0]);
+                                "voxtral_realtime spec: no commit at cur_pos=%d "
+                                "(n_audio=%d, predicted[0]=%d) — breaking",
+                                cur_pos, n_audio, predicted[0]);
                     }
                     break;
                 }
 
-                cur_pos = static_cast<int>(all_ids.size()) - 1;
-                next_tok = all_ids.back();
-                cc->kv_cache.n = cur_pos + 1; cc->kv_cache.head = cur_pos + 1;
+                cur_pos           = static_cast<int>(all_ids.size()) - 1;
+                next_tok          = all_ids.back();
+                cc->kv_cache.n    = cur_pos + 1;
+                cc->kv_cache.head = cur_pos + 1;
 
-                if (hit_eos) { next_tok = eos_id; break; }
+                if (hit_eos) {
+                    next_tok = eos_id;
+                    break;
+                }
             }
         }
     }
@@ -889,46 +1013,62 @@ transcribe_status forward_buffer(Session * cc, Model * cm,
         std::vector<int32_t> full_ids = prompt_ids;
         full_ids.insert(full_ids.end(), generated_ids.begin(), generated_ids.end());
         const int pad_id = (cm->hparams.pad_token_id >= 0) ? cm->hparams.pad_token_id : 11;
-        if (static_cast<int>(full_ids.size()) < n_audio)
+        if (static_cast<int>(full_ids.size()) < n_audio) {
             full_ids.resize(n_audio, pad_id);
-        else
+        } else {
             full_ids.resize(n_audio);
+        }
 
-        if (cc->kv_cache.buffer != nullptr) ggml_backend_buffer_clear(cc->kv_cache.buffer, 0);
-        cc->kv_cache.n = 0; cc->kv_cache.head = 0;
+        if (cc->kv_cache.buffer != nullptr) {
+            ggml_backend_buffer_clear(cc->kv_cache.buffer, 0);
+        }
+        cc->kv_cache.n    = 0;
+        cc->kv_cache.head = 0;
 
-        if (cc->compute_ctx != nullptr) { ggml_free(cc->compute_ctx); cc->compute_ctx = nullptr; }
-        ggml_init_params ip {}; ip.mem_size = 256 * 1024 * 1024; ip.no_alloc = true;
+        if (cc->compute_ctx != nullptr) {
+            ggml_free(cc->compute_ctx);
+            cc->compute_ctx = nullptr;
+        }
+        ggml_init_params ip{};
+        ip.mem_size     = 256 * 1024 * 1024;
+        ip.no_alloc     = true;
         cc->compute_ctx = ggml_init(ip);
         if (cc->compute_ctx == nullptr) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "voxtral_realtime: compute context allocation failed — "
-                "out of memory.");
+                                "voxtral_realtime: compute context allocation failed — "
+                                "out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
 
-        PrefillBuild tf = build_prefill_graph(cc->compute_ctx, cm->weights, cm->hparams,
-            cc->kv_cache, cc->ada_scale_all, n_audio, cc->decoder_use_flash,
-            /*want_all_logits=*/true);
-        if (tf.graph == nullptr || tf.out == nullptr) return TRANSCRIBE_ERR_GGUF;
+        PrefillBuild tf = build_prefill_graph(cc->compute_ctx, cm->weights, cm->hparams, cc->kv_cache,
+                                              cc->ada_scale_all, n_audio, cc->decoder_use_flash,
+                                              /*want_all_logits=*/true);
+        if (tf.graph == nullptr || tf.out == nullptr) {
+            return TRANSCRIBE_ERR_GGUF;
+        }
         ggml_backend_sched_reset(cc->sched);
         if (!ggml_backend_sched_alloc_graph(cc->sched, tf.graph)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "voxtral_realtime run: tail-forward graph allocation failed — "
-                "out of memory.");
+                                "voxtral_realtime run: tail-forward graph allocation failed — "
+                                "out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
 
         ggml_backend_tensor_set(tf.input_ids_in, full_ids.data(), 0, full_ids.size() * sizeof(int32_t));
         ggml_backend_tensor_set(tf.audio_in, cc->enc_host.data(), 0, cc->enc_host.size() * sizeof(float));
         std::vector<int32_t> positions(n_audio);
-        for (int i = 0; i < n_audio; ++i) positions[i] = i;
+        for (int i = 0; i < n_audio; ++i) {
+            positions[i] = i;
+        }
         ggml_backend_tensor_set(tf.positions_in, positions.data(), 0, positions.size() * sizeof(int32_t));
         {
-            const ggml_fp16_t mz = ggml_fp32_to_fp16(0.0f), mn = ggml_fp32_to_fp16(-INFINITY);
+            const ggml_fp16_t        mz = ggml_fp32_to_fp16(0.0f), mn = ggml_fp32_to_fp16(-INFINITY);
             std::vector<ggml_fp16_t> mask(static_cast<size_t>(n_audio) * n_audio, mn);
-            for (int r = 0; r < n_audio; ++r) for (int c = 0; c <= r; ++c)
-                mask[static_cast<size_t>(r) * n_audio + c] = mz;
+            for (int r = 0; r < n_audio; ++r) {
+                for (int c = 0; c <= r; ++c) {
+                    mask[static_cast<size_t>(r) * n_audio + c] = mz;
+                }
+            }
             ggml_backend_tensor_set(tf.mask_in, mask.data(), 0, mask.size() * sizeof(ggml_fp16_t));
         }
         apply_threads(cc->sched, cc->n_threads);
@@ -938,28 +1078,38 @@ transcribe_status forward_buffer(Session * cc, Model * cm,
         }
 
         auto dump = [&](const char * n, ggml_tensor * t, const char * s) {
-            if (t != nullptr) transcribe::debug::dump_tensor(n, t, s);
+            if (t != nullptr) {
+                transcribe::debug::dump_tensor(n, t, s);
+            }
         };
-        dump("dec.token_emb",       tf.dumps.token_emb,       "dec");
-        dump("dec.audio_injected",  tf.dumps.audio_injected,  "dec");
-        dump("dec.block.0.out",     tf.dumps.block_0_out,     "dec");
-        { char nm[64]; std::snprintf(nm, sizeof(nm), "dec.block.%d.out", cm->hparams.dec_n_layers / 2);
-          dump(nm, tf.dumps.block_mid_out, "dec"); }
-        { char nm[64]; std::snprintf(nm, sizeof(nm), "dec.block.%d.out", cm->hparams.dec_n_layers - 1);
-          dump(nm, tf.dumps.block_last_out, "dec"); }
+        dump("dec.token_emb", tf.dumps.token_emb, "dec");
+        dump("dec.audio_injected", tf.dumps.audio_injected, "dec");
+        dump("dec.block.0.out", tf.dumps.block_0_out, "dec");
+        {
+            char nm[64];
+            std::snprintf(nm, sizeof(nm), "dec.block.%d.out", cm->hparams.dec_n_layers / 2);
+            dump(nm, tf.dumps.block_mid_out, "dec");
+        }
+        {
+            char nm[64];
+            std::snprintf(nm, sizeof(nm), "dec.block.%d.out", cm->hparams.dec_n_layers - 1);
+            dump(nm, tf.dumps.block_last_out, "dec");
+        }
         dump("dec.out_before_head", tf.dumps.out_before_head, "dec");
 
         // gen0 / gen8 logits: columns (T_prompt-1) and (T_prompt-1+8) of [vocab, n_audio].
         std::vector<float> logits_all(static_cast<size_t>(vocab) * n_audio);
         ggml_backend_tensor_get(tf.dumps.logits_all, logits_all.data(), 0, logits_all.size() * sizeof(float));
         const long long lshape[1] = { vocab };
-        const int g0 = T_prompt - 1, g8 = T_prompt - 1 + 8;
-        if (g0 >= 0 && g0 < n_audio)
+        const int       g0 = T_prompt - 1, g8 = T_prompt - 1 + 8;
+        if (g0 >= 0 && g0 < n_audio) {
             transcribe::debug::dump_host_f32("dec.logits_raw", logits_all.data() + static_cast<size_t>(g0) * vocab,
                                              vocab, lshape, 1, "dec");
-        if (g8 >= 0 && g8 < n_audio)
+        }
+        if (g8 >= 0 && g8 < n_audio) {
             transcribe::debug::dump_host_f32("dec.logits_raw.gen8", logits_all.data() + static_cast<size_t>(g8) * vocab,
                                              vocab, lshape, 1, "dec");
+        }
     }
 
     // ----- Decode transcript -----
@@ -969,12 +1119,18 @@ transcribe_status forward_buffer(Session * cc, Model * cm,
     std::vector<int32_t> text_ids;
     text_ids.reserve(generated_ids.size());
     for (int32_t id : generated_ids) {
-        if (!cm->tok.is_control(id)) text_ids.push_back(id);
+        if (!cm->tok.is_control(id)) {
+            text_ids.push_back(id);
+        }
     }
     std::string text = cm->tok.decode(text_ids.data(), static_cast<int>(text_ids.size()));
-    size_t b = 0, e = text.size();
-    while (b < e && std::isspace(static_cast<unsigned char>(text[b]))) ++b;
-    while (e > b && std::isspace(static_cast<unsigned char>(text[e - 1]))) --e;
+    size_t      b = 0, e = text.size();
+    while (b < e && std::isspace(static_cast<unsigned char>(text[b]))) {
+        ++b;
+    }
+    while (e > b && std::isspace(static_cast<unsigned char>(text[e - 1]))) {
+        --e;
+    }
     text = text.substr(b, e - b);
 
     out_text = std::move(text);
@@ -983,13 +1139,21 @@ transcribe_status forward_buffer(Session * cc, Model * cm,
 
 // Offline one-shot entry point. Thin wrapper over forward_buffer that owns the
 // result snapshot (full_text + a single text-only segment).
-transcribe_status run(transcribe_session * session, const float * pcm, int n_samples,
+transcribe_status run(transcribe_session *          session,
+                      const float *                 pcm,
+                      int                           n_samples,
                       const transcribe_run_params * params) {
-    if (session == nullptr || pcm == nullptr || n_samples <= 0) return TRANSCRIBE_ERR_INVALID_ARG;
+    if (session == nullptr || pcm == nullptr || n_samples <= 0) {
+        return TRANSCRIBE_ERR_INVALID_ARG;
+    }
     auto * cc = static_cast<Session *>(session);
     auto * cm = static_cast<Model *>(cc->model);
-    if (cm == nullptr || cm->plan.scheduler_list.empty()) return TRANSCRIBE_ERR_INVALID_ARG;
-    if (cc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
+    if (cm == nullptr || cm->plan.scheduler_list.empty()) {
+        return TRANSCRIBE_ERR_INVALID_ARG;
+    }
+    if (cc->poll_abort()) {
+        return TRANSCRIBE_ERR_ABORTED;
+    }
 
     transcribe::debug::init();
     const bool dumps_on = transcribe::debug::enabled();
@@ -1001,25 +1165,30 @@ transcribe_status run(transcribe_session * session, const float * pcm, int n_sam
     // 1-gram acceptance is too low to amortize the T=K+1 verify graph). See
     // docs/models/voxtral-realtime.md.
     constexpr int VOXTRAL_REALTIME_SPEC_K_MAX = 8;
-    int k_drafts = 1;
-    if (params != nullptr && params->struct_size >=
-        offsetof(transcribe_run_params, spec_k_drafts) + sizeof(params->spec_k_drafts)) {
+    int           k_drafts                    = 1;
+    if (params != nullptr &&
+        params->struct_size >= offsetof(transcribe_run_params, spec_k_drafts) + sizeof(params->spec_k_drafts)) {
         const int requested = params->spec_k_drafts;
-        if (requested == 0)      k_drafts = 0;
-        else if (requested > 0)  k_drafts = std::min(requested, VOXTRAL_REALTIME_SPEC_K_MAX);
+        if (requested == 0) {
+            k_drafts = 0;
+        } else if (requested > 0) {
+            k_drafts = std::min(requested, VOXTRAL_REALTIME_SPEC_K_MAX);
+        }
         // requested == -1 keeps the family default; requested < -1 falls
         // through to the family default (matches the silent-ignore semantics).
     }
 
     std::string text;
-    if (auto st = forward_buffer(cc, cm, pcm, n_samples,
-                                 cm->hparams.default_num_delay_tokens, dumps_on, k_drafts, text);
-        st != TRANSCRIBE_OK) return st;
+    if (auto st =
+            forward_buffer(cc, cm, pcm, n_samples, cm->hparams.default_num_delay_tokens, dumps_on, k_drafts, text);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     cc->full_text   = text;
     cc->result_kind = TRANSCRIBE_TIMESTAMPS_NONE;
     cc->has_result  = true;
-    transcribe_session::SegmentEntry seg {};
+    transcribe_session::SegmentEntry seg{};
     seg.text  = text;
     seg.t0_ms = 0;
     seg.t1_ms = static_cast<int64_t>(n_samples) * 1000 / static_cast<int64_t>(cm->hparams.fe_sample_rate);
@@ -1040,31 +1209,42 @@ constexpr int k_default_min_decode_interval_ms = 1000;
 // Resolve the stream extension (delay + decode throttle). Reads only the
 // caller-owned stream_params; mutates nothing.
 transcribe_status resolve_stream_ext(const transcribe_stream_params * sp,
-                                     const Model * cm,
-                                     int * out_num_delay, int * out_min_decode_ms) {
-    int num_delay     = cm->hparams.default_num_delay_tokens;
-    int min_decode_ms = k_default_min_decode_interval_ms;
-    const transcribe_ext * fam = (sp != nullptr) ? sp->family : nullptr;
-    if (const transcribe_status st = transcribe_ext_check(
-            fam, TRANSCRIBE_EXT_KIND_VOXTRAL_REALTIME_STREAM,
-            sizeof(transcribe_voxtral_realtime_stream_ext)); st != TRANSCRIBE_OK) {
+                                     const Model *                    cm,
+                                     int *                            out_num_delay,
+                                     int *                            out_min_decode_ms) {
+    int                    num_delay     = cm->hparams.default_num_delay_tokens;
+    int                    min_decode_ms = k_default_min_decode_interval_ms;
+    const transcribe_ext * fam           = (sp != nullptr) ? sp->family : nullptr;
+    if (const transcribe_status st = transcribe_ext_check(fam, TRANSCRIBE_EXT_KIND_VOXTRAL_REALTIME_STREAM,
+                                                          sizeof(transcribe_voxtral_realtime_stream_ext));
+        st != TRANSCRIBE_OK) {
         return st;
     }
     if (fam != nullptr) {
-        const auto * vx =
-            reinterpret_cast<const transcribe_voxtral_realtime_stream_ext *>(fam);
+        const auto *  vx = reinterpret_cast<const transcribe_voxtral_realtime_stream_ext *>(fam);
         // num_delay_tokens: -1 = model default (6 = 480 ms). Otherwise a
         // publisher-validated delay: tokens 1..15 (80..1200 ms) or 30 (2400 ms).
         // One token = 80 ms (12.5 Hz grid).
         const int32_t nt = vx->num_delay_tokens;
-        if (nt != -1 && !((nt >= 1 && nt <= 15) || nt == 30))
+        if (nt != -1 && !((nt >= 1 && nt <= 15) || nt == 30)) {
             return TRANSCRIBE_ERR_INVALID_ARG;
-        if (nt >= 0) num_delay = nt;
-        if (vx->min_decode_interval_ms < -1) return TRANSCRIBE_ERR_INVALID_ARG;
-        if (vx->min_decode_interval_ms >= 0) min_decode_ms = vx->min_decode_interval_ms;
+        }
+        if (nt >= 0) {
+            num_delay = nt;
+        }
+        if (vx->min_decode_interval_ms < -1) {
+            return TRANSCRIBE_ERR_INVALID_ARG;
+        }
+        if (vx->min_decode_interval_ms >= 0) {
+            min_decode_ms = vx->min_decode_interval_ms;
+        }
+    }
+    if (out_num_delay) {
+        *out_num_delay = num_delay;
+    }
+    if (out_min_decode_ms) {
+        *out_min_decode_ms = min_decode_ms;
     }
-    if (out_num_delay)     *out_num_delay     = num_delay;
-    if (out_min_decode_ms) *out_min_decode_ms = min_decode_ms;
     return TRANSCRIBE_OK;
 }
 
@@ -1076,7 +1256,7 @@ void publish_stream_text(Session * cc, Model * cm, std::string text, int64_t aud
     cc->result_kind = TRANSCRIBE_TIMESTAMPS_NONE;
     cc->has_result  = true;
     cc->segments.clear();
-    transcribe_session::SegmentEntry seg {};
+    transcribe_session::SegmentEntry seg{};
     seg.text  = std::move(text);
     seg.t0_ms = 0;
     seg.t1_ms = audio_ms;
@@ -1089,7 +1269,9 @@ transcribe_status stream_validate(const transcribe_session * session,
                                   const transcribe_stream_params * stream_params) {
     const auto * cc = static_cast<const Session *>(session);
     const auto * cm = static_cast<const Model *>(cc->model);
-    if (cm == nullptr || cm->plan.scheduler_list.empty()) return TRANSCRIBE_ERR_INVALID_ARG;
+    if (cm == nullptr || cm->plan.scheduler_list.empty()) {
+        return TRANSCRIBE_ERR_INVALID_ARG;
+    }
     int nd = 0, md = 0;
     return resolve_stream_ext(stream_params, cm, &nd, &md);
 }
@@ -1098,36 +1280,50 @@ transcribe_status stream_validate(const transcribe_session * session,
 std::string detok_generated(Model * cm, const std::vector<int32_t> & ids) {
     std::vector<int32_t> text_ids;
     text_ids.reserve(ids.size());
-    for (int32_t id : ids) if (!cm->tok.is_control(id)) text_ids.push_back(id);
+    for (int32_t id : ids) {
+        if (!cm->tok.is_control(id)) {
+            text_ids.push_back(id);
+        }
+    }
     std::string text = cm->tok.decode(text_ids.data(), static_cast<int>(text_ids.size()));
-    size_t b = 0, e = text.size();
-    while (b < e && std::isspace(static_cast<unsigned char>(text[b]))) ++b;
-    while (e > b && std::isspace(static_cast<unsigned char>(text[e - 1]))) --e;
+    size_t      b = 0, e = text.size();
+    while (b < e && std::isspace(static_cast<unsigned char>(text[b]))) {
+        ++b;
+    }
+    while (e > b && std::isspace(static_cast<unsigned char>(text[e - 1]))) {
+        --e;
+    }
     return text.substr(b, e - b);
 }
 
 // Allocate + compute a graph on the session scheduler. Inputs are set by
 // `set_inputs` AFTER allocation (the alloc assigns tensor data pointers).
-bool stream_run_graph(Session * cc, Model * cm, ggml_cgraph * gf,
+bool stream_run_graph(Session *                     cc,
+                      Model *                       cm,
+                      ggml_cgraph *                 gf,
                       const std::function<void()> & set_inputs,
-                      int64_t * out_compute_us = nullptr) {
+                      int64_t *                     out_compute_us = nullptr) {
     if (cc->sched == nullptr) {
         cc->sched = ggml_backend_sched_new(cm->plan.scheduler_list.data(), nullptr,
-            static_cast<int>(cm->plan.scheduler_list.size()), 16384, false, true);
-        if (cc->sched == nullptr) return false;
+                                           static_cast<int>(cm->plan.scheduler_list.size()), 16384, false, true);
+        if (cc->sched == nullptr) {
+            return false;
+        }
     }
     ggml_backend_sched_reset(cc->sched);
-    if (!ggml_backend_sched_alloc_graph(cc->sched, gf)) {               // graph alloc = overhead
+    if (!ggml_backend_sched_alloc_graph(cc->sched, gf)) {  // graph alloc = overhead
         transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "voxtral_realtime: stream graph allocation failed — "
-            "out of memory.");
+                            "voxtral_realtime: stream graph allocation failed — "
+                            "out of memory.");
         return false;
     }
     set_inputs();
     apply_threads(cc->sched, cc->n_threads);
     const int64_t tc0 = ggml_time_us();
-    const bool ok = ggml_backend_sched_graph_compute(cc->sched, gf) == GGML_STATUS_SUCCESS;
-    if (out_compute_us) *out_compute_us = ggml_time_us() - tc0;        // pure graph_compute
+    const bool    ok  = ggml_backend_sched_graph_compute(cc->sched, gf) == GGML_STATUS_SUCCESS;
+    if (out_compute_us) {
+        *out_compute_us = ggml_time_us() - tc0;  // pure graph_compute
+    }
     return ok;
 }
 
@@ -1138,6 +1334,7 @@ bool stream_run_graph(Session * cc, Model * cm, ggml_cgraph * gf,
 // sliding_window and a multiple of proj_downsample).
 constexpr int k_enc_ring_ctx  = 1536;
 constexpr int k_enc_max_batch = 512;
+
 // (decoder sliding-window ring size is read from the GGUF: hp.dec_sliding_window)
 
 // Compact the encoder KV ring: move the last `keep` frames (slots
@@ -1147,12 +1344,12 @@ constexpr int k_enc_max_batch = 512;
 // positions, so moving the bytes preserves correctness; the caller updates
 // stream_enc_abs_base so the windowed mask stays consistent.
 void compact_enc_ring(Session * cc, Model * cm, int keep, int from_slot) {
-    const int    C        = cc->enc_kv.n_ctx;
-    const size_t kv_dim   = static_cast<size_t>(cm->hparams.enc_n_heads) * cm->hparams.enc_head_dim;
-    const int    n_layers = cm->hparams.enc_n_layers;
-    const size_t elem     = ggml_element_size(cc->enc_kv.self_k);
+    const int          C        = cc->enc_kv.n_ctx;
+    const size_t       kv_dim   = static_cast<size_t>(cm->hparams.enc_n_heads) * cm->hparams.enc_head_dim;
+    const int          n_layers = cm->hparams.enc_n_layers;
+    const size_t       elem     = ggml_element_size(cc->enc_kv.self_k);
     std::vector<float> buf(static_cast<size_t>(keep) * kv_dim);
-    ggml_tensor * tens[2] = { cc->enc_kv.self_k, cc->enc_kv.self_v };
+    ggml_tensor *      tens[2] = { cc->enc_kv.self_k, cc->enc_kv.self_v };
     for (int L = 0; L < n_layers; ++L) {
         for (ggml_tensor * t : tens) {
             const size_t src = (static_cast<size_t>(L) * C + (from_slot - keep)) * kv_dim;
@@ -1170,23 +1367,29 @@ void compact_enc_ring(Session * cc, Model * cm, int keep, int from_slot) {
 // is_final the full offline-padded buffer is processed, so the emitted ids equal
 // the offline path (and the `stream` oracle). Sets *out_changed on advance.
 transcribe_status stream_process(Session * cc, Model * cm, bool is_final, bool * out_changed) {
-    if (out_changed) *out_changed = false;
-    const HParams & hp = cm->hparams;
-    const bool dumps_on = transcribe::debug::enabled();
-    const int n_mels      = hp.enc_num_mel_bins;
-    const int hop         = hp.fe_hop_length;
-    const int win         = hp.fe_win_length;
-    const int down        = hp.proj_downsample;
-    const int alpt        = hp.audio_length_per_tok;
-    const int dec_h       = hp.dec_hidden;
-    const int raw_per_tok = alpt * hop;                       // 1280
-    const int n_left_tok  = cm->specials.n_left_pad;          // 32
-    const int num_delay   = cc->stream_num_delay;
-    const int T_prompt    = 1 + n_left_tok + num_delay;       // BOS + pads
-    const std::string prev_text = cc->full_text;
-
-    if (!cm->mel.has_value()) return TRANSCRIBE_ERR_INVALID_ARG;
-    if (cc->stream_pcm.empty() && !is_final) return TRANSCRIBE_OK;
+    if (out_changed) {
+        *out_changed = false;
+    }
+    const HParams &   hp          = cm->hparams;
+    const bool        dumps_on    = transcribe::debug::enabled();
+    const int         n_mels      = hp.enc_num_mel_bins;
+    const int         hop         = hp.fe_hop_length;
+    const int         win         = hp.fe_win_length;
+    const int         down        = hp.proj_downsample;
+    const int         alpt        = hp.audio_length_per_tok;
+    const int         dec_h       = hp.dec_hidden;
+    const int         raw_per_tok = alpt * hop;                  // 1280
+    const int         n_left_tok  = cm->specials.n_left_pad;     // 32
+    const int         num_delay   = cc->stream_num_delay;
+    const int         T_prompt    = 1 + n_left_tok + num_delay;  // BOS + pads
+    const std::string prev_text   = cc->full_text;
+
+    if (!cm->mel.has_value()) {
+        return TRANSCRIBE_ERR_INVALID_ARG;
+    }
+    if (cc->stream_pcm.empty() && !is_final) {
+        return TRANSCRIBE_OK;
+    }
 
     // ---- 1. Build ONLY the window of the (left-padded) buffer the streaming mel
     //         needs: absolute samples [ws_sample, total_abs). ws_sample backs off
@@ -1200,23 +1403,24 @@ transcribe_status stream_process(Session * cc, Model * cm, bool is_final, bool *
     const int     mel_off     = std::max(0, cc->stream_n_mel_committed - GUARD);
     const size_t  ws_sample   = static_cast<size_t>(mel_off) * hop;
     const size_t  drop        = static_cast<size_t>(cc->stream_pcm_drop);
-    const size_t  n_aud_total = drop + cc->stream_pcm.size();   // total real audio samples
-    size_t total_abs;
+    const size_t  n_aud_total = drop + cc->stream_pcm.size();  // total real audio samples
+    size_t        total_abs;
     if (is_final) {
         const size_t raw_pad = ((n_aud_total + raw_per_tok - 1) / raw_per_tok) * raw_per_tok;
         const size_t right   = static_cast<size_t>(num_delay + 1 + 10) * raw_per_tok;
-        total_abs = left + raw_pad + right;
+        total_abs            = left + raw_pad + right;
     } else {
         total_abs = left + n_aud_total;
     }
-    if (total_abs <= ws_sample) return TRANSCRIBE_OK;
-    const size_t win_len = total_abs - ws_sample;
-    std::vector<float> buffer(win_len, 0.0f);          // buffer[j] == absolute sample ws_sample+j
-    const size_t a_lo = std::max(ws_sample, left);     // real-audio overlap of the window
-    const size_t a_hi = std::min(total_abs, left + n_aud_total);
+    if (total_abs <= ws_sample) {
+        return TRANSCRIBE_OK;
+    }
+    const size_t       win_len = total_abs - ws_sample;
+    std::vector<float> buffer(win_len, 0.0f);             // buffer[j] == absolute sample ws_sample+j
+    const size_t       a_lo = std::max(ws_sample, left);  // real-audio overlap of the window
+    const size_t       a_hi = std::min(total_abs, left + n_aud_total);
     if (a_hi > a_lo) {
-        std::memcpy(buffer.data() + (a_lo - ws_sample),
-                    cc->stream_pcm.data() + (a_lo - left - drop),
+        std::memcpy(buffer.data() + (a_lo - ws_sample), cc->stream_pcm.data() + (a_lo - left - drop),
                     (a_hi - a_lo) * sizeof(float));
     }
     // Drop PCM the window has moved past — every future feed's ws_sample >= this
@@ -1224,18 +1428,21 @@ transcribe_status stream_process(Session * cc, Model * cm, bool is_final, bool *
     // erase shifts only the small retained window, so memory stays bounded.
     if (ws_sample > left + drop) {
         const size_t keep_from = ws_sample - left - drop;
-        cc->stream_pcm.erase(cc->stream_pcm.begin(),
-                             cc->stream_pcm.begin() + static_cast<std::ptrdiff_t>(keep_from));
+        cc->stream_pcm.erase(cc->stream_pcm.begin(), cc->stream_pcm.begin() + static_cast<std::ptrdiff_t>(keep_from));
         cc->stream_pcm_drop += static_cast<int64_t>(keep_from);
     }
 
     // ---- 2. Streaming mel over the window. ----
-    int mm = 0, mel_n = 0;
+    int           mm = 0, mel_n = 0;
     const int64_t t_mel0 = ggml_time_us();
     if (auto st = cm->mel->compute(buffer.data(), win_len, cc->mel_buf, mm, mel_n, cc->n_threads);
-        st != TRANSCRIBE_OK) return st;
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
     cc->stream_t_mel_us += ggml_time_us() - t_mel0;
-    if (mm != n_mels) return TRANSCRIBE_ERR_GGUF;
+    if (mm != n_mels) {
+        return TRANSCRIBE_ERR_GGUF;
+    }
 
     int n_mel_ready;  // ABSOLUTE stable-frame count (window covers [mel_off, mel_off+mel_n))
     if (is_final) {
@@ -1244,12 +1451,16 @@ transcribe_status stream_process(Session * cc, Model * cm, bool is_final, bool *
         // Conservative: a centered frame is stable once its full window is
         // within real samples (so it equals the final buffer's same-index frame).
         const long fr = (static_cast<long>(total_abs) - win) / hop;
-        n_mel_ready = static_cast<int>(std::max(0L, fr + 1));
-        n_mel_ready = std::min(n_mel_ready, mel_off + mel_n);
+        n_mel_ready   = static_cast<int>(std::max(0L, fr + 1));
+        n_mel_ready   = std::min(n_mel_ready, mel_off + mel_n);
+    }
+    if (n_mel_ready <= 4) {
+        return TRANSCRIBE_OK;
     }
-    if (n_mel_ready <= 4) return TRANSCRIBE_OK;
     const int T_emb_ready = (n_mel_ready - 2) / 2 + 1;
-    if (is_final) cc->stream_n_audio_clamp = T_emb_ready / down;
+    if (is_final) {
+        cc->stream_n_audio_clamp = T_emb_ready / down;
+    }
 
     // ---- 3. Conv stem with the streaming PADDING CACHE: feed only the NEW mel
     //         frames (token-aligned, a multiple of 2*down=8) against the carried
@@ -1258,38 +1469,51 @@ transcribe_status stream_process(Session * cc, Model * cm, bool is_final, bool *
     const int ed = hp.enc_d_model;
     const int M  = ((n_mel_ready - cc->stream_n_mel_committed) / (2 * down)) * (2 * down);
     if (M > 0) {
-        if (cc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
-        const int emb_base_abs = cc->stream_n_enc_committed;  // abs index of emb_host[0]
-        const int M_emb        = M / 2;                       // new embedder frames (down-aligned)
-        const int m0           = cc->stream_n_mel_committed;  // first new mel frame (absolute)
-        const int mrel         = m0 - mel_off;                // ... as a window-relative index
+        if (cc->poll_abort()) {
+            return TRANSCRIBE_ERR_ABORTED;
+        }
+        const int          emb_base_abs = cc->stream_n_enc_committed;  // abs index of emb_host[0]
+        const int          M_emb        = M / 2;                       // new embedder frames (down-aligned)
+        const int          m0           = cc->stream_n_mel_committed;  // first new mel frame (absolute)
+        const int          mrel         = m0 - mel_off;                // ... as a window-relative index
         std::vector<float> emb_host(static_cast<size_t>(ed) * M_emb);
-        const int64_t t_conv0 = ggml_time_us();
+        const int64_t      t_conv0 = ggml_time_us();
         {
-            if (cc->compute_ctx != nullptr) { ggml_free(cc->compute_ctx); cc->compute_ctx = nullptr; }
-            ggml_init_params ip {}; ip.mem_size = 64 * 1024 * 1024; ip.no_alloc = true;
+            if (cc->compute_ctx != nullptr) {
+                ggml_free(cc->compute_ctx);
+                cc->compute_ctx = nullptr;
+            }
+            ggml_init_params ip{};
+            ip.mem_size     = 64 * 1024 * 1024;
+            ip.no_alloc     = true;
             cc->compute_ctx = ggml_init(ip);
             if (cc->compute_ctx == nullptr) {
-            transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "voxtral_realtime: compute context allocation failed — "
-                "out of memory.");
-            return TRANSCRIBE_ERR_OOM;
-        }
+                transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
+                                    "voxtral_realtime: compute context allocation failed — "
+                                    "out of memory.");
+                return TRANSCRIBE_ERR_OOM;
+            }
             EmbedderChunkBuild emb = build_embedder_chunk_graph(cc->compute_ctx, cm->weights, hp, M);
-            if (emb.graph == nullptr || emb.out == nullptr) return TRANSCRIBE_ERR_GGUF;
+            if (emb.graph == nullptr || emb.out == nullptr) {
+                return TRANSCRIBE_ERR_GGUF;
+            }
             // new mel frames [m0, m0+M), mel-major buffer -> frame-major [n_mels, M].
             std::vector<float> mel_fm(static_cast<size_t>(n_mels) * M);
-            for (int t = 0; t < M; ++t)
-                for (int k = 0; k < n_mels; ++k)
+            for (int t = 0; t < M; ++t) {
+                for (int k = 0; k < n_mels; ++k) {
                     mel_fm[static_cast<size_t>(t) * n_mels + k] =
                         cc->mel_buf[static_cast<size_t>(k) * mel_n + (mrel + t)];
-            if (!stream_run_graph(cc, cm, emb.graph, [&]{
+                }
+            }
+            if (!stream_run_graph(cc, cm, emb.graph, [&] {
                     ggml_backend_tensor_set(emb.mel_in, mel_fm.data(), 0, mel_fm.size() * sizeof(float));
                     ggml_backend_tensor_set(emb.cache1_in, cc->stream_conv0_cache.data(), 0,
                                             cc->stream_conv0_cache.size() * sizeof(float));
                     ggml_backend_tensor_set(emb.cache2_in, cc->stream_conv1_cache.data(), 0,
                                             cc->stream_conv1_cache.size() * sizeof(float));
-                })) return TRANSCRIBE_ERR_GGUF;
+                })) {
+                return TRANSCRIBE_ERR_GGUF;
+            }
             ggml_backend_tensor_get(emb.out, emb_host.data(), 0, emb_host.size() * sizeof(float));
             // Carry conv caches for the next chunk: conv0 ← last 2 NEW mel frames
             // (frame-major [n_mels,2]); conv1 ← the chunk's last conv0-output frame.
@@ -1306,13 +1530,15 @@ transcribe_status stream_process(Session * cc, Model * cm, bool is_final, bool *
         cc->stream_t_conv_us += ggml_time_us() - t_conv0;
 
         // ---- 4. Encoder ring: push the M_emb new frames in <=k_enc_max_batch batches.
-        int remaining = M_emb;
-        const int C = cc->enc_kv.n_ctx;
-        const int W = hp.enc_sliding_window;
+        int               remaining = M_emb;
+        const int         C         = cc->enc_kv.n_ctx;
+        const int         W         = hp.enc_sliding_window;
         const ggml_fp16_t mz = ggml_fp32_to_fp16(0.0f), mn = ggml_fp32_to_fp16(-INFINITY);
-        const int64_t t_enc0 = ggml_time_us();
+        const int64_t     t_enc0 = ggml_time_us();
         while (remaining > 0) {
-            if (cc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
+            if (cc->poll_abort()) {
+                return TRANSCRIBE_ERR_ABORTED;
+            }
             const int batch = std::min(remaining, k_enc_max_batch);
             // Compact the ring so this batch fits (keeps the last W frames).
             if (cc->stream_enc_slot + batch > C) {
@@ -1322,31 +1548,41 @@ transcribe_status stream_process(Session * cc, Model * cm, bool is_final, bool *
                 cc->stream_enc_slot = keep;
             }
             const int write_slot = cc->stream_enc_slot;
-            const int abs0       = cc->stream_n_enc_committed;     // abs of first query
+            const int abs0       = cc->stream_n_enc_committed;  // abs of first query
             const int read_start = std::max(0, write_slot - (W - 1));
             const int read_len   = (write_slot + batch) - read_start;
 
-            if (cc->compute_ctx != nullptr) { ggml_free(cc->compute_ctx); cc->compute_ctx = nullptr; }
-            ggml_init_params ip {}; ip.mem_size = 256 * 1024 * 1024; ip.no_alloc = true;
+            if (cc->compute_ctx != nullptr) {
+                ggml_free(cc->compute_ctx);
+                cc->compute_ctx = nullptr;
+            }
+            ggml_init_params ip{};
+            ip.mem_size     = 256 * 1024 * 1024;
+            ip.no_alloc     = true;
             cc->compute_ctx = ggml_init(ip);
             if (cc->compute_ctx == nullptr) {
-            transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "voxtral_realtime: compute context allocation failed — "
-                "out of memory.");
-            return TRANSCRIBE_ERR_OOM;
-        }
-            EncoderChunkBuild eb = build_encoder_chunk_graph(cc->compute_ctx, cm->weights, hp,
-                cc->enc_kv, batch, write_slot, read_start, read_len, cc->encoder_use_flash);
-            if (eb.graph == nullptr || eb.out == nullptr) return TRANSCRIBE_ERR_GGUF;
+                transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
+                                    "voxtral_realtime: compute context allocation failed — "
+                                    "out of memory.");
+                return TRANSCRIBE_ERR_OOM;
+            }
+            EncoderChunkBuild eb = build_encoder_chunk_graph(cc->compute_ctx, cm->weights, hp, cc->enc_kv, batch,
+                                                             write_slot, read_start, read_len, cc->encoder_use_flash);
+            if (eb.graph == nullptr || eb.out == nullptr) {
+                return TRANSCRIBE_ERR_GGUF;
+            }
 
-            const int rel0 = abs0 - emb_base_abs;                  // offset into emb_host
+            const int          rel0 = abs0 - emb_base_abs;  // offset into emb_host
             std::vector<float> chunk_in(static_cast<size_t>(ed) * batch);
-            for (int i = 0; i < batch; ++i)
-                for (int d = 0; d < ed; ++d)
-                    chunk_in[static_cast<size_t>(i) * ed + d] =
-                        emb_host[static_cast<size_t>(rel0 + i) * ed + d];
+            for (int i = 0; i < batch; ++i) {
+                for (int d = 0; d < ed; ++d) {
+                    chunk_in[static_cast<size_t>(i) * ed + d] = emb_host[static_cast<size_t>(rel0 + i) * ed + d];
+                }
+            }
             std::vector<int32_t> pos(batch);
-            for (int i = 0; i < batch; ++i) pos[i] = abs0 + i;
+            for (int i = 0; i < batch; ++i) {
+                pos[i] = abs0 + i;
+            }
             // Sliding-window-causal mask [read_len(key), batch(query)], ABSOLUTE.
             // key read-index k -> abs = stream_enc_abs_base + read_start + k.
             std::vector<ggml_fp16_t> mask(static_cast<size_t>(read_len) * batch, mn);
@@ -1354,26 +1590,32 @@ transcribe_status stream_process(Session * cc, Model * cm, bool is_final, bool *
                 const int qabs = abs0 + qi;
                 for (int k = 0; k < read_len; ++k) {
                     const int kabs = cc->stream_enc_abs_base + read_start + k;
-                    if (kabs <= qabs && (qabs - kabs) < W)
+                    if (kabs <= qabs && (qabs - kabs) < W) {
                         mask[static_cast<size_t>(qi) * read_len + k] = mz;
+                    }
                 }
             }
             int64_t enc_compute_us = 0;
-            if (!stream_run_graph(cc, cm, eb.graph, [&]{
-                    ggml_backend_tensor_set(eb.embed_in, chunk_in.data(), 0, chunk_in.size() * sizeof(float));
-                    ggml_backend_tensor_set(eb.positions_in, pos.data(), 0, pos.size() * sizeof(int32_t));
-                    ggml_backend_tensor_set(eb.mask_in, mask.data(), 0, mask.size() * sizeof(ggml_fp16_t));
-                }, &enc_compute_us)) return TRANSCRIBE_ERR_GGUF;
+            if (!stream_run_graph(
+                    cc, cm, eb.graph,
+                    [&] {
+                        ggml_backend_tensor_set(eb.embed_in, chunk_in.data(), 0, chunk_in.size() * sizeof(float));
+                        ggml_backend_tensor_set(eb.positions_in, pos.data(), 0, pos.size() * sizeof(int32_t));
+                        ggml_backend_tensor_set(eb.mask_in, mask.data(), 0, mask.size() * sizeof(ggml_fp16_t));
+                    },
+                    &enc_compute_us)) {
+                return TRANSCRIBE_ERR_GGUF;
+            }
             cc->stream_t_enc_compute_us += enc_compute_us;
 
-            const int n_audio_new = eb.n_audio_new;
-            const size_t base = static_cast<size_t>(cc->stream_n_tok_ready - cc->stream_audio_base) * dec_h;
+            const int    n_audio_new = eb.n_audio_new;
+            const size_t base        = static_cast<size_t>(cc->stream_n_tok_ready - cc->stream_audio_base) * dec_h;
             cc->stream_audio_embeds.resize(base + static_cast<size_t>(n_audio_new) * dec_h);
             ggml_backend_tensor_get(eb.out, cc->stream_audio_embeds.data() + base, 0,
                                     static_cast<size_t>(n_audio_new) * dec_h * sizeof(float));
-            cc->stream_enc_slot        += batch;
+            cc->stream_enc_slot += batch;
             cc->stream_n_enc_committed += batch;
-            cc->stream_n_tok_ready     += n_audio_new;
+            cc->stream_n_tok_ready += n_audio_new;
             remaining -= batch;
         }
         cc->stream_t_enc_us += ggml_time_us() - t_enc0;
@@ -1381,124 +1623,170 @@ transcribe_status stream_process(Session * cc, Model * cm, bool is_final, bool *
 
     // ---- 5. Decoder: prompt prefill once, then one step per ready token. ----
     const int64_t t_dec0 = ggml_time_us();
-    const int vocab = hp.dec_vocab_size;
+    const int     vocab  = hp.dec_vocab_size;
     const int32_t eos_id = hp.eos_token_id;
-    auto argmax = [](const std::vector<float> & v) -> int32_t {
-        int32_t best = 0; float bv = v[0];
-        for (int32_t i = 1; i < static_cast<int32_t>(v.size()); ++i) if (v[i] > bv) { bv = v[i]; best = i; }
+    auto          argmax = [](const std::vector<float> & v) -> int32_t {
+        int32_t best = 0;
+        float   bv   = v[0];
+        for (int32_t i = 1; i < static_cast<int32_t>(v.size()); ++i) {
+            if (v[i] > bv) {
+                bv   = v[i];
+                best = i;
+            }
+        }
         return best;
     };
 
     if (!cc->stream_prompt_done && cc->stream_n_tok_ready >= T_prompt) {
-        if (cc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
-        if (cc->kv_cache.buffer != nullptr) ggml_backend_buffer_clear(cc->kv_cache.buffer, 0);
-        cc->kv_cache.n = 0; cc->kv_cache.head = 0;
+        if (cc->poll_abort()) {
+            return TRANSCRIBE_ERR_ABORTED;
+        }
+        if (cc->kv_cache.buffer != nullptr) {
+            ggml_backend_buffer_clear(cc->kv_cache.buffer, 0);
+        }
+        cc->kv_cache.n    = 0;
+        cc->kv_cache.head = 0;
 
         std::vector<int32_t> prompt_ids;
         prompt_ids.push_back(cm->specials.bos);
-        for (int i = 0; i < T_prompt - 1; ++i) prompt_ids.push_back(cm->specials.streaming_pad);
+        for (int i = 0; i < T_prompt - 1; ++i) {
+            prompt_ids.push_back(cm->specials.streaming_pad);
+        }
 
-        if (cc->compute_ctx != nullptr) { ggml_free(cc->compute_ctx); cc->compute_ctx = nullptr; }
-        ggml_init_params ip {}; ip.mem_size = 64 * 1024 * 1024; ip.no_alloc = true;
+        if (cc->compute_ctx != nullptr) {
+            ggml_free(cc->compute_ctx);
+            cc->compute_ctx = nullptr;
+        }
+        ggml_init_params ip{};
+        ip.mem_size     = 64 * 1024 * 1024;
+        ip.no_alloc     = true;
         cc->compute_ctx = ggml_init(ip);
         if (cc->compute_ctx == nullptr) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "voxtral_realtime: compute context allocation failed — "
-                "out of memory.");
+                                "voxtral_realtime: compute context allocation failed — "
+                                "out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
-        PrefillBuild pb = build_prefill_graph(cc->compute_ctx, cm->weights, hp, cc->kv_cache,
-            cc->ada_scale_all, T_prompt, cc->decoder_use_flash, /*want_all_logits=*/false);
-        if (pb.graph == nullptr || pb.out == nullptr) return TRANSCRIBE_ERR_GGUF;
+        PrefillBuild pb = build_prefill_graph(cc->compute_ctx, cm->weights, hp, cc->kv_cache, cc->ada_scale_all,
+                                              T_prompt, cc->decoder_use_flash, /*want_all_logits=*/false);
+        if (pb.graph == nullptr || pb.out == nullptr) {
+            return TRANSCRIBE_ERR_GGUF;
+        }
         std::vector<int32_t> positions(T_prompt);
-        for (int i = 0; i < T_prompt; ++i) positions[i] = i;
-        std::vector<ggml_fp16_t> mask(static_cast<size_t>(T_prompt) * T_prompt,
-                                      ggml_fp32_to_fp16(-INFINITY));
-        const ggml_fp16_t mz = ggml_fp32_to_fp16(0.0f);
-        for (int r = 0; r < T_prompt; ++r) for (int c = 0; c <= r; ++c)
-            mask[static_cast<size_t>(r) * T_prompt + c] = mz;
-        if (!stream_run_graph(cc, cm, pb.graph, [&]{
+        for (int i = 0; i < T_prompt; ++i) {
+            positions[i] = i;
+        }
+        std::vector<ggml_fp16_t> mask(static_cast<size_t>(T_prompt) * T_prompt, ggml_fp32_to_fp16(-INFINITY));
+        const ggml_fp16_t        mz = ggml_fp32_to_fp16(0.0f);
+        for (int r = 0; r < T_prompt; ++r) {
+            for (int c = 0; c <= r; ++c) {
+                mask[static_cast<size_t>(r) * T_prompt + c] = mz;
+            }
+        }
+        if (!stream_run_graph(cc, cm, pb.graph, [&] {
                 ggml_backend_tensor_set(pb.input_ids_in, prompt_ids.data(), 0, prompt_ids.size() * sizeof(int32_t));
                 ggml_backend_tensor_set(pb.audio_in, cc->stream_audio_embeds.data(), 0,
                                         static_cast<size_t>(dec_h) * T_prompt * sizeof(float));
                 ggml_backend_tensor_set(pb.positions_in, positions.data(), 0, positions.size() * sizeof(int32_t));
                 ggml_backend_tensor_set(pb.mask_in, mask.data(), 0, mask.size() * sizeof(ggml_fp16_t));
-            })) return TRANSCRIBE_ERR_GGUF;
-        cc->kv_cache.n = T_prompt; cc->kv_cache.head = T_prompt;
+            })) {
+            return TRANSCRIBE_ERR_GGUF;
+        }
+        cc->kv_cache.n    = T_prompt;
+        cc->kv_cache.head = T_prompt;
         std::vector<float> logits(vocab);
         ggml_backend_tensor_get(pb.out, logits.data(), 0, logits.size() * sizeof(float));
-        if (dumps_on) cc->stream_gen0_logits = logits;   // stream.logits_raw
+        if (dumps_on) {
+            cc->stream_gen0_logits = logits;  // stream.logits_raw
+        }
         const int32_t g0 = argmax(logits);
         cc->stream_generated.push_back(g0);
-        cc->stream_next_tok = g0;
-        cc->stream_dec_pos  = T_prompt;
+        cc->stream_next_tok    = g0;
+        cc->stream_dec_pos     = T_prompt;
         cc->stream_prompt_done = true;
     }
 
     if (cc->stream_prompt_done && !cc->stream_eos && cc->stream_dec_pos < cc->stream_n_tok_ready) {
         const int max_n_kv = cc->kv_cache.n_ctx;
-        if (cc->compute_ctx != nullptr) { ggml_free(cc->compute_ctx); cc->compute_ctx = nullptr; }
-        ggml_init_params ip {}; ip.mem_size = 64 * 1024 * 1024; ip.no_alloc = true;
+        if (cc->compute_ctx != nullptr) {
+            ggml_free(cc->compute_ctx);
+            cc->compute_ctx = nullptr;
+        }
+        ggml_init_params ip{};
+        ip.mem_size     = 64 * 1024 * 1024;
+        ip.no_alloc     = true;
         cc->compute_ctx = ggml_init(ip);
         if (cc->compute_ctx == nullptr) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "voxtral_realtime: compute context allocation failed — "
-                "out of memory.");
+                                "voxtral_realtime: compute context allocation failed — "
+                                "out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
-        StepBuild sb = build_step_graph(cc->compute_ctx, cm->weights, hp, cc->kv_cache,
-            cc->ada_scale_all, max_n_kv, cc->decoder_use_flash);
-        if (sb.graph == nullptr || sb.out == nullptr) return TRANSCRIBE_ERR_GGUF;
+        StepBuild sb = build_step_graph(cc->compute_ctx, cm->weights, hp, cc->kv_cache, cc->ada_scale_all, max_n_kv,
+                                        cc->decoder_use_flash);
+        if (sb.graph == nullptr || sb.out == nullptr) {
+            return TRANSCRIBE_ERR_GGUF;
+        }
         if (cc->sched == nullptr) {
             cc->sched = ggml_backend_sched_new(cm->plan.scheduler_list.data(), nullptr,
-                static_cast<int>(cm->plan.scheduler_list.size()), 16384, false, true);
-            if (cc->sched == nullptr) return TRANSCRIBE_ERR_GGUF;
+                                               static_cast<int>(cm->plan.scheduler_list.size()), 16384, false, true);
+            if (cc->sched == nullptr) {
+                return TRANSCRIBE_ERR_GGUF;
+            }
         }
         ggml_backend_sched_reset(cc->sched);
         if (!ggml_backend_sched_alloc_graph(cc->sched, sb.graph)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "voxtral_realtime: stream step graph allocation failed — "
-                "out of memory.");
+                                "voxtral_realtime: stream step graph allocation failed — "
+                                "out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
         apply_threads(cc->sched, cc->n_threads);
 
-        const int swin    = hp.dec_sliding_window;   // 8192
-        const int kv_ring = max_n_kv;                 // ring size == n_ctx (== swin here)
+        const int                swin    = hp.dec_sliding_window;  // 8192
+        const int                kv_ring = max_n_kv;               // ring size == n_ctx (== swin here)
         // Hard absolute-position cap = dec_max_position; a streaming caller hits
         // memory/latency long before it (~2.9 h).
-        const int max_pos = voxtral_realtime_abs_position_cap(hp);
-        const ggml_fp16_t mz = ggml_fp32_to_fp16(0.0f), mn = ggml_fp32_to_fp16(-INFINITY);
+        const int                max_pos = voxtral_realtime_abs_position_cap(hp);
+        const ggml_fp16_t        mz = ggml_fp32_to_fp16(0.0f), mn = ggml_fp32_to_fp16(-INFINITY);
         std::vector<ggml_fp16_t> step_mask(max_n_kv, mn);
-        int cap = (is_final && cc->stream_n_audio_clamp >= 0)
-                ? std::min(cc->stream_n_tok_ready, cc->stream_n_audio_clamp)
-                : cc->stream_n_tok_ready;
+        int                      cap         = (is_final && cc->stream_n_audio_clamp >= 0) ?
+                                                   std::min(cc->stream_n_tok_ready, cc->stream_n_audio_clamp) :
+                                                   cc->stream_n_tok_ready;
         // `hit_pos_cap`: this chunk's decode was limited by the hard position cap
         // (not by stream_n_tok_ready / the finalize clamp), so the truncation WARN
         // below fires only at the genuine hard cap.
-        const bool hit_pos_cap = (max_pos < cap);
-        cap = std::min(cap, max_pos);
+        const bool               hit_pos_cap = (max_pos < cap);
+        cap                                  = std::min(cap, max_pos);
         while (!cc->stream_eos && cc->stream_dec_pos < cap) {
-            if (cc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
+            if (cc->poll_abort()) {
+                return TRANSCRIBE_ERR_ABORTED;
+            }
             const int cur = cc->stream_dec_pos;
             ggml_backend_tensor_set(sb.input_id_in, &cc->stream_next_tok, 0, sizeof(int32_t));
-            ggml_backend_tensor_set(sb.audio_in,
-                cc->stream_audio_embeds.data() + static_cast<size_t>(cur - cc->stream_audio_base) * dec_h, 0,
-                static_cast<size_t>(dec_h) * sizeof(float));
-            const int32_t pos_val = cur; ggml_backend_tensor_set(sb.position_in, &pos_val, 0, sizeof(int32_t));
+            ggml_backend_tensor_set(
+                sb.audio_in, cc->stream_audio_embeds.data() + static_cast<size_t>(cur - cc->stream_audio_base) * dec_h,
+                0, static_cast<size_t>(dec_h) * sizeof(float));
+            const int32_t pos_val = cur;
+            ggml_backend_tensor_set(sb.position_in, &pos_val, 0, sizeof(int32_t));
             // Sliding-window ring write: token `cur` lands at slot `cur % kv_ring`,
             // overwriting token `cur - kv_ring` (exactly one past the window, so it
             // is already evicted). RoPE position stays ABSOLUTE (`cur`).
-            const int64_t kv_idx = cur % kv_ring; ggml_backend_tensor_set(sb.kv_idx_in, &kv_idx, 0, sizeof(int64_t));
+            const int64_t kv_idx = cur % kv_ring;
+            ggml_backend_tensor_set(sb.kv_idx_in, &kv_idx, 0, sizeof(int64_t));
             // Reveal keys [max(0,cur-swin+1) .. cur] at their ring slots (t % kv_ring).
             // For cur < kv_ring this is the identity slot map (== the pre-ring path);
             // once full, the `swin` in-window tokens occupy all `kv_ring` slots 1:1.
             std::fill(step_mask.begin(), step_mask.end(), mn);
-            for (int t = std::max(0, cur - swin + 1); t <= cur; ++t) step_mask[t % kv_ring] = mz;
-            ggml_backend_tensor_set(sb.mask_in, step_mask.data(), 0, static_cast<size_t>(max_n_kv) * sizeof(ggml_fp16_t));
-            if (ggml_backend_sched_graph_compute(cc->sched, sb.graph) != GGML_STATUS_SUCCESS)
+            for (int t = std::max(0, cur - swin + 1); t <= cur; ++t) {
+                step_mask[t % kv_ring] = mz;
+            }
+            ggml_backend_tensor_set(sb.mask_in, step_mask.data(), 0,
+                                    static_cast<size_t>(max_n_kv) * sizeof(ggml_fp16_t));
+            if (ggml_backend_sched_graph_compute(cc->sched, sb.graph) != GGML_STATUS_SUCCESS) {
                 return TRANSCRIBE_ERR_GGUF;
-            if (dumps_on && cur == T_prompt - 1 + 8) {       // stream.logits_raw.gen8
+            }
+            if (dumps_on && cur == T_prompt - 1 + 8) {  // stream.logits_raw.gen8
                 cc->stream_gen8_logits.assign(vocab, 0.0f);
                 ggml_backend_tensor_get(sb.logits, cc->stream_gen8_logits.data(), 0,
                                         static_cast<size_t>(vocab) * sizeof(float));
@@ -1509,22 +1797,24 @@ transcribe_status stream_process(Session * cc, Model * cm, bool is_final, bool *
             cc->stream_dec_pos  = cur + 1;
             // Bookkeeping only (block_step reads n_ctx / max_n_kv, not n / head);
             // keep them ring-consistent rather than letting them run past n_ctx.
-            cc->kv_cache.n = std::min(cur + 2, kv_ring); cc->kv_cache.head = (cur + 1) % kv_ring;
-            if (tok == eos_id) { cc->stream_eos = true; break; }
+            cc->kv_cache.n      = std::min(cur + 2, kv_ring);
+            cc->kv_cache.head   = (cur + 1) % kv_ring;
+            if (tok == eos_id) {
+                cc->stream_eos = true;
+                break;
+            }
             cc->stream_generated.push_back(tok);
         }
 
         // Truncation at the hard context cap without an EOS: flag via
         // transcribe_was_truncated() + a single WARN (guarded by !was_truncated
         // so it fires at most once across the per-feed/finalize re-entries).
-        if (hit_pos_cap && !cc->stream_eos && cc->stream_dec_pos >= cap &&
-            !cc->was_truncated) {
+        if (hit_pos_cap && !cc->stream_eos && cc->stream_dec_pos >= cap && !cc->was_truncated) {
             cc->was_truncated = true;
-            transcribe::log_msg(
-                TRANSCRIBE_LOG_LEVEL_WARN,
-                "voxtral_realtime: output truncated at the %d-token context cap "
-                "before end-of-stream; transcript may be incomplete.",
-                max_pos);
+            transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_WARN,
+                                "voxtral_realtime: output truncated at the %d-token context cap "
+                                "before end-of-stream; transcript may be incomplete.",
+                                max_pos);
         }
     }
 
@@ -1546,17 +1836,16 @@ transcribe_status stream_process(Session * cc, Model * cm, bool is_final, bool *
         const double enc = cc->stream_t_enc_us / 1000.0, dec = cc->stream_t_dec_us / 1000.0;
         const double enc_c = cc->stream_t_enc_compute_us / 1000.0;  // pure graph_compute
         const double enc_o = enc - enc_c;                           // build + alloc + host prep
-        const double tot = mel + conv + enc + dec;
+        const double tot   = mel + conv + enc + dec;
         log_msg(TRANSCRIBE_LOG_LEVEL_DEBUG,
-            "[stream-timing] mel=%.0fms (%.1f%%)  conv=%.0fms (%.1f%%)  enc=%.0fms (%.1f%%)"
-            " [compute=%.0f overhead=%.0f]  dec=%.0fms (%.1f%%)  sum=%.0fms",
-            mel, tot > 0 ? 100.0 * mel / tot : 0.0, conv, tot > 0 ? 100.0 * conv / tot : 0.0,
-            enc, tot > 0 ? 100.0 * enc / tot : 0.0, enc_c, enc_o,
-            dec, tot > 0 ? 100.0 * dec / tot : 0.0, tot);
+                "[stream-timing] mel=%.0fms (%.1f%%)  conv=%.0fms (%.1f%%)  enc=%.0fms (%.1f%%)"
+                " [compute=%.0f overhead=%.0f]  dec=%.0fms (%.1f%%)  sum=%.0fms",
+                mel, tot > 0 ? 100.0 * mel / tot : 0.0, conv, tot > 0 ? 100.0 * conv / tot : 0.0, enc,
+                tot > 0 ? 100.0 * enc / tot : 0.0, enc_c, enc_o, dec, tot > 0 ? 100.0 * dec / tot : 0.0, tot);
         log_msg(TRANSCRIBE_LOG_LEVEL_DEBUG,
-            "[stream-mem] retained PCM=%zu samples (%.1fs)  audio-embeds=%zu frames  (vs %d total tokens)",
-            cc->stream_pcm.size(), static_cast<double>(cc->stream_pcm.size()) / std::max(1, hp.fe_sample_rate),
-            cc->stream_audio_embeds.size() / std::max<size_t>(1, dec_h), cc->stream_n_tok_ready);
+                "[stream-mem] retained PCM=%zu samples (%.1fs)  audio-embeds=%zu frames  (vs %d total tokens)",
+                cc->stream_pcm.size(), static_cast<double>(cc->stream_pcm.size()) / std::max(1, hp.fe_sample_rate),
+                cc->stream_audio_embeds.size() / std::max<size_t>(1, dec_h), cc->stream_n_tok_ready);
     }
 
     // ---- 6. Numerical-validation dumps (finalize only). ----
@@ -1565,23 +1854,27 @@ transcribe_status stream_process(Session * cc, Model * cm, bool is_final, bool *
         if (cc->stream_n_tok_ready > 0) {
             const long long shp[2] = { dec_h, cc->stream_n_tok_ready };
             transcribe::debug::dump_host_f32("proj.out", cc->stream_audio_embeds.data(),
-                static_cast<long long>(cc->stream_audio_embeds.size()), shp, 2, "proj");
+                                             static_cast<long long>(cc->stream_audio_embeds.size()), shp, 2, "proj");
         }
         const long long lshp[1] = { vocab };
-        if (!cc->stream_gen0_logits.empty())
-            transcribe::debug::dump_host_f32("stream.logits_raw", cc->stream_gen0_logits.data(),
-                                             vocab, lshp, 1, "stream");
-        if (!cc->stream_gen8_logits.empty())
-            transcribe::debug::dump_host_f32("stream.logits_raw.gen8", cc->stream_gen8_logits.data(),
-                                             vocab, lshp, 1, "stream");
+        if (!cc->stream_gen0_logits.empty()) {
+            transcribe::debug::dump_host_f32("stream.logits_raw", cc->stream_gen0_logits.data(), vocab, lshp, 1,
+                                             "stream");
+        }
+        if (!cc->stream_gen8_logits.empty()) {
+            transcribe::debug::dump_host_f32("stream.logits_raw.gen8", cc->stream_gen8_logits.data(), vocab, lshp, 1,
+                                             "stream");
+        }
     }
 
     // ---- 7. Publish transcript. ----
-    std::string text = detok_generated(cm, cc->stream_generated);
-    const int sr = std::max(1, hp.fe_sample_rate);
+    std::string   text     = detok_generated(cm, cc->stream_generated);
+    const int     sr       = std::max(1, hp.fe_sample_rate);
     const int64_t audio_ms = static_cast<int64_t>(n_aud_total) * 1000 / sr;
     publish_stream_text(cc, cm, text, audio_ms);
-    if (out_changed) *out_changed = (text != prev_text) || is_final;
+    if (out_changed) {
+        *out_changed = (text != prev_text) || is_final;
+    }
     return TRANSCRIBE_OK;
 }
 
@@ -1590,9 +1883,13 @@ transcribe_status stream_begin(transcribe_session * session,
                                const transcribe_stream_params * stream_params) {
     auto * cc = static_cast<Session *>(session);
     auto * cm = static_cast<Model *>(cc->model);
-    if (cm == nullptr || cm->plan.scheduler_list.empty()) return TRANSCRIBE_ERR_INVALID_ARG;
+    if (cm == nullptr || cm->plan.scheduler_list.empty()) {
+        return TRANSCRIBE_ERR_INVALID_ARG;
+    }
     int nd = 0, md = 0;
-    if (auto st = resolve_stream_ext(stream_params, cm, &nd, &md); st != TRANSCRIBE_OK) return st;
+    if (auto st = resolve_stream_ext(stream_params, cm, &nd, &md); st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     cc->stream_pcm.clear();
     cc->stream_num_delay           = nd;
@@ -1601,21 +1898,21 @@ transcribe_status stream_begin(transcribe_session * session,
 
     // Reset incremental encoder/decoder state.
     cc->stream_n_enc_committed = 0;
-    cc->stream_enc_slot     = 0;
-    cc->stream_enc_abs_base = 0;
+    cc->stream_enc_slot        = 0;
+    cc->stream_enc_abs_base    = 0;
     cc->stream_conv0_cache.assign(static_cast<size_t>(cm->hparams.enc_num_mel_bins) * 2, 0.0f);
     cc->stream_conv1_cache.assign(static_cast<size_t>(cm->hparams.enc_d_model), 0.0f);
     cc->stream_n_mel_committed = 0;
-    cc->stream_pcm_drop = 0;
-    cc->stream_audio_base = 0;
+    cc->stream_pcm_drop        = 0;
+    cc->stream_audio_base      = 0;
     cc->stream_t_mel_us = cc->stream_t_conv_us = cc->stream_t_enc_us = cc->stream_t_dec_us = 0;
-    cc->stream_t_enc_compute_us = 0;
+    cc->stream_t_enc_compute_us                                                            = 0;
     cc->stream_audio_embeds.clear();
-    cc->stream_n_tok_ready  = 0;
-    cc->stream_prompt_done  = false;
-    cc->stream_dec_pos      = 0;
-    cc->stream_next_tok     = 0;
-    cc->stream_eos          = false;
+    cc->stream_n_tok_ready = 0;
+    cc->stream_prompt_done = false;
+    cc->stream_dec_pos     = 0;
+    cc->stream_next_tok    = 0;
+    cc->stream_eos         = false;
     cc->stream_generated.clear();
     cc->stream_n_audio_clamp = -1;
 
@@ -1623,15 +1920,16 @@ transcribe_status stream_begin(transcribe_session * session,
     // k_enc_ring_ctx slots; compaction keeps the last sliding_window(750) frames
     // so any stream length runs in constant memory (the reference mechanism).
     cc->enc_kv.free();
-    if (!transcribe::causal_lm::kv_init(cc->enc_kv, cm->plan.primary, /*n_ctx=*/k_enc_ring_ctx,
-            cm->hparams.enc_n_heads, cm->hparams.enc_head_dim,
-            cm->hparams.enc_n_layers, GGML_TYPE_F32)) {
+    if (!transcribe::causal_lm::kv_init(cc->enc_kv, cm->plan.primary, /*n_ctx=*/k_enc_ring_ctx, cm->hparams.enc_n_heads,
+                                        cm->hparams.enc_head_dim, cm->hparams.enc_n_layers, GGML_TYPE_F32)) {
         transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "voxtral_realtime stream_begin: encoder KV cache allocation failed — "
-            "out of memory.");
+                            "voxtral_realtime stream_begin: encoder KV cache allocation failed — "
+                            "out of memory.");
         return TRANSCRIBE_ERR_OOM;
     }
-    if (cc->enc_kv.buffer != nullptr) ggml_backend_buffer_clear(cc->enc_kv.buffer, 0);
+    if (cc->enc_kv.buffer != nullptr) {
+        ggml_backend_buffer_clear(cc->enc_kv.buffer, 0);
+    }
 
     // Decoder KV: a sliding-window RING sized to the model's own `sliding_window`
     // (from the GGUF, 8192 here). The step loop writes token `cur` at slot
@@ -1643,44 +1941,56 @@ transcribe_status stream_begin(transcribe_session * session,
     if (cc->kv_cache.n_ctx < dec_ring) {
         const ggml_type kt = (cc->kv_type == TRANSCRIBE_KV_TYPE_F32) ? GGML_TYPE_F32 : GGML_TYPE_F16;
         cc->kv_cache.free();
-        if (!transcribe::causal_lm::kv_init(cc->kv_cache, cm->plan.primary, dec_ring,
-                cm->hparams.dec_n_kv_heads, cm->hparams.dec_head_dim,
-                cm->hparams.dec_n_layers, kt)) {
+        if (!transcribe::causal_lm::kv_init(cc->kv_cache, cm->plan.primary, dec_ring, cm->hparams.dec_n_kv_heads,
+                                            cm->hparams.dec_head_dim, cm->hparams.dec_n_layers, kt)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "voxtral_realtime stream_begin: decoder KV cache allocation "
-                "failed — out of memory.");
+                                "voxtral_realtime stream_begin: decoder KV cache allocation "
+                                "failed — out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
     }
-    if (cc->kv_cache.buffer != nullptr) ggml_backend_buffer_clear(cc->kv_cache.buffer, 0);
-    cc->kv_cache.n = 0; cc->kv_cache.head = 0;
+    if (cc->kv_cache.buffer != nullptr) {
+        ggml_backend_buffer_clear(cc->kv_cache.buffer, 0);
+    }
+    cc->kv_cache.n    = 0;
+    cc->kv_cache.head = 0;
 
     // Adaptive-norm scales for the active delay (persist across feeds).
-    if (auto st = compute_ada_scales(cc, cm, nd); st != TRANSCRIBE_OK) return st;
+    if (auto st = compute_ada_scales(cc, cm, nd); st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     transcribe::debug::init();
     return TRANSCRIBE_OK;
 }
 
-transcribe_status stream_feed(transcribe_session * session, const float * pcm,
-                              int n_samples, transcribe_stream_update * update) {
+transcribe_status stream_feed(transcribe_session *       session,
+                              const float *              pcm,
+                              int                        n_samples,
+                              transcribe_stream_update * update) {
     auto * cc = static_cast<Session *>(session);
     auto * cm = static_cast<Model *>(cc->model);
-    if (cm == nullptr || cm->plan.scheduler_list.empty()) return TRANSCRIBE_ERR_INVALID_ARG;
-    if (cc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
+    if (cm == nullptr || cm->plan.scheduler_list.empty()) {
+        return TRANSCRIBE_ERR_INVALID_ARG;
+    }
+    if (cc->poll_abort()) {
+        return TRANSCRIBE_ERR_ABORTED;
+    }
 
-    if (n_samples > 0 && pcm != nullptr)
+    if (n_samples > 0 && pcm != nullptr) {
         cc->stream_pcm.insert(cc->stream_pcm.end(), pcm, pcm + n_samples);
+    }
 
-    const int sr = std::max(1, cm->hparams.fe_sample_rate);
+    const int sr              = std::max(1, cm->hparams.fe_sample_rate);
     cc->stream_audio_input_us = static_cast<int64_t>(cc->stream_pcm.size()) * 1000000 / sr;
 
-    bool result_changed = false;
-    const int64_t since = static_cast<int64_t>(cc->stream_pcm.size()) - cc->stream_last_decode_samples;
+    bool          result_changed   = false;
+    const int64_t since            = static_cast<int64_t>(cc->stream_pcm.size()) - cc->stream_last_decode_samples;
     const int64_t interval_samples = static_cast<int64_t>(cc->stream_min_decode_ms) * sr / 1000;
     if (since >= interval_samples) {
-        if (auto st = stream_process(cc, cm, /*is_final=*/false, &result_changed);
-            st != TRANSCRIBE_OK) return st;
+        if (auto st = stream_process(cc, cm, /*is_final=*/false, &result_changed); st != TRANSCRIBE_OK) {
+            return st;
+        }
         cc->stream_last_decode_samples = static_cast<int64_t>(cc->stream_pcm.size());
     }
 
@@ -1694,17 +2004,22 @@ transcribe_status stream_feed(transcribe_session * session, const float * pcm,
     return TRANSCRIBE_OK;
 }
 
-transcribe_status stream_finalize(transcribe_session * session,
-                                  transcribe_stream_update * update) {
+transcribe_status stream_finalize(transcribe_session * session, transcribe_stream_update * update) {
     auto * cc = static_cast<Session *>(session);
     auto * cm = static_cast<Model *>(cc->model);
-    if (cm == nullptr || cm->plan.scheduler_list.empty()) return TRANSCRIBE_ERR_INVALID_ARG;
-    if (cc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
+    if (cm == nullptr || cm->plan.scheduler_list.empty()) {
+        return TRANSCRIBE_ERR_INVALID_ARG;
+    }
+    if (cc->poll_abort()) {
+        return TRANSCRIBE_ERR_ABORTED;
+    }
 
     bool changed = false;
-    if (auto st = stream_process(cc, cm, /*is_final=*/true, &changed); st != TRANSCRIBE_OK) return st;
+    if (auto st = stream_process(cc, cm, /*is_final=*/true, &changed); st != TRANSCRIBE_OK) {
+        return st;
+    }
 
-    const int sr = std::max(1, cm->hparams.fe_sample_rate);
+    const int     sr       = std::max(1, cm->hparams.fe_sample_rate);
     const int64_t audio_ms = static_cast<int64_t>(cc->stream_pcm.size()) * 1000 / sr;
     if (update != nullptr) {
         update->result_changed     = true;
@@ -1723,27 +2038,28 @@ void stream_reset(transcribe_session * session) {
     cc->stream_num_delay           = -1;
     cc->enc_kv.free();
     cc->stream_n_enc_committed = 0;
-    cc->stream_enc_slot     = 0;
-    cc->stream_enc_abs_base = 0;
+    cc->stream_enc_slot        = 0;
+    cc->stream_enc_abs_base    = 0;
     cc->stream_conv0_cache.clear();
     cc->stream_conv1_cache.clear();
     cc->stream_n_mel_committed = 0;
-    cc->stream_pcm_drop = 0;
-    cc->stream_audio_base = 0;
+    cc->stream_pcm_drop        = 0;
+    cc->stream_audio_base      = 0;
     cc->stream_audio_embeds.clear();
-    cc->stream_n_tok_ready  = 0;
-    cc->stream_prompt_done  = false;
-    cc->stream_dec_pos      = 0;
-    cc->stream_next_tok     = 0;
-    cc->stream_eos          = false;
+    cc->stream_n_tok_ready = 0;
+    cc->stream_prompt_done = false;
+    cc->stream_dec_pos     = 0;
+    cc->stream_next_tok    = 0;
+    cc->stream_eos         = false;
     cc->stream_generated.clear();
     cc->stream_n_audio_clamp = -1;
 }
 
-bool accepts_ext_kind(const transcribe_model * model, transcribe_ext_slot slot,
-                      uint32_t kind) {
+bool accepts_ext_kind(const transcribe_model * model, transcribe_ext_slot slot, uint32_t kind) {
     (void) model;
-    if (slot != TRANSCRIBE_EXT_SLOT_STREAM) return false;
+    if (slot != TRANSCRIBE_EXT_SLOT_STREAM) {
+        return false;
+    }
     return kind == TRANSCRIBE_EXT_KIND_VOXTRAL_REALTIME_STREAM;
 }
 
@@ -1758,18 +2074,22 @@ bool accepts_ext_kind(const transcribe_model * model, transcribe_ext_slot slot,
 // AND every decode step, and a per-row n_audio clamp. Falls back to serial for
 // n==1, dump mode, or no decoder flash (the batched blocks are flash-only).
 
-transcribe_status run_batch_serial(Session * cc, const float * const * pcm,
-                                   const int * n_samples, int n,
+transcribe_status run_batch_serial(Session *                     cc,
+                                   const float * const *         pcm,
+                                   const int *                   n_samples,
+                                   int                           n,
                                    const transcribe_run_params * params) {
     for (int i = 0; i < n; ++i) {
-        if (cc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
-        const transcribe_status st =
-            (pcm[i] == nullptr || n_samples[i] <= 0)
-                ? TRANSCRIBE_ERR_INVALID_ARG
-                : run(cc, pcm[i], n_samples[i], params);
-        if (st == TRANSCRIBE_OK) cc->batch_results.push_back(cc->capture_result(st));
-        else {
-            transcribe_session::ResultSet rs; rs.status = st;
+        if (cc->poll_abort()) {
+            return TRANSCRIBE_ERR_ABORTED;
+        }
+        const transcribe_status st = (pcm[i] == nullptr || n_samples[i] <= 0) ? TRANSCRIBE_ERR_INVALID_ARG :
+                                                                                run(cc, pcm[i], n_samples[i], params);
+        if (st == TRANSCRIBE_OK) {
+            cc->batch_results.push_back(cc->capture_result(st));
+        } else {
+            transcribe_session::ResultSet rs;
+            rs.status = st;
             cc->batch_results.push_back(std::move(rs));
         }
     }
@@ -1781,42 +2101,59 @@ transcribe_status run_batch_serial(Session * cc, const float * const * pcm,
 // (2) a per-row n_audio clamp. Mirrors forward_buffer's single-utterance step
 // loop: open the KV window [0, n_past] cumulatively (no sliding-window eviction;
 // offline clips fit the window), never push EOS, stop a row at EOS or n_audio_b.
-transcribe_status run_batch_step_loop(
-    Session * cc, const StepBuildBatched & sb, int n, int max_n_kv,
-    int32_t eos_id, int dec_h,
-    const std::vector<std::vector<float>> & enc_hosts,
-    const std::vector<int> & n_audio_b, std::vector<char> & valid,
-    std::vector<int32_t> & next_tok, std::vector<int> & n_past,
-    std::vector<std::vector<int32_t>> & generated) {
-    const ggml_fp16_t mz = ggml_fp32_to_fp16(0.0f), mn = ggml_fp32_to_fp16(-INFINITY);
-    std::vector<int32_t> ids_buf(n, 0), pos_buf(n, 0), out_buf(n, 0);
-    std::vector<int64_t> kvidx_buf(n, 0);
-    std::vector<float> audio_buf(static_cast<size_t>(dec_h) * n, 0.0f);
+transcribe_status run_batch_step_loop(Session *                               cc,
+                                      const StepBuildBatched &                sb,
+                                      int                                     n,
+                                      int                                     max_n_kv,
+                                      int32_t                                 eos_id,
+                                      int                                     dec_h,
+                                      const std::vector<std::vector<float>> & enc_hosts,
+                                      const std::vector<int> &                n_audio_b,
+                                      std::vector<char> &                     valid,
+                                      std::vector<int32_t> &                  next_tok,
+                                      std::vector<int> &                      n_past,
+                                      std::vector<std::vector<int32_t>> &     generated) {
+    const ggml_fp16_t        mz = ggml_fp32_to_fp16(0.0f), mn = ggml_fp32_to_fp16(-INFINITY);
+    std::vector<int32_t>     ids_buf(n, 0), pos_buf(n, 0), out_buf(n, 0);
+    std::vector<int64_t>     kvidx_buf(n, 0);
+    std::vector<float>       audio_buf(static_cast<size_t>(dec_h) * n, 0.0f);
     std::vector<ggml_fp16_t> mask_buf(static_cast<size_t>(max_n_kv) * n, mn);
-    std::vector<char> finished(n, 1);
-    for (int b = 0; b < n; ++b)
-        if (valid[b]) finished[b] = (next_tok[b] == eos_id || n_past[b] >= n_audio_b[b]);
+    std::vector<char>        finished(n, 1);
     for (int b = 0; b < n; ++b) {
-        if (!valid[b]) continue;
+        if (valid[b]) {
+            finished[b] = (next_tok[b] == eos_id || n_past[b] >= n_audio_b[b]);
+        }
+    }
+    for (int b = 0; b < n; ++b) {
+        if (!valid[b]) {
+            continue;
+        }
         const size_t base = static_cast<size_t>(b) * max_n_kv;
-        for (int c = 0; c <= n_past[b] && c < max_n_kv; ++c) mask_buf[base + c] = mz;
+        for (int c = 0; c <= n_past[b] && c < max_n_kv; ++c) {
+            mask_buf[base + c] = mz;
+        }
     }
 
     bool all_done = false;
     while (!all_done) {
-        if (cc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
+        if (cc->poll_abort()) {
+            return TRANSCRIBE_ERR_ABORTED;
+        }
         for (int b = 0; b < n; ++b) {
             ids_buf[b]   = next_tok[b];
             pos_buf[b]   = n_past[b];
             kvidx_buf[b] = n_past[b];
-            int ac = n_past[b];                          // audio embed for this position
-            if (ac >= n_audio_b[b]) ac = (n_audio_b[b] > 0 ? n_audio_b[b] - 1 : 0);
+            int ac       = n_past[b];  // audio embed for this position
+            if (ac >= n_audio_b[b]) {
+                ac = (n_audio_b[b] > 0 ? n_audio_b[b] - 1 : 0);
+            }
             float * dst = audio_buf.data() + static_cast<size_t>(b) * dec_h;
-            if (valid[b] && !enc_hosts[b].empty())
+            if (valid[b] && !enc_hosts[b].empty()) {
                 std::memcpy(dst, enc_hosts[b].data() + static_cast<size_t>(ac) * dec_h,
                             static_cast<size_t>(dec_h) * sizeof(float));
-            else
+            } else {
                 std::memset(dst, 0, static_cast<size_t>(dec_h) * sizeof(float));
+            }
         }
         ggml_backend_tensor_set(sb.input_ids_in, ids_buf.data(), 0, ids_buf.size() * sizeof(int32_t));
         ggml_backend_tensor_set(sb.audio_in, audio_buf.data(), 0, audio_buf.size() * sizeof(float));
@@ -1831,137 +2168,180 @@ transcribe_status run_batch_step_loop(
 
         all_done = true;
         for (int b = 0; b < n; ++b) {
-            if (finished[b] || !valid[b]) continue;
+            if (finished[b] || !valid[b]) {
+                continue;
+            }
             const int32_t tok = out_buf[b];
-            next_tok[b] = tok;
+            next_tok[b]       = tok;
             n_past[b] += 1;
-            if (tok == eos_id) { finished[b] = 1; continue; }       // don't push EOS
+            if (tok == eos_id) {
+                finished[b] = 1;
+                continue;
+            }  // don't push EOS
             generated[b].push_back(tok);
-            if (n_past[b] >= n_audio_b[b]) { finished[b] = 1; continue; }  // clamp (token pushed)
+            if (n_past[b] >= n_audio_b[b]) {
+                finished[b] = 1;
+                continue;
+            }  // clamp (token pushed)
             const size_t base = static_cast<size_t>(b) * max_n_kv;
-            if (n_past[b] < max_n_kv) mask_buf[base + n_past[b]] = mz;     // open next position
+            if (n_past[b] < max_n_kv) {
+                mask_buf[base + n_past[b]] = mz;  // open next position
+            }
             all_done = false;
         }
     }
     return TRANSCRIBE_OK;
 }
 
-transcribe_status run_batch(transcribe_session * session, const float * const * pcm,
-                            const int * n_samples, int n,
+transcribe_status run_batch(transcribe_session *          session,
+                            const float * const *         pcm,
+                            const int *                   n_samples,
+                            int                           n,
                             const transcribe_run_params * params) {
     auto * cc = static_cast<Session *>(session);
     auto * cm = static_cast<Model *>(cc->model);
-    if (cm == nullptr || cm->plan.scheduler_list.empty() || !cm->mel.has_value())
+    if (cm == nullptr || cm->plan.scheduler_list.empty() || !cm->mel.has_value()) {
         return TRANSCRIBE_ERR_INVALID_ARG;
+    }
 
     // The batched causal_lm decoder blocks are flash-only; dump mode and n==1 take
     // the established single-shot path. The batched encoder honors encoder_use_flash
     // (default non-flash = CPU source of truth), so it is not gated here.
-    if (!cc->decoder_use_flash || transcribe::debug::enabled() || n == 1)
+    if (!cc->decoder_use_flash || transcribe::debug::enabled() || n == 1) {
         return run_batch_serial(cc, pcm, n_samples, n, params);
+    }
 
     transcribe::debug::init();
-    const int     num_delay = cm->hparams.default_num_delay_tokens;
-    const int     n_mels    = cm->hparams.enc_num_mel_bins;
-    const int     dec_h     = cm->hparams.dec_hidden;
-    const int     down      = cm->hparams.proj_downsample;
-    const int32_t eos_id    = cm->hparams.eos_token_id;
-    const PromptSpecials & sp = cm->specials;
+    const int              num_delay = cm->hparams.default_num_delay_tokens;
+    const int              n_mels    = cm->hparams.enc_num_mel_bins;
+    const int              dec_h     = cm->hparams.dec_hidden;
+    const int              down      = cm->hparams.proj_downsample;
+    const int32_t          eos_id    = cm->hparams.eos_token_id;
+    const PromptSpecials & sp        = cm->specials;
 
     // ----- Pass 0: per-utterance offline-padded mel -----
-    std::vector<char> valid(n, 1);
+    std::vector<char>               valid(n, 1);
     // Per-utterance terminal status for rejected rows (default INVALID_ARG;
     // over-context rows below upgrade to INPUT_TOO_LONG).
-    std::vector<transcribe_status> fail_status(n, TRANSCRIBE_ERR_INVALID_ARG);
-    std::vector<std::vector<float>> mel_bufs(n);   // mel-major [n_mels, mel_nf]
-    std::vector<int> mel_nf(n, 0);
-    int max_mel = 0;
-    const int64_t t_mel0 = ggml_time_us();
+    std::vector<transcribe_status>  fail_status(n, TRANSCRIBE_ERR_INVALID_ARG);
+    std::vector<std::vector<float>> mel_bufs(n);  // mel-major [n_mels, mel_nf]
+    std::vector<int>                mel_nf(n, 0);
+    int                             max_mel = 0;
+    const int64_t                   t_mel0  = ggml_time_us();
     for (int b = 0; b < n; ++b) {
-        if (pcm[b] == nullptr || n_samples[b] <= 0) { valid[b] = 0; continue; }
-        const int raw_per_tok = cm->hparams.audio_length_per_tok * cm->hparams.fe_hop_length;
-        const size_t left  = static_cast<size_t>(sp.n_left_pad) * raw_per_tok;
-        const size_t right = static_cast<size_t>(num_delay + 1 + 10) * raw_per_tok;
-        const size_t raw_pad =
-            ((static_cast<size_t>(n_samples[b]) + raw_per_tok - 1) / raw_per_tok) * raw_per_tok;
-        const size_t total = left + raw_pad + right;
+        if (pcm[b] == nullptr || n_samples[b] <= 0) {
+            valid[b] = 0;
+            continue;
+        }
+        const int    raw_per_tok = cm->hparams.audio_length_per_tok * cm->hparams.fe_hop_length;
+        const size_t left        = static_cast<size_t>(sp.n_left_pad) * raw_per_tok;
+        const size_t right       = static_cast<size_t>(num_delay + 1 + 10) * raw_per_tok;
+        const size_t raw_pad     = ((static_cast<size_t>(n_samples[b]) + raw_per_tok - 1) / raw_per_tok) * raw_per_tok;
+        const size_t total       = left + raw_pad + right;
         std::vector<float> padded(total, 0.0f);
         std::memcpy(padded.data() + left, pcm[b], static_cast<size_t>(n_samples[b]) * sizeof(float));
         int mm = 0, nf = 0;
-        if (cm->mel->compute(padded.data(), total, mel_bufs[b], mm, nf, cc->n_threads) != TRANSCRIBE_OK
-            || mm != n_mels) { valid[b] = 0; continue; }
+        if (cm->mel->compute(padded.data(), total, mel_bufs[b], mm, nf, cc->n_threads) != TRANSCRIBE_OK ||
+            mm != n_mels) {
+            valid[b] = 0;
+            continue;
+        }
         mel_nf[b] = nf;
-        if (nf > max_mel) max_mel = nf;
+        if (nf > max_mel) {
+            max_mel = nf;
+        }
     }
     const int64_t mel_us = ggml_time_us() - t_mel0;
 
     auto emit_all_invalid = [&]() {
         for (int b = 0; b < n; ++b) {
-            transcribe_session::ResultSet rs; rs.status = fail_status[b];
+            transcribe_session::ResultSet rs;
+            rs.status = fail_status[b];
             cc->batch_results.push_back(std::move(rs));
         }
         return TRANSCRIBE_OK;
     };
-    if (max_mel <= 4) return emit_all_invalid();
+    if (max_mel <= 4) {
+        return emit_all_invalid();
+    }
 
     if (cc->sched == nullptr) {
         cc->sched = ggml_backend_sched_new(cm->plan.scheduler_list.data(), nullptr,
-            static_cast<int>(cm->plan.scheduler_list.size()), 16384, false, true);
-        if (cc->sched == nullptr) return TRANSCRIBE_ERR_GGUF;
+                                           static_cast<int>(cm->plan.scheduler_list.size()), 16384, false, true);
+        if (cc->sched == nullptr) {
+            return TRANSCRIBE_ERR_GGUF;
+        }
     }
 
     // ----- Pass 1: batched encoder (mels right-padded to max_mel) -----
     std::vector<std::vector<float>> enc_hosts(n);  // [b] -> [dec_h * n_audio_b]
-    std::vector<int> n_audio_b(n, 0);
-    const int64_t t_enc0 = ggml_time_us();
+    std::vector<int>                n_audio_b(n, 0);
+    const int64_t                   t_enc0 = ggml_time_us();
     {
-        if (cc->compute_ctx != nullptr) { ggml_free(cc->compute_ctx); cc->compute_ctx = nullptr; }
-        ggml_init_params ip {}; ip.mem_size = 64 * 1024 * 1024; ip.no_alloc = true;
+        if (cc->compute_ctx != nullptr) {
+            ggml_free(cc->compute_ctx);
+            cc->compute_ctx = nullptr;
+        }
+        ggml_init_params ip{};
+        ip.mem_size     = 64 * 1024 * 1024;
+        ip.no_alloc     = true;
         cc->compute_ctx = ggml_init(ip);
         if (cc->compute_ctx == nullptr) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "voxtral_realtime: compute context allocation failed — "
-                "out of memory.");
+                                "voxtral_realtime: compute context allocation failed — "
+                                "out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
 
-        EncoderBuildBatched eb = build_encoder_graph_batched(cc->compute_ctx, cm->weights,
-            cm->hparams, max_mel, n, cc->encoder_use_flash);
-        if (eb.graph == nullptr || eb.out == nullptr) return TRANSCRIBE_ERR_GGUF;
+        EncoderBuildBatched eb =
+            build_encoder_graph_batched(cc->compute_ctx, cm->weights, cm->hparams, max_mel, n, cc->encoder_use_flash);
+        if (eb.graph == nullptr || eb.out == nullptr) {
+            return TRANSCRIBE_ERR_GGUF;
+        }
         const int T_enc_max   = eb.T_enc;
         const int n_audio_max = eb.n_audio;
 
         ggml_backend_sched_reset(cc->sched);
         if (!ggml_backend_sched_alloc_graph(cc->sched, eb.graph)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "voxtral_realtime run_batch: encoder graph allocation failed — "
-                "out of memory.");
+                                "voxtral_realtime run_batch: encoder graph allocation failed — "
+                                "out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
 
         std::vector<float> mel_in(static_cast<size_t>(n_mels) * max_mel * n, 0.0f);
         for (int b = 0; b < n; ++b) {
-            if (!valid[b]) continue;
-            const int nf = mel_nf[b];
+            if (!valid[b]) {
+                continue;
+            }
+            const int    nf   = mel_nf[b];
             const size_t boff = static_cast<size_t>(b) * n_mels * max_mel;
-            for (int t = 0; t < nf; ++t)
-                for (int mmi = 0; mmi < n_mels; ++mmi)
+            for (int t = 0; t < nf; ++t) {
+                for (int mmi = 0; mmi < n_mels; ++mmi) {
                     mel_in[boff + static_cast<size_t>(t) * n_mels + mmi] =
                         mel_bufs[b][static_cast<size_t>(mmi) * nf + t];
+                }
+            }
         }
         ggml_backend_tensor_set(eb.mel_in, mel_in.data(), 0, mel_in.size() * sizeof(float));
 
         std::vector<int32_t> positions(T_enc_max);
-        for (int i = 0; i < T_enc_max; ++i) positions[i] = i;
+        for (int i = 0; i < T_enc_max; ++i) {
+            positions[i] = i;
+        }
         ggml_backend_tensor_set(eb.positions_in, positions.data(), 0, positions.size() * sizeof(int32_t));
 
         {
-            const int T = T_enc_max, win = cm->hparams.enc_sliding_window;
-            const ggml_fp16_t mz = ggml_fp32_to_fp16(0.0f), mn = ggml_fp32_to_fp16(-INFINITY);
+            const int                T = T_enc_max, win = cm->hparams.enc_sliding_window;
+            const ggml_fp16_t        mz = ggml_fp32_to_fp16(0.0f), mn = ggml_fp32_to_fp16(-INFINITY);
             std::vector<ggml_fp16_t> mask(static_cast<size_t>(T) * T, mn);
-            for (int q = 0; q < T; ++q)
-                for (int k = 0; k <= q; ++k)
-                    if (q - k < win) mask[static_cast<size_t>(q) * T + k] = mz;
+            for (int q = 0; q < T; ++q) {
+                for (int k = 0; k <= q; ++k) {
+                    if (q - k < win) {
+                        mask[static_cast<size_t>(q) * T + k] = mz;
+                    }
+                }
+            }
             ggml_backend_tensor_set(eb.mask_in, mask.data(), 0, mask.size() * sizeof(ggml_fp16_t));
         }
         apply_threads(cc->sched, cc->n_threads);
@@ -1973,26 +2353,36 @@ transcribe_status run_batch(transcribe_session * session, const float * const *
         std::vector<float> proj(static_cast<size_t>(dec_h) * n_audio_max * n);
         ggml_backend_tensor_get(eb.out, proj.data(), 0, proj.size() * sizeof(float));
         for (int b = 0; b < n; ++b) {
-            if (!valid[b]) continue;
+            if (!valid[b]) {
+                continue;
+            }
             const int T_enc_b = (mel_nf[b] - 2) / 2 + 1;
-            int na = T_enc_b / down;
-            if (na <= 0) { valid[b] = 0; continue; }
-            if (na > n_audio_max) na = n_audio_max;
-            n_audio_b[b] = na;
+            int       na      = T_enc_b / down;
+            if (na <= 0) {
+                valid[b] = 0;
+                continue;
+            }
+            if (na > n_audio_max) {
+                na = n_audio_max;
+            }
+            n_audio_b[b]      = na;
             const size_t boff = static_cast<size_t>(b) * dec_h * n_audio_max;
-            enc_hosts[b].assign(proj.begin() + boff,
-                                proj.begin() + boff + static_cast<size_t>(dec_h) * na);
+            enc_hosts[b].assign(proj.begin() + boff, proj.begin() + boff + static_cast<size_t>(dec_h) * na);
         }
     }
     const int64_t enc_us = ggml_time_us() - t_enc0;
 
     // ----- Pass 2: ada scales (shared; num_delay uniform across the batch) -----
-    if (compute_ada_scales(cc, cm, num_delay) != TRANSCRIBE_OK) return TRANSCRIBE_ERR_GGUF;
+    if (compute_ada_scales(cc, cm, num_delay) != TRANSCRIBE_OK) {
+        return TRANSCRIBE_ERR_GGUF;
+    }
 
     // ----- Prompt (uniform) + short-clip gating -----
     std::vector<int32_t> prompt_ids;
     prompt_ids.push_back(sp.bos);
-    for (int i = 0; i < sp.n_left_pad + num_delay; ++i) prompt_ids.push_back(sp.streaming_pad);
+    for (int i = 0; i < sp.n_left_pad + num_delay; ++i) {
+        prompt_ids.push_back(sp.streaming_pad);
+    }
     const int T_prompt = static_cast<int>(prompt_ids.size());
 
     // model_max = dec_max_position, the absolute RoPE wall (n_ctx never narrows
@@ -2000,107 +2390,143 @@ transcribe_status run_batch(transcribe_session * session, const float * const *
     // can't be partially decoded by clamping the cache — reject up front with
     // INPUT_TOO_LONG, same contract as run().
     const int model_max = voxtral_realtime_abs_position_cap(cm->hparams);
-    int max_audio = 0;
+    int       max_audio = 0;
     for (int b = 0; b < n; ++b) {
-        if (!valid[b]) continue;
-        if (T_prompt >= n_audio_b[b]) { valid[b] = 0; continue; }  // clip too short
-        if (model_max > 0 && n_audio_b[b] + 1 > model_max) {       // clip too long
+        if (!valid[b]) {
+            continue;
+        }
+        if (T_prompt >= n_audio_b[b]) {
+            valid[b] = 0;
+            continue;
+        }  // clip too short
+        if (model_max > 0 && n_audio_b[b] + 1 > model_max) {  // clip too long
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "voxtral_realtime run_batch: utterance %d input too long — %d "
-                "audio tokens exceed the model's %d-token absolute position cap "
-                "(dec_max_position, ~2.9 h). Shorten the audio. See "
-                "transcribe_capabilities.max_audio_ms.",
-                b, n_audio_b[b], model_max);
+                                "voxtral_realtime run_batch: utterance %d input too long — %d "
+                                "audio tokens exceed the model's %d-token absolute position cap "
+                                "(dec_max_position, ~2.9 h). Shorten the audio. See "
+                                "transcribe_capabilities.max_audio_ms.",
+                                b, n_audio_b[b], model_max);
             valid[b]       = 0;
             fail_status[b] = TRANSCRIBE_ERR_INPUT_TOO_LONG;
             continue;
         }
-        if (n_audio_b[b] > max_audio) max_audio = n_audio_b[b];
+        if (n_audio_b[b] > max_audio) {
+            max_audio = n_audio_b[b];
+        }
+    }
+    if (max_audio <= T_prompt) {
+        return emit_all_invalid();
     }
-    if (max_audio <= T_prompt) return emit_all_invalid();
 
     // ----- Batched KV cache (one slab per row) -----
     // Every valid row now satisfies n_audio_b[b] + 1 <= model_max, so the
     // pow2 width is safely clamped to the ceiling without cutting any decode.
-    int max_n_kv = 1024; while (max_n_kv < max_audio + 1) max_n_kv *= 2;
-    if (model_max > 0 && max_n_kv > model_max) max_n_kv = model_max;
+    int max_n_kv = 1024;
+    while (max_n_kv < max_audio + 1) {
+        max_n_kv *= 2;
+    }
+    if (model_max > 0 && max_n_kv > model_max) {
+        max_n_kv = model_max;
+    }
     // Step attention reads only the valid window: the batch's actual max audio
     // length, not the power-of-2 allocation. min() preserves the full window if
     // the alloc was capped. Bit-identical (extra slots are masked).
-    const int read_n_kv = std::min(max_audio, max_n_kv);
-    const ggml_type kv_type = (cc->kv_type == TRANSCRIBE_KV_TYPE_F32) ? GGML_TYPE_F32 : GGML_TYPE_F16;
-    if (cc->kv_cache_batch.self_k == nullptr || cc->kv_batch_cap != n ||
-        cc->kv_batch_n_ctx < max_n_kv) {
+    const int       read_n_kv = std::min(max_audio, max_n_kv);
+    const ggml_type kv_type   = (cc->kv_type == TRANSCRIBE_KV_TYPE_F32) ? GGML_TYPE_F32 : GGML_TYPE_F16;
+    if (cc->kv_cache_batch.self_k == nullptr || cc->kv_batch_cap != n || cc->kv_batch_n_ctx < max_n_kv) {
         cc->kv_cache_batch.free();
-        if (!transcribe::causal_lm::kv_init_batched(cc->kv_cache_batch, cm->plan.primary,
-                max_n_kv, cm->hparams.dec_n_kv_heads, cm->hparams.dec_head_dim,
-                cm->hparams.dec_n_layers, n, kv_type)) {
+        if (!transcribe::causal_lm::kv_init_batched(cc->kv_cache_batch, cm->plan.primary, max_n_kv,
+                                                    cm->hparams.dec_n_kv_heads, cm->hparams.dec_head_dim,
+                                                    cm->hparams.dec_n_layers, n, kv_type)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "voxtral_realtime run_batch: batched KV cache allocation failed — "
-                "out of memory.");
+                                "voxtral_realtime run_batch: batched KV cache allocation failed — "
+                                "out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
         cc->kv_batch_cap   = n;
         cc->kv_batch_n_ctx = max_n_kv;
     }
-    if (cc->kv_cache_batch.buffer != nullptr) ggml_backend_buffer_clear(cc->kv_cache_batch.buffer, 0);
+    if (cc->kv_cache_batch.buffer != nullptr) {
+        ggml_backend_buffer_clear(cc->kv_cache_batch.buffer, 0);
+    }
 
-    std::vector<int32_t> next_tok(n, 0);
-    std::vector<int> n_past(n, T_prompt);
+    std::vector<int32_t>              next_tok(n, 0);
+    std::vector<int>                  n_past(n, T_prompt);
     std::vector<std::vector<int32_t>> generated(n);
 
     // ----- Pass 3: batched prefill (rectangular, additive fusion) -----
     const int64_t t_dec0 = ggml_time_us();
     {
-        if (cc->compute_ctx != nullptr) { ggml_free(cc->compute_ctx); cc->compute_ctx = nullptr; }
-        ggml_init_params ip {}; ip.mem_size = 64 * 1024 * 1024; ip.no_alloc = true;
+        if (cc->compute_ctx != nullptr) {
+            ggml_free(cc->compute_ctx);
+            cc->compute_ctx = nullptr;
+        }
+        ggml_init_params ip{};
+        ip.mem_size     = 64 * 1024 * 1024;
+        ip.no_alloc     = true;
         cc->compute_ctx = ggml_init(ip);
         if (cc->compute_ctx == nullptr) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "voxtral_realtime: compute context allocation failed — "
-                "out of memory.");
+                                "voxtral_realtime: compute context allocation failed — "
+                                "out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
 
-        PrefillBuildBatched pb = build_prefill_graph_batched(cc->compute_ctx, cm->weights,
-            cm->hparams, cc->kv_cache_batch, cc->ada_scale_all, T_prompt, n, cc->decoder_use_flash);
-        if (pb.graph == nullptr || pb.out == nullptr) return TRANSCRIBE_ERR_GGUF;
+        PrefillBuildBatched pb =
+            build_prefill_graph_batched(cc->compute_ctx, cm->weights, cm->hparams, cc->kv_cache_batch,
+                                        cc->ada_scale_all, T_prompt, n, cc->decoder_use_flash);
+        if (pb.graph == nullptr || pb.out == nullptr) {
+            return TRANSCRIBE_ERR_GGUF;
+        }
         ggml_backend_sched_reset(cc->sched);
         if (!ggml_backend_sched_alloc_graph(cc->sched, pb.graph)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "voxtral_realtime run_batch: prefill graph allocation failed — "
-                "out of memory.");
+                                "voxtral_realtime run_batch: prefill graph allocation failed — "
+                                "out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
 
         std::vector<int32_t> ids(static_cast<size_t>(T_prompt) * n);
-        for (int b = 0; b < n; ++b)
-            for (int t = 0; t < T_prompt; ++t) ids[static_cast<size_t>(b) * T_prompt + t] = prompt_ids[t];
+        for (int b = 0; b < n; ++b) {
+            for (int t = 0; t < T_prompt; ++t) {
+                ids[static_cast<size_t>(b) * T_prompt + t] = prompt_ids[t];
+            }
+        }
         ggml_backend_tensor_set(pb.input_ids_in, ids.data(), 0, ids.size() * sizeof(int32_t));
 
         std::vector<float> audio(static_cast<size_t>(dec_h) * T_prompt * n, 0.0f);
         for (int b = 0; b < n; ++b) {
-            if (!valid[b]) continue;
-            std::memcpy(audio.data() + static_cast<size_t>(b) * T_prompt * dec_h,
-                        enc_hosts[b].data(), static_cast<size_t>(dec_h) * T_prompt * sizeof(float));
+            if (!valid[b]) {
+                continue;
+            }
+            std::memcpy(audio.data() + static_cast<size_t>(b) * T_prompt * dec_h, enc_hosts[b].data(),
+                        static_cast<size_t>(dec_h) * T_prompt * sizeof(float));
         }
         ggml_backend_tensor_set(pb.audio_dense_in, audio.data(), 0, audio.size() * sizeof(float));
 
         std::vector<int32_t> positions(T_prompt);
-        for (int t = 0; t < T_prompt; ++t) positions[t] = t;
+        for (int t = 0; t < T_prompt; ++t) {
+            positions[t] = t;
+        }
         ggml_backend_tensor_set(pb.positions_in, positions.data(), 0, positions.size() * sizeof(int32_t));
 
         {
-            const ggml_fp16_t mz = ggml_fp32_to_fp16(0.0f), mn = ggml_fp32_to_fp16(-INFINITY);
+            const ggml_fp16_t        mz = ggml_fp32_to_fp16(0.0f), mn = ggml_fp32_to_fp16(-INFINITY);
             std::vector<ggml_fp16_t> mask(static_cast<size_t>(T_prompt) * T_prompt, mn);
-            for (int r = 0; r < T_prompt; ++r) for (int c = 0; c <= r; ++c)
-                mask[static_cast<size_t>(r) * T_prompt + c] = mz;
+            for (int r = 0; r < T_prompt; ++r) {
+                for (int c = 0; c <= r; ++c) {
+                    mask[static_cast<size_t>(r) * T_prompt + c] = mz;
+                }
+            }
             ggml_backend_tensor_set(pb.mask_in, mask.data(), 0, mask.size() * sizeof(ggml_fp16_t));
         }
 
         std::vector<int64_t> kvidx(static_cast<size_t>(T_prompt) * n);
-        for (int b = 0; b < n; ++b)
-            for (int t = 0; t < T_prompt; ++t) kvidx[static_cast<size_t>(b) * T_prompt + t] = t;
+        for (int b = 0; b < n; ++b) {
+            for (int t = 0; t < T_prompt; ++t) {
+                kvidx[static_cast<size_t>(b) * T_prompt + t] = t;
+            }
+        }
         ggml_backend_tensor_set(pb.kv_idx_in, kvidx.data(), 0, kvidx.size() * sizeof(int64_t));
 
         std::vector<int32_t> last_idx(n, T_prompt - 1);
@@ -2115,64 +2541,74 @@ transcribe_status run_batch(transcribe_session * session, const float * const *
         ggml_backend_tensor_get(pb.out, first.data(), 0, first.size() * sizeof(int32_t));
         for (int b = 0; b < n; ++b) {
             next_tok[b] = first[b];
-            if (valid[b]) generated[b].push_back(first[b]);
+            if (valid[b]) {
+                generated[b].push_back(first[b]);
+            }
         }
     }
 
     // ----- Pass 4: batched step loop -----
     {
-        if (cc->compute_ctx != nullptr) { ggml_free(cc->compute_ctx); cc->compute_ctx = nullptr; }
-        ggml_init_params ip {}; ip.mem_size = 32 * 1024 * 1024; ip.no_alloc = true;
+        if (cc->compute_ctx != nullptr) {
+            ggml_free(cc->compute_ctx);
+            cc->compute_ctx = nullptr;
+        }
+        ggml_init_params ip{};
+        ip.mem_size     = 32 * 1024 * 1024;
+        ip.no_alloc     = true;
         cc->compute_ctx = ggml_init(ip);
         if (cc->compute_ctx == nullptr) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "voxtral_realtime: compute context allocation failed — "
-                "out of memory.");
+                                "voxtral_realtime: compute context allocation failed — "
+                                "out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
 
-        StepBuildBatched sb = build_step_graph_batched(cc->compute_ctx, cm->weights,
-            cm->hparams, cc->kv_cache_batch, cc->ada_scale_all, read_n_kv, n, cc->decoder_use_flash);
-        if (sb.graph == nullptr || sb.out == nullptr) return TRANSCRIBE_ERR_GGUF;
+        StepBuildBatched sb = build_step_graph_batched(cc->compute_ctx, cm->weights, cm->hparams, cc->kv_cache_batch,
+                                                       cc->ada_scale_all, read_n_kv, n, cc->decoder_use_flash);
+        if (sb.graph == nullptr || sb.out == nullptr) {
+            return TRANSCRIBE_ERR_GGUF;
+        }
         ggml_backend_sched_reset(cc->sched);
         if (!ggml_backend_sched_alloc_graph(cc->sched, sb.graph)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "voxtral_realtime run_batch: step graph allocation failed — "
-                "out of memory.");
+                                "voxtral_realtime run_batch: step graph allocation failed — "
+                                "out of memory.");
             return TRANSCRIBE_ERR_OOM;
         }
         apply_threads(cc->sched, cc->n_threads);
 
-        const transcribe_status st = run_batch_step_loop(cc, sb, n, read_n_kv, eos_id, dec_h,
-            enc_hosts, n_audio_b, valid, next_tok, n_past, generated);
-        if (st != TRANSCRIBE_OK) return st;
+        const transcribe_status st = run_batch_step_loop(cc, sb, n, read_n_kv, eos_id, dec_h, enc_hosts, n_audio_b,
+                                                         valid, next_tok, n_past, generated);
+        if (st != TRANSCRIBE_OK) {
+            return st;
+        }
     }
     const int64_t dec_us = ggml_time_us() - t_dec0;
 
     // ----- Capture per-utterance results -----
-    const int valid_count = std::max(1,
-        static_cast<int>(std::count(valid.begin(), valid.end(), char(1))));
+    const int valid_count = std::max(1, static_cast<int>(std::count(valid.begin(), valid.end(), char(1))));
     for (int b = 0; b < n; ++b) {
         if (!valid[b]) {
             // INVALID_ARG (malformed / clip-too-short) or INPUT_TOO_LONG
             // (rejected over-context row), per fail_status.
-            transcribe_session::ResultSet rs; rs.status = fail_status[b];
+            transcribe_session::ResultSet rs;
+            rs.status = fail_status[b];
             cc->batch_results.push_back(std::move(rs));
             continue;
         }
-        std::string text = detok_generated(cm, generated[b]);
+        std::string                   text = detok_generated(cm, generated[b]);
         transcribe_session::ResultSet rs;
         rs.full_text   = text;
         rs.result_kind = TRANSCRIBE_TIMESTAMPS_NONE;
         rs.has_result  = true;
         // Valid rows fit the context (over-context rows were rejected up front
         // as INPUT_TOO_LONG), so a completed row is OK.
-        rs.status = TRANSCRIBE_OK;
-        transcribe_session::SegmentEntry seg {};
+        rs.status      = TRANSCRIBE_OK;
+        transcribe_session::SegmentEntry seg{};
         seg.text  = text;
         seg.t0_ms = 0;
-        seg.t1_ms = static_cast<int64_t>(n_samples[b]) * 1000
-                  / static_cast<int64_t>(cm->hparams.fe_sample_rate);
+        seg.t1_ms = static_cast<int64_t>(n_samples[b]) * 1000 / static_cast<int64_t>(cm->hparams.fe_sample_rate);
         rs.segments.push_back(std::move(seg));
         rs.t_mel_us    = mel_us / valid_count;
         rs.t_encode_us = enc_us / valid_count;
@@ -2196,13 +2632,14 @@ extern const Arch arch = {
     /* .accepts_ext_kind = */ accepts_ext_kind,
 };
 
-} // namespace transcribe::voxtral_realtime
+}  // namespace transcribe::voxtral_realtime
 
 // Public streaming-extension initializer (C ABI). Mirrors the per-family
 // pattern used by parakeet / moonshine_streaming.
-extern "C" void transcribe_voxtral_realtime_stream_ext_init(
-    struct transcribe_voxtral_realtime_stream_ext * p) {
-    if (p == nullptr) return;
+extern "C" void transcribe_voxtral_realtime_stream_ext_init(struct transcribe_voxtral_realtime_stream_ext * p) {
+    if (p == nullptr) {
+        return;
+    }
     std::memset(p, 0, sizeof(*p));
     p->ext.size               = sizeof(*p);
     p->ext.kind               = TRANSCRIBE_EXT_KIND_VOXTRAL_REALTIME_STREAM;
diff --git a/src/arch/voxtral_realtime/voxtral_realtime.h b/src/arch/voxtral_realtime/voxtral_realtime.h
index 5bff35b8..68a200d4 100644
--- a/src/arch/voxtral_realtime/voxtral_realtime.h
+++ b/src/arch/voxtral_realtime/voxtral_realtime.h
@@ -7,16 +7,15 @@
 #pragma once
 
 #include "causal_lm/causal_lm.h"
+#include "ggml-backend.h"
+#include "ggml.h"
 #include "transcribe-backend.h"
-#include "transcribe-session.h"
 #include "transcribe-mel.h"
 #include "transcribe-model.h"
+#include "transcribe-session.h"
 #include "transcribe-tokenizer.h"
 #include "weights.h"
 
-#include "ggml.h"
-#include "ggml-backend.h"
-
 #include <cstdint>
 #include <optional>
 #include <string>
@@ -37,20 +36,20 @@ void apply_family_invariants(transcribe_model & model);
 //   [BOS] [STREAMING_PAD] * (n_left_pad + num_delay_tokens)
 // with the projector audio embeddings ADDED onto every position.
 struct PromptSpecials {
-    int32_t bos          = -1;
+    int32_t bos           = -1;
     int32_t streaming_pad = -1;  // additive-fusion placeholder (id 32)
-    int32_t eos          = -1;
-    int32_t n_left_pad   = 32;   // streaming_n_left_pad_tokens (tekken)
+    int32_t eos           = -1;
+    int32_t n_left_pad    = 32;  // streaming_n_left_pad_tokens (tekken)
 };
 
 struct Model final : public transcribe_model {
-    Tokenizer tok;
-    HParams   hparams;
-    Weights   weights;
+    Tokenizer      tok;
+    HParams        hparams;
+    Weights        weights;
     ggml_context * ctx_meta = nullptr;
 
-    transcribe::BackendPlan       plan;
-    ggml_backend_buffer_t         backend_buffer = nullptr;
+    transcribe::BackendPlan                    plan;
+    ggml_backend_buffer_t                      backend_buffer = nullptr;
     transcribe::causal_lm::PackedGateUpHandles packed_gate_up;
 
     std::optional<transcribe::MelFrontend> mel;
@@ -73,20 +72,20 @@ struct Session final : public transcribe_session {
     // slab per utterance, reused across calls, re-allocated only when the batch
     // size or context window grows. Mirrors VoxtralSession.
     transcribe::causal_lm::KvCache kv_cache_batch;
-    int kv_batch_cap   = 0;  // slabs allocated (== n_batch of last alloc)
-    int kv_batch_n_ctx = 0;  // n_ctx of last alloc
+    int                            kv_batch_cap   = 0;  // slabs allocated (== n_batch of last alloc)
+    int                            kv_batch_n_ctx = 0;  // n_ctx of last alloc
 
     std::vector<float> mel_buf;
-    std::vector<float> enc_host;   // projector output (audio embeds), [hidden, n_audio]
+    std::vector<float> enc_host;  // projector output (audio embeds), [hidden, n_audio]
 
     // Per-layer adaptive-norm FFN scale (1 + ada(t_cond)), precomputed for the
     // active num_delay_tokens. One [dec_hidden] tensor per decoder layer, all
     // packed into ada_scale_all [dec_hidden, n_layers] in ada_buffer.
-    ggml_context *        ada_ctx    = nullptr;
-    ggml_backend_buffer_t ada_buffer = nullptr;
-    ggml_tensor *         ada_scale_all = nullptr;     // [dec_hidden, n_layers]
-    std::vector<ggml_tensor *> ada_scale;              // per-layer views
-    int ada_num_delay = -1;
+    ggml_context *             ada_ctx       = nullptr;
+    ggml_backend_buffer_t      ada_buffer    = nullptr;
+    ggml_tensor *              ada_scale_all = nullptr;  // [dec_hidden, n_layers]
+    std::vector<ggml_tensor *> ada_scale;                // per-layer views
+    int                        ada_num_delay = -1;
 
     bool encoder_use_flash = false;
     bool decoder_use_flash = true;
@@ -96,34 +95,34 @@ struct Session final : public transcribe_session {
     // an encoder KV cache (StaticCache, sliding_window=750) under a windowed
     // mask, each frame processed exactly once. The decoder prefills the prompt
     // once then steps one token per audio frame against its persistent KV.
-    std::vector<float> stream_pcm;                  // accumulated raw PCM (no pad)
-    int                stream_num_delay = -1;       // active num_delay_tokens
-    int                stream_min_decode_ms = -1;   // partial-decode throttle
+    std::vector<float> stream_pcm;                       // accumulated raw PCM (no pad)
+    int                stream_num_delay           = -1;  // active num_delay_tokens
+    int                stream_min_decode_ms       = -1;  // partial-decode throttle
     int64_t            stream_last_decode_samples = 0;
 
-    transcribe::causal_lm::KvCache enc_kv;           // encoder StaticCache (ring)
-    int     stream_enc_slot     = 0;                // ring write head (slot units)
-    int     stream_enc_abs_base = 0;                // absolute frame index of slot 0
-    int     stream_n_enc_committed = 0;             // enc frames committed (absolute)
+    transcribe::causal_lm::KvCache enc_kv;                      // encoder StaticCache (ring)
+    int                            stream_enc_slot        = 0;  // ring write head (slot units)
+    int                            stream_enc_abs_base    = 0;  // absolute frame index of slot 0
+    int                            stream_n_enc_committed = 0;  // enc frames committed (absolute)
     // Conv-stem padding cache: feed only new mel frames, carrying the conv
     // left-context. conv0 (k3 s1) ← last 2 mel frames; conv1 (k3 s2) ← last 1
     // conv0-output frame. Zeros on the first chunk == whole-buffer left-pad.
-    std::vector<float> stream_conv0_cache;          // [n_mels, 2] (mel-major, 2 frames)
-    std::vector<float> stream_conv1_cache;          // [d_model, 1] (last conv0-out frame)
-    int     stream_n_mel_committed = 0;             // mel frames fed through the conv stem
+    std::vector<float>             stream_conv0_cache;          // [n_mels, 2] (mel-major, 2 frames)
+    std::vector<float>             stream_conv1_cache;          // [d_model, 1] (last conv0-out frame)
+    int                            stream_n_mel_committed = 0;  // mel frames fed through the conv stem
     // Frontend memory bounding (match the reference's bounded streaming): drop PCM
     // and audio-embeds that no future feed/step can read. Offsets keep absolute
     // indexing correct across the physical drops (batched to stay amortized O(1)).
-    int64_t stream_pcm_drop      = 0;               // samples erased from stream_pcm front
-    int     stream_audio_base    = 0;               // absolute index of stream_audio_embeds[0]
-    std::vector<float> stream_audio_embeds;         // [dec_hidden, n_tok_ready]
-    int     stream_n_tok_ready    = 0;              // audio embeds computed
-    bool    stream_prompt_done    = false;          // decoder prompt prefilled
-    int     stream_dec_pos        = 0;              // next decoder position
-    int32_t stream_next_tok       = 0;              // last emitted token (step input)
-    bool    stream_eos            = false;
-    std::vector<int32_t> stream_generated;          // emitted token ids
-    int     stream_n_audio_clamp  = -1;             // ceil(mel_frames/8) decode cap
+    int64_t                        stream_pcm_drop        = 0;  // samples erased from stream_pcm front
+    int                            stream_audio_base      = 0;  // absolute index of stream_audio_embeds[0]
+    std::vector<float>             stream_audio_embeds;         // [dec_hidden, n_tok_ready]
+    int                            stream_n_tok_ready = 0;      // audio embeds computed
+    bool                           stream_prompt_done = false;  // decoder prompt prefilled
+    int                            stream_dec_pos     = 0;      // next decoder position
+    int32_t                        stream_next_tok    = 0;      // last emitted token (step input)
+    bool                           stream_eos         = false;
+    std::vector<int32_t>           stream_generated;            // emitted token ids
+    int                            stream_n_audio_clamp = -1;   // ceil(mel_frames/8) decode cap
 
     // Numerical-validation captures (only when TRANSCRIBE_DUMP_DIR is set):
     // stream.logits_raw (first generated step) and .gen8 (ninth step).
@@ -132,14 +131,14 @@ struct Session final : public transcribe_session {
 
     // Per-component wall-time accumulators (us), printed at finalize when
     // TRANSCRIBE_VOXTRAL_REALTIME_STREAM_TIMING is set. Diagnostic only.
-    int64_t stream_t_mel_us = 0;   // CPU log-mel (windowed compute)
-    int64_t stream_t_conv_us = 0;  // conv stem (cached chunk graph)
-    int64_t stream_t_enc_us = 0;   // encoder ring transformer (build + alloc + compute)
+    int64_t stream_t_mel_us         = 0;  // CPU log-mel (windowed compute)
+    int64_t stream_t_conv_us        = 0;  // conv stem (cached chunk graph)
+    int64_t stream_t_enc_us         = 0;  // encoder ring transformer (build + alloc + compute)
     int64_t stream_t_enc_compute_us = 0;  // ... of which pure graph_compute (rest = per-feed overhead)
-    int64_t stream_t_dec_us = 0;   // decoder prefill + step loop
+    int64_t stream_t_dec_us         = 0;  // decoder prefill + step loop
 
     Session() = default;
     ~Session() override;
 };
 
-} // namespace transcribe::voxtral_realtime
+}  // namespace transcribe::voxtral_realtime
diff --git a/src/arch/voxtral_realtime/weights.cpp b/src/arch/voxtral_realtime/weights.cpp
index f1633d51..33a64a1a 100644
--- a/src/arch/voxtral_realtime/weights.cpp
+++ b/src/arch/voxtral_realtime/weights.cpp
@@ -8,12 +8,11 @@
 
 #include "weights.h"
 
-#include "transcribe-meta.h"
-#include "transcribe-weights-util.h"
-#include "transcribe-log.h"
-
 #include "ggml.h"
 #include "gguf.h"
+#include "transcribe-log.h"
+#include "transcribe-meta.h"
+#include "transcribe-weights-util.h"
 
 #include <cstdio>
 
@@ -24,55 +23,163 @@ constexpr const char * kFamilyTag = "voxtral_realtime";
 }
 
 transcribe_status read_hparams(const gguf_context * gguf, HParams & hp) {
-    if (gguf == nullptr) return TRANSCRIBE_ERR_INVALID_ARG;
+    if (gguf == nullptr) {
+        return TRANSCRIBE_ERR_INVALID_ARG;
+    }
     constexpr const char * T = kFamilyTag;
 
     // Audio encoder.
-    if (auto st = read_required_u32_kv(gguf, "stt.voxtral_realtime.encoder.n_layers", T, hp.enc_n_layers); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.voxtral_realtime.encoder.d_model", T, hp.enc_d_model); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.voxtral_realtime.encoder.n_heads", T, hp.enc_n_heads); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.voxtral_realtime.encoder.n_kv_heads", T, hp.enc_n_kv_heads); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.voxtral_realtime.encoder.head_dim", T, hp.enc_head_dim); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.voxtral_realtime.encoder.ffn_dim", T, hp.enc_ffn_dim); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.voxtral_realtime.encoder.num_mel_bins", T, hp.enc_num_mel_bins); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.voxtral_realtime.encoder.max_position_embeddings", T, hp.enc_max_pos); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.voxtral_realtime.encoder.sliding_window", T, hp.enc_sliding_window); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf, "stt.voxtral_realtime.encoder.rope_theta", T, hp.enc_rope_theta); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf, "stt.voxtral_realtime.encoder.rms_norm_eps", T, hp.enc_rms_norm_eps); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.voxtral_realtime.encoder.hidden_act", T, hp.enc_hidden_act); st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_u32_kv(gguf, "stt.voxtral_realtime.encoder.n_layers", T, hp.enc_n_layers);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.voxtral_realtime.encoder.d_model", T, hp.enc_d_model);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.voxtral_realtime.encoder.n_heads", T, hp.enc_n_heads);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.voxtral_realtime.encoder.n_kv_heads", T, hp.enc_n_kv_heads);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.voxtral_realtime.encoder.head_dim", T, hp.enc_head_dim);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.voxtral_realtime.encoder.ffn_dim", T, hp.enc_ffn_dim);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.voxtral_realtime.encoder.num_mel_bins", T, hp.enc_num_mel_bins);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.voxtral_realtime.encoder.max_position_embeddings", T, hp.enc_max_pos);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.voxtral_realtime.encoder.sliding_window", T, hp.enc_sliding_window);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.voxtral_realtime.encoder.rope_theta", T, hp.enc_rope_theta);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.voxtral_realtime.encoder.rms_norm_eps", T, hp.enc_rms_norm_eps);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_string_kv(gguf, "stt.voxtral_realtime.encoder.hidden_act", T, hp.enc_hidden_act);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Projector.
-    if (auto st = read_required_u32_kv(gguf, "stt.voxtral_realtime.projector.downsample_factor", T, hp.proj_downsample); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.voxtral_realtime.projector.input_dim", T, hp.proj_in); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.voxtral_realtime.projector.hidden_act", T, hp.proj_hidden_act); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.voxtral_realtime.projector.audio_length_per_tok", T, hp.audio_length_per_tok); st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_u32_kv(gguf, "stt.voxtral_realtime.projector.downsample_factor", T, hp.proj_downsample);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.voxtral_realtime.projector.input_dim", T, hp.proj_in);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_string_kv(gguf, "stt.voxtral_realtime.projector.hidden_act", T, hp.proj_hidden_act);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.voxtral_realtime.projector.audio_length_per_tok", T,
+                                       hp.audio_length_per_tok);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Text LM.
-    if (auto st = read_required_u32_kv(gguf, "stt.voxtral_realtime.decoder.n_layers", T, hp.dec_n_layers); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.voxtral_realtime.decoder.hidden_size", T, hp.dec_hidden); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.voxtral_realtime.decoder.intermediate_size", T, hp.dec_intermediate); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.voxtral_realtime.decoder.n_heads", T, hp.dec_n_heads); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.voxtral_realtime.decoder.n_kv_heads", T, hp.dec_n_kv_heads); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.voxtral_realtime.decoder.head_dim", T, hp.dec_head_dim); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.voxtral_realtime.decoder.hidden_act", T, hp.dec_hidden_act); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf, "stt.voxtral_realtime.decoder.rms_norm_eps", T, hp.dec_rms_norm_eps); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf, "stt.voxtral_realtime.decoder.rope_theta", T, hp.dec_rope_theta); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.voxtral_realtime.decoder.sliding_window", T, hp.dec_sliding_window); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.voxtral_realtime.decoder.max_position_embeddings", T, hp.dec_max_position); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_bool_kv(gguf, "stt.voxtral_realtime.decoder.tie_word_embeddings", T, true, hp.dec_tie_word_embeddings); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.voxtral_realtime.decoder.vocab_size", T, hp.dec_vocab_size); st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_u32_kv(gguf, "stt.voxtral_realtime.decoder.n_layers", T, hp.dec_n_layers);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.voxtral_realtime.decoder.hidden_size", T, hp.dec_hidden);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.voxtral_realtime.decoder.intermediate_size", T, hp.dec_intermediate);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.voxtral_realtime.decoder.n_heads", T, hp.dec_n_heads);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.voxtral_realtime.decoder.n_kv_heads", T, hp.dec_n_kv_heads);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.voxtral_realtime.decoder.head_dim", T, hp.dec_head_dim);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_string_kv(gguf, "stt.voxtral_realtime.decoder.hidden_act", T, hp.dec_hidden_act);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.voxtral_realtime.decoder.rms_norm_eps", T, hp.dec_rms_norm_eps);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.voxtral_realtime.decoder.rope_theta", T, hp.dec_rope_theta);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.voxtral_realtime.decoder.sliding_window", T, hp.dec_sliding_window);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st =
+            read_required_u32_kv(gguf, "stt.voxtral_realtime.decoder.max_position_embeddings", T, hp.dec_max_position);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_bool_kv(gguf, "stt.voxtral_realtime.decoder.tie_word_embeddings", T, true,
+                                        hp.dec_tie_word_embeddings);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.voxtral_realtime.decoder.vocab_size", T, hp.dec_vocab_size);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Time conditioning.
-    if (auto st = read_required_u32_kv(gguf, "stt.voxtral_realtime.time.default_num_delay_tokens", T, hp.default_num_delay_tokens); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf, "stt.voxtral_realtime.time.embed_theta", T, hp.time_embed_theta); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.voxtral_realtime.time.embed_dim", T, hp.time_embed_dim); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.voxtral_realtime.time.ada_hidden", T, hp.ada_hidden); st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_u32_kv(gguf, "stt.voxtral_realtime.time.default_num_delay_tokens", T,
+                                       hp.default_num_delay_tokens);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.voxtral_realtime.time.embed_theta", T, hp.time_embed_theta);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.voxtral_realtime.time.embed_dim", T, hp.time_embed_dim);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.voxtral_realtime.time.ada_hidden", T, hp.ada_hidden);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     {
         uint32_t spt = 32;
         switch (read_uint32_kv(gguf, "stt.voxtral_realtime.streaming_pad_token_id", spt)) {
-            case KvResult::Ok:     hp.streaming_pad_token_id = static_cast<int32_t>(spt); break;
-            case KvResult::Absent: break;
+            case KvResult::Ok:
+                hp.streaming_pad_token_id = static_cast<int32_t>(spt);
+                break;
+            case KvResult::Absent:
+                break;
             case KvResult::BadType:
                 log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral_realtime: streaming_pad_token_id wrong type");
                 return TRANSCRIBE_ERR_GGUF;
@@ -80,27 +187,61 @@ transcribe_status read_hparams(const gguf_context * gguf, HParams & hp) {
     }
 
     // Frontend.
-    if (auto st = read_required_string_kv(gguf, "stt.frontend.type", T, hp.fe_type); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.frontend.num_mels", T, hp.fe_num_mels); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.frontend.sample_rate", T, hp.fe_sample_rate); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.frontend.n_fft", T, hp.fe_n_fft); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.frontend.win_length", T, hp.fe_win_length); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.frontend.hop_length", T, hp.fe_hop_length); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.frontend.window", T, hp.fe_window); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.frontend.normalize", T, hp.fe_normalize); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf, "stt.frontend.global_log_mel_max", T, hp.fe_global_log_mel_max); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf, "stt.frontend.dither", T, hp.fe_dither); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf, "stt.frontend.pre_emphasis", T, hp.fe_pre_emphasis); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf, "stt.frontend.f_min", T, hp.fe_f_min); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_f32_kv(gguf, "stt.frontend.f_max", T, hp.fe_f_max); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_string_kv(gguf, "stt.frontend.pad_mode", T, "reflect", hp.fe_pad_mode); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_string_kv(gguf, "stt.frontend.mel_norm", T, "slaney", hp.fe_mel_norm); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_bool_kv(gguf, "stt.frontend.center", T, true, hp.fe_center); st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_string_kv(gguf, "stt.frontend.type", T, hp.fe_type); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.num_mels", T, hp.fe_num_mels); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.sample_rate", T, hp.fe_sample_rate); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.n_fft", T, hp.fe_n_fft); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.win_length", T, hp.fe_win_length); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.hop_length", T, hp.fe_hop_length); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_string_kv(gguf, "stt.frontend.window", T, hp.fe_window); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_string_kv(gguf, "stt.frontend.normalize", T, hp.fe_normalize); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.frontend.global_log_mel_max", T, hp.fe_global_log_mel_max);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.frontend.dither", T, hp.fe_dither); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.frontend.pre_emphasis", T, hp.fe_pre_emphasis); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.frontend.f_min", T, hp.fe_f_min); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_f32_kv(gguf, "stt.frontend.f_max", T, hp.fe_f_max); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_string_kv(gguf, "stt.frontend.pad_mode", T, "reflect", hp.fe_pad_mode);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_string_kv(gguf, "stt.frontend.mel_norm", T, "slaney", hp.fe_mel_norm);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_bool_kv(gguf, "stt.frontend.center", T, true, hp.fe_center); st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Cross-field invariants.
-    if (hp.enc_n_layers <= 0 || hp.enc_d_model <= 0 || hp.enc_n_heads <= 0 ||
-        hp.enc_head_dim <= 0 || hp.enc_ffn_dim <= 0 || hp.enc_num_mel_bins <= 0 ||
-        hp.enc_sliding_window <= 0) {
+    if (hp.enc_n_layers <= 0 || hp.enc_d_model <= 0 || hp.enc_n_heads <= 0 || hp.enc_head_dim <= 0 ||
+        hp.enc_ffn_dim <= 0 || hp.enc_num_mel_bins <= 0 || hp.enc_sliding_window <= 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral_realtime: encoder hparams must be positive");
         return TRANSCRIBE_ERR_GGUF;
     }
@@ -110,17 +251,17 @@ transcribe_status read_hparams(const gguf_context * gguf, HParams & hp) {
     }
     if (hp.proj_in != hp.enc_d_model * hp.proj_downsample) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral_realtime: projector input_dim (%d) != enc_d_model*downsample (%d)",
-                     hp.proj_in, hp.enc_d_model * hp.proj_downsample);
+                hp.proj_in, hp.enc_d_model * hp.proj_downsample);
         return TRANSCRIBE_ERR_GGUF;
     }
-    if (hp.dec_n_layers <= 0 || hp.dec_hidden <= 0 || hp.dec_n_heads <= 0 ||
-        hp.dec_n_kv_heads <= 0 || hp.dec_head_dim <= 0 || hp.dec_intermediate <= 0) {
+    if (hp.dec_n_layers <= 0 || hp.dec_hidden <= 0 || hp.dec_n_heads <= 0 || hp.dec_n_kv_heads <= 0 ||
+        hp.dec_head_dim <= 0 || hp.dec_intermediate <= 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral_realtime: decoder hparams must be positive");
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.dec_n_heads % hp.dec_n_kv_heads != 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral_realtime: n_heads (%d) not divisible by n_kv_heads (%d)",
-                     hp.dec_n_heads, hp.dec_n_kv_heads);
+                hp.dec_n_heads, hp.dec_n_kv_heads);
         return TRANSCRIBE_ERR_GGUF;
     }
     if (!hp.dec_tie_word_embeddings) {
@@ -128,20 +269,23 @@ transcribe_status read_hparams(const gguf_context * gguf, HParams & hp) {
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.dec_hidden_act != "silu" && hp.dec_hidden_act != "swish") {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral_realtime: unsupported decoder hidden_act \"%s\"", hp.dec_hidden_act.c_str());
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral_realtime: unsupported decoder hidden_act \"%s\"",
+                hp.dec_hidden_act.c_str());
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.enc_hidden_act != "silu" && hp.enc_hidden_act != "swish") {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral_realtime: unsupported encoder hidden_act \"%s\"", hp.enc_hidden_act.c_str());
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral_realtime: unsupported encoder hidden_act \"%s\"",
+                hp.enc_hidden_act.c_str());
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.proj_hidden_act != "gelu") {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral_realtime: unsupported projector hidden_act \"%s\"", hp.proj_hidden_act.c_str());
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral_realtime: unsupported projector hidden_act \"%s\"",
+                hp.proj_hidden_act.c_str());
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.time_embed_dim != hp.dec_hidden) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral_realtime: time_embed_dim (%d) != dec_hidden (%d)",
-                     hp.time_embed_dim, hp.dec_hidden);
+                hp.time_embed_dim, hp.dec_hidden);
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.fe_type != "mel") {
@@ -160,36 +304,39 @@ namespace {
 using transcribe::weights::lname;
 constexpr const char * kTag = kFamilyTag;
 
-#define GET_F32(slot, name, ...) \
-    do { \
-        ggml_tensor * _t = transcribe::weights::find_tensor( \
-            ctx_meta, (name), {GGML_TYPE_F32}, {__VA_ARGS__}, kTag); \
-        if (_t == nullptr) return TRANSCRIBE_ERR_GGUF; \
-        (slot) = _t; \
+#define GET_F32(slot, name, ...)                                                                          \
+    do {                                                                                                  \
+        ggml_tensor * _t =                                                                                \
+            transcribe::weights::find_tensor(ctx_meta, (name), { GGML_TYPE_F32 }, { __VA_ARGS__ }, kTag); \
+        if (_t == nullptr)                                                                                \
+            return TRANSCRIBE_ERR_GGUF;                                                                   \
+        (slot) = _t;                                                                                      \
     } while (0)
 
-#define GET_CONV(slot, name, ...) \
-    do { \
-        ggml_tensor * _t = transcribe::weights::find_tensor( \
-            ctx_meta, (name), {TRANSCRIBE_QUANT_CONV_TYPES}, {__VA_ARGS__}, kTag); \
-        if (_t == nullptr) return TRANSCRIBE_ERR_GGUF; \
-        (slot) = _t; \
+#define GET_CONV(slot, name, ...)                                                                              \
+    do {                                                                                                       \
+        ggml_tensor * _t = transcribe::weights::find_tensor(ctx_meta, (name), { TRANSCRIBE_QUANT_CONV_TYPES }, \
+                                                            { __VA_ARGS__ }, kTag);                            \
+        if (_t == nullptr)                                                                                     \
+            return TRANSCRIBE_ERR_GGUF;                                                                        \
+        (slot) = _t;                                                                                           \
     } while (0)
 
-#define GET_LIN(slot, name, ...) \
-    do { \
-        ggml_tensor * _t = transcribe::weights::find_tensor( \
-            ctx_meta, (name), {TRANSCRIBE_QUANT_LINEAR_TYPES}, {__VA_ARGS__}, kTag); \
-        if (_t == nullptr) return TRANSCRIBE_ERR_GGUF; \
-        (slot) = _t; \
+#define GET_LIN(slot, name, ...)                                                                                 \
+    do {                                                                                                         \
+        ggml_tensor * _t = transcribe::weights::find_tensor(ctx_meta, (name), { TRANSCRIBE_QUANT_LINEAR_TYPES }, \
+                                                            { __VA_ARGS__ }, kTag);                              \
+        if (_t == nullptr)                                                                                       \
+            return TRANSCRIBE_ERR_GGUF;                                                                          \
+        (slot) = _t;                                                                                             \
     } while (0)
 
-} // namespace
+}  // namespace
 
-transcribe_status build_weights(ggml_context *  ctx_meta,
-                                const HParams & hp,
-                                Weights &       weights) {
-    if (ctx_meta == nullptr) return TRANSCRIBE_ERR_INVALID_ARG;
+transcribe_status build_weights(ggml_context * ctx_meta, const HParams & hp, Weights & weights) {
+    if (ctx_meta == nullptr) {
+        return TRANSCRIBE_ERR_INVALID_ARG;
+    }
 
     const int64_t d_model = hp.enc_d_model;
     const int64_t n_mel   = hp.enc_num_mel_bins;
@@ -197,29 +344,29 @@ transcribe_status build_weights(ggml_context *  ctx_meta,
     const int64_t enc_qkv = static_cast<int64_t>(hp.enc_n_heads) * hp.enc_head_dim;
 
     // ----- encoder conv stem (causal) -----
-    GET_CONV(weights.enc_stem.conv0_w, "enc.conv.0.weight", 3, n_mel,   d_model);
-    GET_F32 (weights.enc_stem.conv0_b, "enc.conv.0.bias",   d_model);
+    GET_CONV(weights.enc_stem.conv0_w, "enc.conv.0.weight", 3, n_mel, d_model);
+    GET_F32(weights.enc_stem.conv0_b, "enc.conv.0.bias", d_model);
     GET_CONV(weights.enc_stem.conv1_w, "enc.conv.1.weight", 3, d_model, d_model);
-    GET_F32 (weights.enc_stem.conv1_b, "enc.conv.1.bias",   d_model);
-    GET_F32 (weights.enc_stem.final_norm_w, "enc.final_norm.weight", d_model);
+    GET_F32(weights.enc_stem.conv1_b, "enc.conv.1.bias", d_model);
+    GET_F32(weights.enc_stem.final_norm_w, "enc.final_norm.weight", d_model);
 
     // ----- encoder blocks (q/v/out bias, k no bias; SwiGLU, down bias) -----
     weights.enc_blocks.assign(hp.enc_n_layers, EncBlock{});
     for (int i = 0; i < hp.enc_n_layers; ++i) {
         auto & b = weights.enc_blocks[i];
         GET_F32(b.norm_attn_w, lname("enc.blocks.%d.norm_attn.weight", i), d_model);
-        GET_LIN(b.attn_q_w,    lname("enc.blocks.%d.attn.q.weight",    i), d_model, enc_qkv);
-        GET_F32(b.attn_q_b,    lname("enc.blocks.%d.attn.q.bias",      i), enc_qkv);
-        GET_LIN(b.attn_k_w,    lname("enc.blocks.%d.attn.k.weight",    i), d_model, enc_qkv);
-        GET_LIN(b.attn_v_w,    lname("enc.blocks.%d.attn.v.weight",    i), d_model, enc_qkv);
-        GET_F32(b.attn_v_b,    lname("enc.blocks.%d.attn.v.bias",      i), enc_qkv);
-        GET_LIN(b.attn_out_w,  lname("enc.blocks.%d.attn.out.weight",  i), enc_qkv, d_model);
-        GET_F32(b.attn_out_b,  lname("enc.blocks.%d.attn.out.bias",    i), d_model);
-        GET_F32(b.norm_ffn_w,  lname("enc.blocks.%d.norm_ffn.weight",  i), d_model);
-        GET_LIN(b.ffn_gate_w,  lname("enc.blocks.%d.ffn.gate.weight",  i), d_model, enc_ff);
-        GET_LIN(b.ffn_up_w,    lname("enc.blocks.%d.ffn.up.weight",    i), d_model, enc_ff);
-        GET_LIN(b.ffn_down_w,  lname("enc.blocks.%d.ffn.down.weight",  i), enc_ff,  d_model);
-        GET_F32(b.ffn_down_b,  lname("enc.blocks.%d.ffn.down.bias",    i), d_model);
+        GET_LIN(b.attn_q_w, lname("enc.blocks.%d.attn.q.weight", i), d_model, enc_qkv);
+        GET_F32(b.attn_q_b, lname("enc.blocks.%d.attn.q.bias", i), enc_qkv);
+        GET_LIN(b.attn_k_w, lname("enc.blocks.%d.attn.k.weight", i), d_model, enc_qkv);
+        GET_LIN(b.attn_v_w, lname("enc.blocks.%d.attn.v.weight", i), d_model, enc_qkv);
+        GET_F32(b.attn_v_b, lname("enc.blocks.%d.attn.v.bias", i), enc_qkv);
+        GET_LIN(b.attn_out_w, lname("enc.blocks.%d.attn.out.weight", i), enc_qkv, d_model);
+        GET_F32(b.attn_out_b, lname("enc.blocks.%d.attn.out.bias", i), d_model);
+        GET_F32(b.norm_ffn_w, lname("enc.blocks.%d.norm_ffn.weight", i), d_model);
+        GET_LIN(b.ffn_gate_w, lname("enc.blocks.%d.ffn.gate.weight", i), d_model, enc_ff);
+        GET_LIN(b.ffn_up_w, lname("enc.blocks.%d.ffn.up.weight", i), d_model, enc_ff);
+        GET_LIN(b.ffn_down_w, lname("enc.blocks.%d.ffn.down.weight", i), enc_ff, d_model);
+        GET_F32(b.ffn_down_b, lname("enc.blocks.%d.ffn.down.bias", i), d_model);
         if (b.ffn_gate_w->type != b.ffn_up_w->type) {
             log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "voxtral_realtime: enc ffn gate/up dtype mismatch at layer %d", i);
             return TRANSCRIBE_ERR_GGUF;
@@ -230,7 +377,7 @@ transcribe_status build_weights(ggml_context *  ctx_meta,
     const int64_t proj_in = hp.proj_in;
     const int64_t dec_h   = hp.dec_hidden;
     GET_LIN(weights.proj.linear_1_w, "proj.linear_1.weight", proj_in, dec_h);
-    GET_LIN(weights.proj.linear_2_w, "proj.linear_2.weight", dec_h,   dec_h);
+    GET_LIN(weights.proj.linear_2_w, "proj.linear_2.weight", dec_h, dec_h);
 
     // ----- text LM: tied embedding -----
     GET_LIN(weights.dec_embed.token_w, "dec.token_embd.weight", dec_h, hp.dec_vocab_size);
@@ -240,7 +387,7 @@ transcribe_status build_weights(ggml_context *  ctx_meta,
     const int64_t dec_nkv = hp.dec_n_kv_heads;
     const int64_t dec_hd  = hp.dec_head_dim;
     const int64_t dec_im  = hp.dec_intermediate;
-    const int64_t q_out   = dec_nh  * dec_hd;
+    const int64_t q_out   = dec_nh * dec_hd;
     const int64_t kv_out  = dec_nkv * dec_hd;
     const int64_t ada_h   = hp.ada_hidden;
 
@@ -248,14 +395,14 @@ transcribe_status build_weights(ggml_context *  ctx_meta,
     for (int i = 0; i < hp.dec_n_layers; ++i) {
         auto & b = weights.dec_blocks[i];
         GET_F32(b.norm_attn_w, lname("dec.blocks.%d.norm_attn.weight", i), dec_h);
-        GET_F32(b.norm_ffn_w,  lname("dec.blocks.%d.norm_ffn.weight",  i), dec_h);
-        GET_LIN(b.attn_q_w,    lname("dec.blocks.%d.attn.q.weight", i), dec_h, q_out);
-        GET_LIN(b.attn_k_w,    lname("dec.blocks.%d.attn.k.weight", i), dec_h, kv_out);
-        GET_LIN(b.attn_v_w,    lname("dec.blocks.%d.attn.v.weight", i), dec_h, kv_out);
-        GET_LIN(b.attn_o_w,    lname("dec.blocks.%d.attn.o.weight", i), q_out, dec_h);
-        GET_LIN(b.ffn_gate_w,  lname("dec.blocks.%d.ffn.gate.weight", i), dec_h, dec_im);
-        GET_LIN(b.ffn_up_w,    lname("dec.blocks.%d.ffn.up.weight",   i), dec_h, dec_im);
-        GET_LIN(b.ffn_down_w,  lname("dec.blocks.%d.ffn.down.weight", i), dec_im, dec_h);
+        GET_F32(b.norm_ffn_w, lname("dec.blocks.%d.norm_ffn.weight", i), dec_h);
+        GET_LIN(b.attn_q_w, lname("dec.blocks.%d.attn.q.weight", i), dec_h, q_out);
+        GET_LIN(b.attn_k_w, lname("dec.blocks.%d.attn.k.weight", i), dec_h, kv_out);
+        GET_LIN(b.attn_v_w, lname("dec.blocks.%d.attn.v.weight", i), dec_h, kv_out);
+        GET_LIN(b.attn_o_w, lname("dec.blocks.%d.attn.o.weight", i), q_out, dec_h);
+        GET_LIN(b.ffn_gate_w, lname("dec.blocks.%d.ffn.gate.weight", i), dec_h, dec_im);
+        GET_LIN(b.ffn_up_w, lname("dec.blocks.%d.ffn.up.weight", i), dec_h, dec_im);
+        GET_LIN(b.ffn_down_w, lname("dec.blocks.%d.ffn.down.weight", i), dec_im, dec_h);
         GET_LIN(b.ada_linear_1_w, lname("dec.blocks.%d.ada.linear_1.weight", i), dec_h, ada_h);
         GET_LIN(b.ada_linear_2_w, lname("dec.blocks.%d.ada.linear_2.weight", i), ada_h, dec_h);
         if (b.ffn_gate_w->type != b.ffn_up_w->type) {
@@ -273,4 +420,4 @@ transcribe_status build_weights(ggml_context *  ctx_meta,
     return TRANSCRIBE_OK;
 }
 
-} // namespace transcribe::voxtral_realtime
+}  // namespace transcribe::voxtral_realtime
diff --git a/src/arch/voxtral_realtime/weights.h b/src/arch/voxtral_realtime/weights.h
index 838b6022..4c18960f 100644
--- a/src/arch/voxtral_realtime/weights.h
+++ b/src/arch/voxtral_realtime/weights.h
@@ -37,42 +37,42 @@ namespace transcribe::voxtral_realtime {
 
 struct HParams {
     // Audio encoder (causal RoPE, sliding-window).
-    int32_t enc_n_layers       = 0;
-    int32_t enc_d_model        = 0;
-    int32_t enc_n_heads        = 0;
-    int32_t enc_n_kv_heads     = 0;   // == n_heads (full MHA)
-    int32_t enc_head_dim       = 0;   // 64
-    int32_t enc_ffn_dim        = 0;   // 5120
-    int32_t enc_num_mel_bins   = 0;   // 128
-    int32_t enc_max_pos        = 0;   // 1500
-    int32_t enc_sliding_window = 0;   // 750
-    float   enc_rope_theta     = 0.0f;
-    float   enc_rms_norm_eps   = 0.0f;
-    std::string enc_hidden_act;       // "silu" (MLP)
+    int32_t     enc_n_layers       = 0;
+    int32_t     enc_d_model        = 0;
+    int32_t     enc_n_heads        = 0;
+    int32_t     enc_n_kv_heads     = 0;  // == n_heads (full MHA)
+    int32_t     enc_head_dim       = 0;  // 64
+    int32_t     enc_ffn_dim        = 0;  // 5120
+    int32_t     enc_num_mel_bins   = 0;  // 128
+    int32_t     enc_max_pos        = 0;  // 1500
+    int32_t     enc_sliding_window = 0;  // 750
+    float       enc_rope_theta     = 0.0f;
+    float       enc_rms_norm_eps   = 0.0f;
+    std::string enc_hidden_act;  // "silu" (MLP)
 
     // Projector (multi-modal).
-    int32_t proj_downsample        = 0;  // 4
-    int32_t proj_in                = 0;  // enc_d_model * downsample (5120)
-    int32_t audio_length_per_tok   = 0;  // 8 mel frames per audio token
-    std::string proj_hidden_act;         // "gelu"
+    int32_t     proj_downsample      = 0;  // 4
+    int32_t     proj_in              = 0;  // enc_d_model * downsample (5120)
+    int32_t     audio_length_per_tok = 0;  // 8 mel frames per audio token
+    std::string proj_hidden_act;           // "gelu"
 
     // Text LM (Ministral).
-    int32_t dec_n_layers       = 0;   // 26
-    int32_t dec_hidden         = 0;   // 3072
-    int32_t dec_intermediate   = 0;   // 9216
-    int32_t dec_n_heads        = 0;   // 32
-    int32_t dec_n_kv_heads     = 0;   // 8
-    int32_t dec_head_dim       = 0;   // 128
-    std::string dec_hidden_act;       // "silu"
-    float   dec_rms_norm_eps   = 0.0f;
-    float   dec_rope_theta     = 0.0f;
-    int32_t dec_sliding_window = 0;   // 8192
-    int32_t dec_max_position   = 0;   // 131072
-    bool    dec_tie_word_embeddings = true;
-    int32_t dec_vocab_size     = 0;   // 131072
+    int32_t     dec_n_layers     = 0;  // 26
+    int32_t     dec_hidden       = 0;  // 3072
+    int32_t     dec_intermediate = 0;  // 9216
+    int32_t     dec_n_heads      = 0;  // 32
+    int32_t     dec_n_kv_heads   = 0;  // 8
+    int32_t     dec_head_dim     = 0;  // 128
+    std::string dec_hidden_act;        // "silu"
+    float       dec_rms_norm_eps        = 0.0f;
+    float       dec_rope_theta          = 0.0f;
+    int32_t     dec_sliding_window      = 0;  // 8192
+    int32_t     dec_max_position        = 0;  // 131072
+    bool        dec_tie_word_embeddings = true;
+    int32_t     dec_vocab_size          = 0;  // 131072
 
     // Delay-token time conditioning.
-    int32_t default_num_delay_tokens = 0;  // 6 (480 ms)
+    int32_t default_num_delay_tokens = 0;     // 6 (480 ms)
     float   time_embed_theta         = 0.0f;  // 10000
     int32_t time_embed_dim           = 0;     // 3072 (== dec_hidden)
     int32_t ada_hidden               = 0;     // 32
@@ -88,27 +88,25 @@ struct HParams {
 
     // Frontend (streaming log-mel; FIXED global_log_mel_max).
     std::string fe_type;
-    int32_t     fe_num_mels         = 0;
-    int32_t     fe_sample_rate      = 0;
-    int32_t     fe_n_fft            = 0;
-    int32_t     fe_win_length       = 0;
-    int32_t     fe_hop_length       = 0;
+    int32_t     fe_num_mels    = 0;
+    int32_t     fe_sample_rate = 0;
+    int32_t     fe_n_fft       = 0;
+    int32_t     fe_win_length  = 0;
+    int32_t     fe_hop_length  = 0;
     std::string fe_window;
-    std::string fe_normalize;        // "global"
+    std::string fe_normalize;  // "global"
     float       fe_global_log_mel_max = 1.5f;
-    float       fe_dither           = 0.0f;
-    float       fe_pre_emphasis     = 0.0f;
-    float       fe_f_min            = 0.0f;
-    float       fe_f_max            = 8000.0f;
+    float       fe_dither             = 0.0f;
+    float       fe_pre_emphasis       = 0.0f;
+    float       fe_f_min              = 0.0f;
+    float       fe_f_max              = 8000.0f;
     std::string fe_pad_mode;
-    bool        fe_center           = true;
+    bool        fe_center = true;
     std::string fe_mel_norm;
 
     // Audio tokens produced for `mel_frames` mel frames: ceil(mel/8).
     int32_t audio_tokens_for(int32_t mel_frames) const {
-        return (audio_length_per_tok > 0)
-                   ? (mel_frames + audio_length_per_tok - 1) / audio_length_per_tok
-                   : 0;
+        return (audio_length_per_tok > 0) ? (mel_frames + audio_length_per_tok - 1) / audio_length_per_tok : 0;
     }
 };
 
@@ -120,29 +118,29 @@ transcribe_status read_hparams(const gguf_context * gguf, HParams & hp);
 
 // 2x causal Conv1d stem + final RMSNorm.
 struct EncStem {
-    ggml_tensor * conv0_w = nullptr;  // [3, num_mel_bins, d_model] (F16)
-    ggml_tensor * conv0_b = nullptr;  // [d_model] (F32)
-    ggml_tensor * conv1_w = nullptr;  // [3, d_model, d_model] (F16)
-    ggml_tensor * conv1_b = nullptr;  // [d_model] (F32)
+    ggml_tensor * conv0_w      = nullptr;  // [3, num_mel_bins, d_model] (F16)
+    ggml_tensor * conv0_b      = nullptr;  // [d_model] (F32)
+    ggml_tensor * conv1_w      = nullptr;  // [3, d_model, d_model] (F16)
+    ggml_tensor * conv1_b      = nullptr;  // [d_model] (F32)
     ggml_tensor * final_norm_w = nullptr;  // RMSNorm [d_model] (F32)
 };
 
 // One encoder transformer block. q/v/out carry bias; k does NOT. SwiGLU/silu
 // MLP with bias only on down_proj. Pre-norm RMSNorm (no bias).
 struct EncBlock {
-    ggml_tensor * norm_attn_w = nullptr;  // RMSNorm [d_model]
-    ggml_tensor * attn_q_w    = nullptr;  // [d_model, n_heads*head_dim]
-    ggml_tensor * attn_q_b    = nullptr;  // [n_heads*head_dim]
-    ggml_tensor * attn_k_w    = nullptr;  // no bias
-    ggml_tensor * attn_v_w    = nullptr;
-    ggml_tensor * attn_v_b    = nullptr;
-    ggml_tensor * attn_out_w  = nullptr;
-    ggml_tensor * attn_out_b  = nullptr;
-    ggml_tensor * norm_ffn_w  = nullptr;  // RMSNorm [d_model]
-    ggml_tensor * ffn_gate_w  = nullptr;  // [d_model, ffn_dim]
-    ggml_tensor * ffn_up_w    = nullptr;  // [d_model, ffn_dim]
-    ggml_tensor * ffn_down_w  = nullptr;  // [ffn_dim, d_model]
-    ggml_tensor * ffn_down_b  = nullptr;  // [d_model]
+    ggml_tensor * norm_attn_w   = nullptr;  // RMSNorm [d_model]
+    ggml_tensor * attn_q_w      = nullptr;  // [d_model, n_heads*head_dim]
+    ggml_tensor * attn_q_b      = nullptr;  // [n_heads*head_dim]
+    ggml_tensor * attn_k_w      = nullptr;  // no bias
+    ggml_tensor * attn_v_w      = nullptr;
+    ggml_tensor * attn_v_b      = nullptr;
+    ggml_tensor * attn_out_w    = nullptr;
+    ggml_tensor * attn_out_b    = nullptr;
+    ggml_tensor * norm_ffn_w    = nullptr;  // RMSNorm [d_model]
+    ggml_tensor * ffn_gate_w    = nullptr;  // [d_model, ffn_dim]
+    ggml_tensor * ffn_up_w      = nullptr;  // [d_model, ffn_dim]
+    ggml_tensor * ffn_down_w    = nullptr;  // [ffn_dim, d_model]
+    ggml_tensor * ffn_down_b    = nullptr;  // [d_model]
     // Packed gate+up [d_model, 2*ffn_dim], filled at load time.
     ggml_tensor * ffn_gate_up_w = nullptr;
 };
@@ -162,16 +160,16 @@ struct DecEmbed {
 };
 
 struct DecBlock {
-    ggml_tensor * norm_attn_w = nullptr;  // input_layernorm (RMSNorm)
-    ggml_tensor * norm_ffn_w  = nullptr;  // post_attention_layernorm
-    ggml_tensor * attn_q_w    = nullptr;  // [hidden, n_heads*head_dim]
-    ggml_tensor * attn_k_w    = nullptr;  // [hidden, n_kv_heads*head_dim]
-    ggml_tensor * attn_v_w    = nullptr;
-    ggml_tensor * attn_o_w    = nullptr;  // [n_heads*head_dim, hidden]
-    ggml_tensor * ffn_gate_w  = nullptr;  // [hidden, intermediate]
-    ggml_tensor * ffn_up_w    = nullptr;  // [hidden, intermediate]
-    ggml_tensor * ffn_down_w  = nullptr;  // [intermediate, hidden]
-    ggml_tensor * ffn_gate_up_w = nullptr;  // packed [hidden, 2*intermediate]
+    ggml_tensor * norm_attn_w    = nullptr;  // input_layernorm (RMSNorm)
+    ggml_tensor * norm_ffn_w     = nullptr;  // post_attention_layernorm
+    ggml_tensor * attn_q_w       = nullptr;  // [hidden, n_heads*head_dim]
+    ggml_tensor * attn_k_w       = nullptr;  // [hidden, n_kv_heads*head_dim]
+    ggml_tensor * attn_v_w       = nullptr;
+    ggml_tensor * attn_o_w       = nullptr;  // [n_heads*head_dim, hidden]
+    ggml_tensor * ffn_gate_w     = nullptr;  // [hidden, intermediate]
+    ggml_tensor * ffn_up_w       = nullptr;  // [hidden, intermediate]
+    ggml_tensor * ffn_down_w     = nullptr;  // [intermediate, hidden]
+    ggml_tensor * ffn_gate_up_w  = nullptr;  // packed [hidden, 2*intermediate]
     // Adaptive-norm: ada(t) = linear2(gelu(linear1(t))). NO RMSNorm inside.
     ggml_tensor * ada_linear_1_w = nullptr;  // [hidden, ada_hidden]
     ggml_tensor * ada_linear_2_w = nullptr;  // [ada_hidden, hidden]
@@ -185,7 +183,7 @@ struct Weights {
     EncStem               enc_stem;
     std::vector<EncBlock> enc_blocks;
 
-    Projector             proj;
+    Projector proj;
 
     DecEmbed              dec_embed;
     std::vector<DecBlock> dec_blocks;
@@ -195,8 +193,6 @@ struct Weights {
     ggml_tensor * time_inv_freq = nullptr;
 };
 
-transcribe_status build_weights(ggml_context *  ctx_meta,
-                                const HParams & hp,
-                                Weights &       weights);
+transcribe_status build_weights(ggml_context * ctx_meta, const HParams & hp, Weights & weights);
 
-} // namespace transcribe::voxtral_realtime
+}  // namespace transcribe::voxtral_realtime
diff --git a/src/arch/whisper/bin_load.cpp b/src/arch/whisper/bin_load.cpp
index bf44ccad..6e8fb32a 100644
--- a/src/arch/whisper/bin_load.cpp
+++ b/src/arch/whisper/bin_load.cpp
@@ -5,18 +5,16 @@
 
 #include "bin_load.h"
 
-#include "weights.h"
-#include "whisper.h"
-
+#include "ggml-alloc.h"
+#include "ggml-backend.h"
+#include "ggml.h"
 #include "transcribe-arch.h"
 #include "transcribe-bin-loader.h"
 #include "transcribe-load-common.h"
-#include "transcribe-tokenizer.h"
 #include "transcribe-log.h"
-
-#include "ggml.h"
-#include "ggml-alloc.h"
-#include "ggml-backend.h"
+#include "transcribe-tokenizer.h"
+#include "weights.h"
+#include "whisper.h"
 
 #include <algorithm>
 #include <cmath>
@@ -41,12 +39,20 @@ constexpr const char * kTag = "whisper-bin";
 // (parity with the stt.variant a GGUF would carry). Doesn't gate runtime.
 std::string detect_variant(const transcribe::bin_loader::WhisperBinModel & bm) {
     const auto & h = bm.hp;
-    std::string base;
+    std::string  base;
     switch (h.n_audio_layer) {
-        case 4:  base = "whisper-tiny";   break;
-        case 6:  base = "whisper-base";   break;
-        case 12: base = "whisper-small";  break;
-        case 24: base = "whisper-medium"; break;
+        case 4:
+            base = "whisper-tiny";
+            break;
+        case 6:
+            base = "whisper-base";
+            break;
+        case 12:
+            base = "whisper-small";
+            break;
+        case 24:
+            base = "whisper-medium";
+            break;
         case 32:
             if (h.n_text_layer == 4) {
                 base = "whisper-large-v3-turbo";
@@ -56,7 +62,9 @@ std::string detect_variant(const transcribe::bin_loader::WhisperBinModel & bm) {
                 base = "whisper-large";
             }
             break;
-        default: base = "whisper";        break;
+        default:
+            base = "whisper";
+            break;
     }
     if (!bm.is_multilingual) {
         base += ".en";
@@ -67,50 +75,45 @@ std::string detect_variant(const transcribe::bin_loader::WhisperBinModel & bm) {
 // Canonical Whisper language table (verbatim from whisper.cpp). Index =
 // whisper language id; multilingual variants install the first num_languages.
 const char * const k_whisper_lang_codes[] = {
-    "en","zh","de","es","ru","ko","fr","ja","pt","tr",
-    "pl","ca","nl","ar","sv","it","id","hi","fi","vi",
-    "he","uk","el","ms","cs","ro","da","hu","ta","no",
-    "th","ur","hr","bg","lt","la","mi","ml","cy","sk",
-    "te","fa","lv","bn","sr","az","sl","kn","et","mk",
-    "br","eu","is","hy","ne","mn","bs","kk","sq","sw",
-    "gl","mr","pa","si","km","sn","yo","so","af","oc",
-    "ka","be","tg","sd","gu","am","yi","lo","uz","fo",
-    "ht","ps","tk","nn","mt","sa","lb","my","bo","tl",
-    "mg","as","tt","haw","ln","ha","ba","jw","su","yue",
+    "en", "zh", "de", "es", "ru", "ko", "fr", "ja", "pt",  "tr", "pl", "ca", "nl", "ar", "sv",  "it", "id",
+    "hi", "fi", "vi", "he", "uk", "el", "ms", "cs", "ro",  "da", "hu", "ta", "no", "th", "ur",  "hr", "bg",
+    "lt", "la", "mi", "ml", "cy", "sk", "te", "fa", "lv",  "bn", "sr", "az", "sl", "kn", "et",  "mk", "br",
+    "eu", "is", "hy", "ne", "mn", "bs", "kk", "sq", "sw",  "gl", "mr", "pa", "si", "km", "sn",  "yo", "so",
+    "af", "oc", "ka", "be", "tg", "sd", "gu", "am", "yi",  "lo", "uz", "fo", "ht", "ps", "tk",  "nn", "mt",
+    "sa", "lb", "my", "bo", "tl", "mg", "as", "tt", "haw", "ln", "ha", "ba", "jw", "su", "yue",
 };
-constexpr int k_whisper_n_lang_codes =
-    static_cast<int>(sizeof(k_whisper_lang_codes) / sizeof(k_whisper_lang_codes[0]));
+constexpr int k_whisper_n_lang_codes = static_cast<int>(sizeof(k_whisper_lang_codes) / sizeof(k_whisper_lang_codes[0]));
 
 // Special token computation (mirrors whisper.cpp). Defaults are the .en /
 // multilingual-base layout; for is_multilingual eot/sot shift +1 and the
 // downstream tokens shift by num_languages - 98.
 struct WhisperSpecials {
-    int eot        = 50256;
-    int sot        = 50257;
-    int translate  = 50357;
-    int transcribe = 50358;
-    int solm       = 50359;
-    int prev       = 50360;
-    int nosp       = 50361;
+    int eot          = 50256;
+    int sot          = 50257;
+    int translate    = 50357;
+    int transcribe   = 50358;
+    int solm         = 50359;
+    int prev         = 50360;
+    int nosp         = 50361;
     int notimestamps = 50362;  // <|notimestamps|>
-    int beg        = 50363;    // <|0.00|>, first timestamp token
+    int beg          = 50363;  // <|0.00|>, first timestamp token
 };
 
 WhisperSpecials compute_specials(int n_vocab) {
     WhisperSpecials s;
-    const bool is_multilingual = n_vocab >= 51865;
+    const bool      is_multilingual = n_vocab >= 51865;
     if (is_multilingual) {
         s.eot += 1;
         s.sot += 1;
         const int num_languages = n_vocab - 51765 - 1;
         const int dt            = num_languages - 98;
-        s.translate    += dt;
-        s.transcribe   += dt;
-        s.solm         += dt;
-        s.prev         += dt;
-        s.nosp         += dt;
+        s.translate += dt;
+        s.transcribe += dt;
+        s.solm += dt;
+        s.prev += dt;
+        s.nosp += dt;
         s.notimestamps += dt;
-        s.beg          += dt;
+        s.beg += dt;
     }
     return s;
 }
@@ -120,13 +123,12 @@ WhisperSpecials compute_specials(int n_vocab) {
 // generation_config.json (identical across variants; suppressing ids absent in
 // the smaller .en vocab is a no-op).
 const int32_t k_whisper_suppress_tokens[] = {
-    1,2,7,8,9,10,14,25,26,27,28,29,31,58,59,60,61,62,63,90,91,92,93,
-    359,503,522,542,873,893,902,918,922,931,1350,1853,1982,2460,
-    2627,3246,3253,3268,3536,3846,3961,4183,4667,6585,6647,7273,
-    9061,9383,10428,10929,11938,12033,12331,12562,13793,14157,14635,
-    15265,15618,16553,16604,18362,18956,20075,21675,22520,26130,
-    26161,26435,28279,29464,31650,32302,32470,36865,42863,47425,
-    49870,50254,50258,50358,50359,50360,50361,50362,
+    1,     2,     7,     8,     9,     10,    14,    25,    26,    27,    28,    29,    31,    58,    59,
+    60,    61,    62,    63,    90,    91,    92,    93,    359,   503,   522,   542,   873,   893,   902,
+    918,   922,   931,   1350,  1853,  1982,  2460,  2627,  3246,  3253,  3268,  3536,  3846,  3961,  4183,
+    4667,  6585,  6647,  7273,  9061,  9383,  10428, 10929, 11938, 12033, 12331, 12562, 13793, 14157, 14635,
+    15265, 15618, 16553, 16604, 18362, 18956, 20075, 21675, 22520, 26130, 26161, 26435, 28279, 29464, 31650,
+    32302, 32470, 36865, 42863, 47425, 49870, 50254, 50258, 50358, 50359, 50360, 50361, 50362,
 };
 constexpr int k_whisper_n_suppress =
     static_cast<int>(sizeof(k_whisper_suppress_tokens) / sizeof(k_whisper_suppress_tokens[0]));
@@ -141,18 +143,18 @@ struct StaticRename {
 };
 
 const StaticRename k_static_renames[] = {
-    {"encoder.positional_embedding",   "enc.pos_emb.weight",     false},
-    {"encoder.conv1.weight",           "enc.conv.0.weight",      false},
-    {"encoder.conv1.bias",             "enc.conv.0.bias",        true },
-    {"encoder.conv2.weight",           "enc.conv.1.weight",      false},
-    {"encoder.conv2.bias",             "enc.conv.1.bias",        true },
-    {"encoder.ln_post.weight",         "enc.final_norm.weight",  false},
-    {"encoder.ln_post.bias",           "enc.final_norm.bias",    false},
-
-    {"decoder.positional_embedding",   "dec.pos_emb.weight",     false},
-    {"decoder.token_embedding.weight", "dec.token_embd.weight",  false},
-    {"decoder.ln.weight",              "dec.final_norm.weight",  false},
-    {"decoder.ln.bias",                "dec.final_norm.bias",    false},
+    { "encoder.positional_embedding",   "enc.pos_emb.weight",    false },
+    { "encoder.conv1.weight",           "enc.conv.0.weight",     false },
+    { "encoder.conv1.bias",             "enc.conv.0.bias",       true  },
+    { "encoder.conv2.weight",           "enc.conv.1.weight",     false },
+    { "encoder.conv2.bias",             "enc.conv.1.bias",       true  },
+    { "encoder.ln_post.weight",         "enc.final_norm.weight", false },
+    { "encoder.ln_post.bias",           "enc.final_norm.bias",   false },
+
+    { "decoder.positional_embedding",   "dec.pos_emb.weight",    false },
+    { "decoder.token_embedding.weight", "dec.token_embd.weight", false },
+    { "decoder.ln.weight",              "dec.final_norm.weight", false },
+    { "decoder.ln.bias",                "dec.final_norm.bias",   false },
 };
 
 struct LayeredRename {
@@ -161,48 +163,48 @@ struct LayeredRename {
 };
 
 const LayeredRename k_enc_block_renames[] = {
-    {"encoder.blocks.%d.attn_ln.weight",      "enc.blocks.%d.norm_attn.weight"},
-    {"encoder.blocks.%d.attn_ln.bias",        "enc.blocks.%d.norm_attn.bias"  },
-    {"encoder.blocks.%d.attn.query.weight",   "enc.blocks.%d.attn.q.weight"   },
-    {"encoder.blocks.%d.attn.query.bias",     "enc.blocks.%d.attn.q.bias"     },
-    {"encoder.blocks.%d.attn.key.weight",     "enc.blocks.%d.attn.k.weight"   },  // no bias
-    {"encoder.blocks.%d.attn.value.weight",   "enc.blocks.%d.attn.v.weight"   },
-    {"encoder.blocks.%d.attn.value.bias",     "enc.blocks.%d.attn.v.bias"     },
-    {"encoder.blocks.%d.attn.out.weight",     "enc.blocks.%d.attn.out.weight" },
-    {"encoder.blocks.%d.attn.out.bias",       "enc.blocks.%d.attn.out.bias"   },
-    {"encoder.blocks.%d.mlp_ln.weight",       "enc.blocks.%d.norm_ffn.weight" },
-    {"encoder.blocks.%d.mlp_ln.bias",         "enc.blocks.%d.norm_ffn.bias"   },
-    {"encoder.blocks.%d.mlp.0.weight",        "enc.blocks.%d.ffn.fc1.weight"  },
-    {"encoder.blocks.%d.mlp.0.bias",          "enc.blocks.%d.ffn.fc1.bias"    },
-    {"encoder.blocks.%d.mlp.2.weight",        "enc.blocks.%d.ffn.fc2.weight"  },
-    {"encoder.blocks.%d.mlp.2.bias",          "enc.blocks.%d.ffn.fc2.bias"    },
+    { "encoder.blocks.%d.attn_ln.weight",    "enc.blocks.%d.norm_attn.weight" },
+    { "encoder.blocks.%d.attn_ln.bias",      "enc.blocks.%d.norm_attn.bias"   },
+    { "encoder.blocks.%d.attn.query.weight", "enc.blocks.%d.attn.q.weight"    },
+    { "encoder.blocks.%d.attn.query.bias",   "enc.blocks.%d.attn.q.bias"      },
+    { "encoder.blocks.%d.attn.key.weight",   "enc.blocks.%d.attn.k.weight"    }, // no bias
+    { "encoder.blocks.%d.attn.value.weight", "enc.blocks.%d.attn.v.weight"    },
+    { "encoder.blocks.%d.attn.value.bias",   "enc.blocks.%d.attn.v.bias"      },
+    { "encoder.blocks.%d.attn.out.weight",   "enc.blocks.%d.attn.out.weight"  },
+    { "encoder.blocks.%d.attn.out.bias",     "enc.blocks.%d.attn.out.bias"    },
+    { "encoder.blocks.%d.mlp_ln.weight",     "enc.blocks.%d.norm_ffn.weight"  },
+    { "encoder.blocks.%d.mlp_ln.bias",       "enc.blocks.%d.norm_ffn.bias"    },
+    { "encoder.blocks.%d.mlp.0.weight",      "enc.blocks.%d.ffn.fc1.weight"   },
+    { "encoder.blocks.%d.mlp.0.bias",        "enc.blocks.%d.ffn.fc1.bias"     },
+    { "encoder.blocks.%d.mlp.2.weight",      "enc.blocks.%d.ffn.fc2.weight"   },
+    { "encoder.blocks.%d.mlp.2.bias",        "enc.blocks.%d.ffn.fc2.bias"     },
 };
 
 const LayeredRename k_dec_block_renames[] = {
-    {"decoder.blocks.%d.attn_ln.weight",        "dec.blocks.%d.norm_self.weight"     },
-    {"decoder.blocks.%d.attn_ln.bias",          "dec.blocks.%d.norm_self.bias"       },
-    {"decoder.blocks.%d.attn.query.weight",     "dec.blocks.%d.self_attn.q.weight"   },
-    {"decoder.blocks.%d.attn.query.bias",       "dec.blocks.%d.self_attn.q.bias"     },
-    {"decoder.blocks.%d.attn.key.weight",       "dec.blocks.%d.self_attn.k.weight"   },
-    {"decoder.blocks.%d.attn.value.weight",     "dec.blocks.%d.self_attn.v.weight"   },
-    {"decoder.blocks.%d.attn.value.bias",       "dec.blocks.%d.self_attn.v.bias"     },
-    {"decoder.blocks.%d.attn.out.weight",       "dec.blocks.%d.self_attn.out.weight" },
-    {"decoder.blocks.%d.attn.out.bias",         "dec.blocks.%d.self_attn.out.bias"   },
-    {"decoder.blocks.%d.cross_attn_ln.weight",  "dec.blocks.%d.norm_cross.weight"    },
-    {"decoder.blocks.%d.cross_attn_ln.bias",    "dec.blocks.%d.norm_cross.bias"      },
-    {"decoder.blocks.%d.cross_attn.query.weight","dec.blocks.%d.cross_attn.q.weight" },
-    {"decoder.blocks.%d.cross_attn.query.bias", "dec.blocks.%d.cross_attn.q.bias"    },
-    {"decoder.blocks.%d.cross_attn.key.weight", "dec.blocks.%d.cross_attn.k.weight"  },
-    {"decoder.blocks.%d.cross_attn.value.weight","dec.blocks.%d.cross_attn.v.weight" },
-    {"decoder.blocks.%d.cross_attn.value.bias", "dec.blocks.%d.cross_attn.v.bias"    },
-    {"decoder.blocks.%d.cross_attn.out.weight", "dec.blocks.%d.cross_attn.out.weight"},
-    {"decoder.blocks.%d.cross_attn.out.bias",   "dec.blocks.%d.cross_attn.out.bias"  },
-    {"decoder.blocks.%d.mlp_ln.weight",         "dec.blocks.%d.norm_ffn.weight"      },
-    {"decoder.blocks.%d.mlp_ln.bias",           "dec.blocks.%d.norm_ffn.bias"        },
-    {"decoder.blocks.%d.mlp.0.weight",          "dec.blocks.%d.ffn.fc1.weight"       },
-    {"decoder.blocks.%d.mlp.0.bias",            "dec.blocks.%d.ffn.fc1.bias"         },
-    {"decoder.blocks.%d.mlp.2.weight",          "dec.blocks.%d.ffn.fc2.weight"       },
-    {"decoder.blocks.%d.mlp.2.bias",            "dec.blocks.%d.ffn.fc2.bias"         },
+    { "decoder.blocks.%d.attn_ln.weight",          "dec.blocks.%d.norm_self.weight"      },
+    { "decoder.blocks.%d.attn_ln.bias",            "dec.blocks.%d.norm_self.bias"        },
+    { "decoder.blocks.%d.attn.query.weight",       "dec.blocks.%d.self_attn.q.weight"    },
+    { "decoder.blocks.%d.attn.query.bias",         "dec.blocks.%d.self_attn.q.bias"      },
+    { "decoder.blocks.%d.attn.key.weight",         "dec.blocks.%d.self_attn.k.weight"    },
+    { "decoder.blocks.%d.attn.value.weight",       "dec.blocks.%d.self_attn.v.weight"    },
+    { "decoder.blocks.%d.attn.value.bias",         "dec.blocks.%d.self_attn.v.bias"      },
+    { "decoder.blocks.%d.attn.out.weight",         "dec.blocks.%d.self_attn.out.weight"  },
+    { "decoder.blocks.%d.attn.out.bias",           "dec.blocks.%d.self_attn.out.bias"    },
+    { "decoder.blocks.%d.cross_attn_ln.weight",    "dec.blocks.%d.norm_cross.weight"     },
+    { "decoder.blocks.%d.cross_attn_ln.bias",      "dec.blocks.%d.norm_cross.bias"       },
+    { "decoder.blocks.%d.cross_attn.query.weight", "dec.blocks.%d.cross_attn.q.weight"   },
+    { "decoder.blocks.%d.cross_attn.query.bias",   "dec.blocks.%d.cross_attn.q.bias"     },
+    { "decoder.blocks.%d.cross_attn.key.weight",   "dec.blocks.%d.cross_attn.k.weight"   },
+    { "decoder.blocks.%d.cross_attn.value.weight", "dec.blocks.%d.cross_attn.v.weight"   },
+    { "decoder.blocks.%d.cross_attn.value.bias",   "dec.blocks.%d.cross_attn.v.bias"     },
+    { "decoder.blocks.%d.cross_attn.out.weight",   "dec.blocks.%d.cross_attn.out.weight" },
+    { "decoder.blocks.%d.cross_attn.out.bias",     "dec.blocks.%d.cross_attn.out.bias"   },
+    { "decoder.blocks.%d.mlp_ln.weight",           "dec.blocks.%d.norm_ffn.weight"       },
+    { "decoder.blocks.%d.mlp_ln.bias",             "dec.blocks.%d.norm_ffn.bias"         },
+    { "decoder.blocks.%d.mlp.0.weight",            "dec.blocks.%d.ffn.fc1.weight"        },
+    { "decoder.blocks.%d.mlp.0.bias",              "dec.blocks.%d.ffn.fc1.bias"          },
+    { "decoder.blocks.%d.mlp.2.weight",            "dec.blocks.%d.ffn.fc2.weight"        },
+    { "decoder.blocks.%d.mlp.2.bias",              "dec.blocks.%d.ffn.fc2.bias"          },
 };
 
 std::string fmt1(const char * fmt, int idx) {
@@ -216,75 +218,71 @@ std::string fmt1(const char * fmt, int idx) {
 // it here (as whisper.cpp does) for install_mel_from_buffers.
 std::vector<float> hann_periodic(int n_fft) {
     std::vector<float> w(static_cast<size_t>(n_fft));
-    const double two_pi_over_n = 2.0 * M_PI / static_cast<double>(n_fft);
+    const double       two_pi_over_n = 2.0 * M_PI / static_cast<double>(n_fft);
     for (int k = 0; k < n_fft; ++k) {
-        w[static_cast<size_t>(k)] =
-            static_cast<float>(0.5 * (1.0 - std::cos(two_pi_over_n * k)));
+        w[static_cast<size_t>(k)] = static_cast<float>(0.5 * (1.0 - std::cos(two_pi_over_n * k)));
     }
     return w;
 }
 
 // Synthesize a WhisperHParams from the parsed bin model. Every field the GGUF
 // path reads from KVs gets a hardcoded value matching the shipped variants.
-void fill_whisper_hparams(const transcribe::bin_loader::WhisperBinModel & bm,
-                          WhisperHParams &                                  hp)
-{
+void fill_whisper_hparams(const transcribe::bin_loader::WhisperBinModel & bm, WhisperHParams & hp) {
     hp = WhisperHParams{};
 
     // Encoder.
-    hp.enc_n_layers              = bm.hp.n_audio_layer;
-    hp.enc_d_model               = bm.hp.n_audio_state;
-    hp.enc_n_heads               = bm.hp.n_audio_head;
-    hp.enc_ffn_dim               = 4 * bm.hp.n_audio_state;
-    hp.enc_num_mel_bins          = bm.hp.n_mels;
-    hp.enc_max_source_positions  = bm.hp.n_audio_ctx;
-    hp.enc_activation            = "gelu";
+    hp.enc_n_layers             = bm.hp.n_audio_layer;
+    hp.enc_d_model              = bm.hp.n_audio_state;
+    hp.enc_n_heads              = bm.hp.n_audio_head;
+    hp.enc_ffn_dim              = 4 * bm.hp.n_audio_state;
+    hp.enc_num_mel_bins         = bm.hp.n_mels;
+    hp.enc_max_source_positions = bm.hp.n_audio_ctx;
+    hp.enc_activation           = "gelu";
 
     // Decoder.
-    hp.dec_n_layers              = bm.hp.n_text_layer;
-    hp.dec_d_model               = bm.hp.n_text_state;
-    hp.dec_n_heads               = bm.hp.n_text_head;
-    hp.dec_ffn_dim               = 4 * bm.hp.n_text_state;
-    hp.dec_max_target_positions  = bm.hp.n_text_ctx;
-    hp.dec_vocab_size            = bm.hp.n_vocab;
-    hp.dec_activation            = "gelu";
-    hp.dec_tie_word_embeddings   = true;
-    hp.dec_scale_embedding       = false;
+    hp.dec_n_layers             = bm.hp.n_text_layer;
+    hp.dec_d_model              = bm.hp.n_text_state;
+    hp.dec_n_heads              = bm.hp.n_text_head;
+    hp.dec_ffn_dim              = 4 * bm.hp.n_text_state;
+    hp.dec_max_target_positions = bm.hp.n_text_ctx;
+    hp.dec_vocab_size           = bm.hp.n_vocab;
+    hp.dec_activation           = "gelu";
+    hp.dec_tie_word_embeddings  = true;
+    hp.dec_scale_embedding      = false;
 
     // Special tokens.
-    const WhisperSpecials sp     = compute_specials(bm.hp.n_vocab);
-    hp.decoder_start_token_id    = sp.sot;
-    hp.sot_token_id              = sp.sot;
-    hp.no_timestamps_token_id    = sp.notimestamps;
-    hp.transcribe_token_id       = bm.is_multilingual ? sp.transcribe : -1;
-    hp.translate_token_id        = bm.is_multilingual ? sp.translate  : -1;
-    hp.prev_sot_token_id         = sp.prev;
+    const WhisperSpecials sp  = compute_specials(bm.hp.n_vocab);
+    hp.decoder_start_token_id = sp.sot;
+    hp.sot_token_id           = sp.sot;
+    hp.no_timestamps_token_id = sp.notimestamps;
+    hp.transcribe_token_id    = bm.is_multilingual ? sp.transcribe : -1;
+    hp.translate_token_id     = bm.is_multilingual ? sp.translate : -1;
+    hp.prev_sot_token_id      = sp.prev;
 
     // Suppression list — same across all multilingual whisper.cpp .bin
     // variants. For .en, suppressing ids that don't exist in the
     // smaller vocab is a no-op; the runtime check `id < vocab_size`
     // gates application.
-    hp.suppress_tokens.assign(k_whisper_suppress_tokens,
-                              k_whisper_suppress_tokens + k_whisper_n_suppress);
-    hp.begin_suppress_tokens.assign({220, sp.eot});
+    hp.suppress_tokens.assign(k_whisper_suppress_tokens, k_whisper_suppress_tokens + k_whisper_n_suppress);
+    hp.begin_suppress_tokens.assign({ 220, sp.eot });
 
     // Frontend (fixed across whisper variants — no .bin field carries
     // these so we use the canonical preprocessor_config.json values).
-    hp.fe_type        = "mel";
-    hp.fe_num_mels    = bm.hp.n_mels;
-    hp.fe_sample_rate = 16000;
-    hp.fe_n_fft       = 400;
-    hp.fe_win_length  = 400;
-    hp.fe_hop_length  = 160;
-    hp.fe_window      = "hann_periodic";
-    hp.fe_normalize   = "whisper_logmel";
-    hp.fe_dither      = 0.0f;
-    hp.fe_pre_emphasis = 0.0f;
-    hp.fe_f_min       = 0.0f;
-    hp.fe_f_max       = 8000.0f;
-    hp.fe_pad_mode    = "reflect";
-    hp.fe_center      = true;
-    hp.fe_mel_norm    = "slaney";
+    hp.fe_type          = "mel";
+    hp.fe_num_mels      = bm.hp.n_mels;
+    hp.fe_sample_rate   = 16000;
+    hp.fe_n_fft         = 400;
+    hp.fe_win_length    = 400;
+    hp.fe_hop_length    = 160;
+    hp.fe_window        = "hann_periodic";
+    hp.fe_normalize     = "whisper_logmel";
+    hp.fe_dither        = 0.0f;
+    hp.fe_pre_emphasis  = 0.0f;
+    hp.fe_f_min         = 0.0f;
+    hp.fe_f_max         = 8000.0f;
+    hp.fe_pad_mode      = "reflect";
+    hp.fe_center        = true;
+    hp.fe_mel_norm      = "slaney";
     hp.fe_chunk_length  = 30;
     hp.fe_n_samples     = 480000;
     hp.fe_nb_max_frames = 3000;
@@ -299,53 +297,53 @@ void fill_whisper_hparams(const transcribe::bin_loader::WhisperBinModel & bm,
 // source type, and record (target, src_offset, src_nbytes) into out_slots for
 // the byte-streaming step. Validates that every slot is filled and no source
 // tensor is left unconsumed.
-ggml_tensor * create_canonical_tensor(
-    ggml_context *                                       ctx_meta,
-    const std::string &                                  canonical_name,
-    const transcribe::bin_loader::BinTensorEntry &       src,
-    bool                                                 collapse_to_1d)
-{
-    int      n_dims = src.n_dims;
-    int64_t  ne[GGML_MAX_DIMS];
-    for (int i = 0; i < GGML_MAX_DIMS; ++i) ne[i] = 1;
-    for (int i = 0; i < n_dims; ++i) ne[i] = src.ne[i];
+ggml_tensor * create_canonical_tensor(ggml_context *                                 ctx_meta,
+                                      const std::string &                            canonical_name,
+                                      const transcribe::bin_loader::BinTensorEntry & src,
+                                      bool                                           collapse_to_1d) {
+    int     n_dims = src.n_dims;
+    int64_t ne[GGML_MAX_DIMS];
+    for (int i = 0; i < GGML_MAX_DIMS; ++i) {
+        ne[i] = 1;
+    }
+    for (int i = 0; i < n_dims; ++i) {
+        ne[i] = src.ne[i];
+    }
 
     if (collapse_to_1d) {
         // whisper.cpp conv biases arrive as ne [1, d_model, 1, 1]; the byte
         // payload is d_model contiguous floats, so collapse to 1D ne [d_model].
         int64_t total = 1;
-        for (int i = 0; i < n_dims; ++i) total *= ne[i];
-        for (int i = 0; i < GGML_MAX_DIMS; ++i) ne[i] = 1;
-        ne[0] = total;
+        for (int i = 0; i < n_dims; ++i) {
+            total *= ne[i];
+        }
+        for (int i = 0; i < GGML_MAX_DIMS; ++i) {
+            ne[i] = 1;
+        }
+        ne[0]  = total;
         n_dims = 1;
     }
 
     ggml_tensor * t = ggml_new_tensor(ctx_meta, src.type, n_dims, ne);
     if (t == nullptr) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "%s: ggml_new_tensor failed for \"%s\"",
-                     kTag, canonical_name.c_str());
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: ggml_new_tensor failed for \"%s\"", kTag, canonical_name.c_str());
         return nullptr;
     }
     ggml_set_name(t, canonical_name.c_str());
     return t;
 }
 
-transcribe_status resolve_tensors(
-    const transcribe::bin_loader::WhisperBinModel &  bm,
-    const WhisperHParams &                           hp,
-    ggml_context *                                   ctx_meta,
-    std::vector<transcribe::bin_loader::BinStreamSlot> & out_slots)
-{
+transcribe_status resolve_tensors(const transcribe::bin_loader::WhisperBinModel &      bm,
+                                  const WhisperHParams &                               hp,
+                                  ggml_context *                                       ctx_meta,
+                                  std::vector<transcribe::bin_loader::BinStreamSlot> & out_slots) {
     // Forward index legacy_name → entry pointer. Faster than scanning
     // bm.tensors per slot, and lets us flag stray entries cheaply.
     std::unordered_map<std::string, const transcribe::bin_loader::BinTensorEntry *> by_name;
     by_name.reserve(bm.tensors.size() * 2);
     for (const auto & e : bm.tensors) {
         if (!by_name.emplace(e.name, &e).second) {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "%s: duplicate tensor \"%s\" in .bin",
-                         kTag, e.name.c_str());
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: duplicate tensor \"%s\" in .bin", kTag, e.name.c_str());
             return TRANSCRIBE_ERR_GGUF;
         }
     }
@@ -357,17 +355,19 @@ transcribe_status resolve_tensors(
     // empty F32 slots to satisfy build_whisper_weights; bytes are filled
     // post-backend-alloc below.
     {
-        const int64_t n_fft_half =
-            static_cast<int64_t>(hp.fe_n_fft / 2 + 1);
-        const int64_t fb_ne[2] = {n_fft_half,
-                                  static_cast<int64_t>(hp.fe_num_mels)};
-        ggml_tensor * fb = ggml_new_tensor(ctx_meta, GGML_TYPE_F32, 2, fb_ne);
-        if (fb == nullptr) return TRANSCRIBE_ERR_GGUF;
+        const int64_t n_fft_half = static_cast<int64_t>(hp.fe_n_fft / 2 + 1);
+        const int64_t fb_ne[2]   = { n_fft_half, static_cast<int64_t>(hp.fe_num_mels) };
+        ggml_tensor * fb         = ggml_new_tensor(ctx_meta, GGML_TYPE_F32, 2, fb_ne);
+        if (fb == nullptr) {
+            return TRANSCRIBE_ERR_GGUF;
+        }
         ggml_set_name(fb, "frontend.mel_filterbank");
 
-        const int64_t win_ne[1] = {static_cast<int64_t>(hp.fe_n_fft)};
-        ggml_tensor * win = ggml_new_tensor(ctx_meta, GGML_TYPE_F32, 1, win_ne);
-        if (win == nullptr) return TRANSCRIBE_ERR_GGUF;
+        const int64_t win_ne[1] = { static_cast<int64_t>(hp.fe_n_fft) };
+        ggml_tensor * win       = ggml_new_tensor(ctx_meta, GGML_TYPE_F32, 1, win_ne);
+        if (win == nullptr) {
+            return TRANSCRIBE_ERR_GGUF;
+        }
         ggml_set_name(win, "frontend.window");
     }
 
@@ -375,44 +375,49 @@ transcribe_status resolve_tensors(
         auto it = by_name.find(rule.legacy);
         if (it == by_name.end()) {
             log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "%s: missing tensor \"%s\" (canonical \"%s\") "
-                         "— .bin is incomplete or not a whisper model",
-                         kTag, rule.legacy, rule.canonical);
+                    "%s: missing tensor \"%s\" (canonical \"%s\") "
+                    "— .bin is incomplete or not a whisper model",
+                    kTag, rule.legacy, rule.canonical);
             return TRANSCRIBE_ERR_GGUF;
         }
-        ggml_tensor * t = create_canonical_tensor(
-            ctx_meta, rule.canonical, *it->second, rule.collapse_to_1d);
+        ggml_tensor * t = create_canonical_tensor(ctx_meta, rule.canonical, *it->second, rule.collapse_to_1d);
         if (t == nullptr) {
             return TRANSCRIBE_ERR_GGUF;
         }
-        out_slots.push_back({t, it->second->offset, it->second->nbytes});
+        out_slots.push_back({ t, it->second->offset, it->second->nbytes });
         consumed.insert(rule.legacy);
         return TRANSCRIBE_OK;
     };
     auto add_slot_layered = [&](const LayeredRename & rule, int idx) -> transcribe_status {
-        StaticRename s;
-        const std::string legacy_s    = fmt1(rule.legacy_fmt,    idx);
+        StaticRename      s;
+        const std::string legacy_s    = fmt1(rule.legacy_fmt, idx);
         const std::string canonical_s = fmt1(rule.canonical_fmt, idx);
-        s.legacy         = legacy_s.c_str();
-        s.canonical      = canonical_s.c_str();
-        s.collapse_to_1d = false;
+        s.legacy                      = legacy_s.c_str();
+        s.canonical                   = canonical_s.c_str();
+        s.collapse_to_1d              = false;
         return add_slot(s);
     };
 
     // Top-level slots.
     for (const auto & r : k_static_renames) {
-        if (auto st = add_slot(r); st != TRANSCRIBE_OK) return st;
+        if (auto st = add_slot(r); st != TRANSCRIBE_OK) {
+            return st;
+        }
     }
     // Encoder blocks.
     for (int i = 0; i < hp.enc_n_layers; ++i) {
         for (const auto & r : k_enc_block_renames) {
-            if (auto st = add_slot_layered(r, i); st != TRANSCRIBE_OK) return st;
+            if (auto st = add_slot_layered(r, i); st != TRANSCRIBE_OK) {
+                return st;
+            }
         }
     }
     // Decoder blocks.
     for (int i = 0; i < hp.dec_n_layers; ++i) {
         for (const auto & r : k_dec_block_renames) {
-            if (auto st = add_slot_layered(r, i); st != TRANSCRIBE_OK) return st;
+            if (auto st = add_slot_layered(r, i); st != TRANSCRIBE_OK) {
+                return st;
+            }
         }
     }
 
@@ -423,9 +428,9 @@ transcribe_status resolve_tensors(
         for (const auto & e : bm.tensors) {
             if (consumed.find(e.name) == consumed.end()) {
                 log_msg(TRANSCRIBE_LOG_LEVEL_INFO,
-                             "%s: unconsumed .bin tensor \"%s\" — "
-                             "this loader does not yet support it",
-                             kTag, e.name.c_str());
+                        "%s: unconsumed .bin tensor \"%s\" — "
+                        "this loader does not yet support it",
+                        kTag, e.name.c_str());
             }
         }
         return TRANSCRIBE_ERR_GGUF;
@@ -438,9 +443,7 @@ transcribe_status resolve_tensors(
 // read_capability_kv + read_languages_kv for the GGUF path, but from inferred
 // values since there are no GGUF KVs. lang_codes (owned on the model) backs the
 // caps.languages pointer table; its lifetime matches the WhisperModel.
-void apply_caps_and_languages(WhisperModel &                                  m,
-                              const transcribe::bin_loader::WhisperBinModel & bm)
-{
+void apply_caps_and_languages(WhisperModel & m, const transcribe::bin_loader::WhisperBinModel & bm) {
     apply_family_invariants(m);
 
     if (!bm.is_multilingual) {
@@ -469,8 +472,7 @@ void apply_caps_and_languages(WhisperModel &                                  m,
         const WhisperSpecials sp = compute_specials(bm.hp.n_vocab);
         m.lang_token_ids.reserve(m.lang_codes.size());
         for (size_t i = 0; i < m.lang_codes.size(); ++i) {
-            m.lang_token_ids.push_back(
-                static_cast<int32_t>(sp.sot + 1 + static_cast<int>(i)));
+            m.lang_token_ids.push_back(static_cast<int32_t>(sp.sot + 1 + static_cast<int>(i)));
         }
     }
 
@@ -487,32 +489,29 @@ void apply_caps_and_languages(WhisperModel &                                  m,
 // the special-piece map (as whisper.cpp does). Without them the run path's
 // initial_prompt rejection check would miss such literals in user text and
 // byte-encode them as context noise instead of rejecting symmetrically.
-transcribe_status install_tokenizer(WhisperModel &                                  m,
-                                    const transcribe::bin_loader::WhisperBinModel & bm)
-{
+transcribe_status install_tokenizer(WhisperModel & m, const transcribe::bin_loader::WhisperBinModel & bm) {
     transcribe::Tokenizer::DecodeOnlySpecials sp;
-    const WhisperSpecials s = compute_specials(bm.hp.n_vocab);
-    sp.eos_id = s.eot;
-    sp.bos_id = s.eot;
-    if (auto st = m.tok.load_decode_only_raw_bytes(bm.vocab_tokens, sp);
-        st != TRANSCRIBE_OK) return st;
+    const WhisperSpecials                     s = compute_specials(bm.hp.n_vocab);
+    sp.eos_id                                   = s.eot;
+    sp.bos_id                                   = s.eot;
+    if (auto st = m.tok.load_decode_only_raw_bytes(bm.vocab_tokens, sp); st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Discrete specials that exist in every Whisper variant.
-    m.tok.add_special_piece("<|endoftext|>",        s.eot);
+    m.tok.add_special_piece("<|endoftext|>", s.eot);
     m.tok.add_special_piece("<|startoftranscript|>", s.sot);
-    m.tok.add_special_piece("<|startofprev|>",      s.prev);
-    m.tok.add_special_piece("<|nospeech|>",         s.nosp);
-    m.tok.add_special_piece("<|notimestamps|>",     s.notimestamps);
+    m.tok.add_special_piece("<|startofprev|>", s.prev);
+    m.tok.add_special_piece("<|nospeech|>", s.nosp);
+    m.tok.add_special_piece("<|notimestamps|>", s.notimestamps);
 
     // Multilingual-only specials: language tokens + task tokens.
     if (bm.is_multilingual) {
-        m.tok.add_special_piece("<|translate|>",  s.translate);
+        m.tok.add_special_piece("<|translate|>", s.translate);
         m.tok.add_special_piece("<|transcribe|>", s.transcribe);
-        const int n_lang = std::min(bm.num_languages,
-                                    k_whisper_n_lang_codes);
+        const int n_lang = std::min(bm.num_languages, k_whisper_n_lang_codes);
         for (int i = 0; i < n_lang; ++i) {
-            std::string lit = std::string("<|") +
-                              k_whisper_lang_codes[i] + "|>";
+            std::string lit = std::string("<|") + k_whisper_lang_codes[i] + "|>";
             m.tok.add_special_piece(lit, s.sot + 1 + i);
         }
     }
@@ -521,19 +520,17 @@ transcribe_status install_tokenizer(WhisperModel &
     // matches HF's added_tokens convention so such literals are detected.
     char tsbuf[16];
     for (int i = 0; i <= 1500; ++i) {
-        std::snprintf(tsbuf, sizeof(tsbuf), "<|%.2f|>",
-                      static_cast<double>(i) * 0.02);
+        std::snprintf(tsbuf, sizeof(tsbuf), "<|%.2f|>", static_cast<double>(i) * 0.02);
         m.tok.add_special_piece(tsbuf, s.beg + i);
     }
     return TRANSCRIBE_OK;
 }
 
-} // namespace
+}  // namespace
 
-transcribe_status load_from_bin(const char *                           path,
+transcribe_status load_from_bin(const char *                                path,
                                 const struct transcribe_model_load_params * params,
-                                struct transcribe_model **             out_model)
-{
+                                struct transcribe_model **                  out_model) {
     if (out_model == nullptr || path == nullptr || params == nullptr) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
@@ -543,13 +540,11 @@ transcribe_status load_from_bin(const char *                           path,
 
     // ---- Parse the .bin (metadata only) ----
     transcribe::bin_loader::WhisperBinModel bm;
-    if (auto st = transcribe::bin_loader::parse_whisper_bin(path, bm);
-        st != TRANSCRIBE_OK)
-    {
+    if (auto st = transcribe::bin_loader::parse_whisper_bin(path, bm); st != TRANSCRIBE_OK) {
         return st;
     }
 
-    auto m = std::make_unique<WhisperModel>();
+    auto m       = std::make_unique<WhisperModel>();
     m->arch      = &arch;
     m->t_load_us = 0;
     m->variant   = detect_variant(bm);
@@ -570,22 +565,19 @@ transcribe_status load_from_bin(const char *                           path,
     // Sized like the GGUF path: roughly n_tensors * tensor_overhead,
     // with slack. Whisper-tiny has ~167 tensors, large-v3 ~1200.
     const size_t n_tensors_est =
-        static_cast<size_t>(15 + 15 * m->hparams.enc_n_layers
-                              + 24 * m->hparams.dec_n_layers + 32);
-    ggml_init_params init_params {};
-    init_params.mem_size = (n_tensors_est + 64) * ggml_tensor_overhead();
+        static_cast<size_t>(15 + 15 * m->hparams.enc_n_layers + 24 * m->hparams.dec_n_layers + 32);
+    ggml_init_params init_params{};
+    init_params.mem_size   = (n_tensors_est + 64) * ggml_tensor_overhead();
     init_params.mem_buffer = nullptr;
-    init_params.no_alloc = true;
-    m->ctx_meta = ggml_init(init_params);
+    init_params.no_alloc   = true;
+    m->ctx_meta            = ggml_init(init_params);
     if (m->ctx_meta == nullptr) {
         return TRANSCRIBE_ERR_GGUF;
     }
 
     std::vector<transcribe::bin_loader::BinStreamSlot> stream_slots;
     stream_slots.reserve(bm.tensors.size());
-    if (auto st = resolve_tensors(bm, m->hparams, m->ctx_meta, stream_slots);
-        st != TRANSCRIBE_OK)
-    {
+    if (auto st = resolve_tensors(bm, m->hparams, m->ctx_meta, stream_slots); st != TRANSCRIBE_OK) {
         return st;
     }
 
@@ -593,44 +585,36 @@ transcribe_status load_from_bin(const char *                           path,
     // Now that ctx_meta holds tensors with canonical names + post-
     // squeeze ne, the standard build_whisper_weights pass succeeds
     // identically to the GGUF path.
-    if (auto st = build_whisper_weights(m->ctx_meta, m->hparams, m->weights);
-        st != TRANSCRIBE_OK)
-    {
+    if (auto st = build_whisper_weights(m->ctx_meta, m->hparams, m->weights); st != TRANSCRIBE_OK) {
         return st;
     }
 
     // ---- Backend plan ----
-    if (auto st = transcribe::load_common::init_backends(
-            params->backend, params->gpu_device, "whisper", m->plan);
-        st != TRANSCRIBE_OK)
-    {
+    if (auto st = transcribe::load_common::init_backends(params->backend, params->gpu_device, "whisper", m->plan);
+        st != TRANSCRIBE_OK) {
         return st;
     }
-    m->backend = ggml_backend_name(m->plan.primary);
+    m->backend         = ggml_backend_name(m->plan.primary);
     m->primary_backend = m->plan.primary;
 
     // ---- Allocate backend buffer ----
-    ggml_backend_buffer_t buf =
-        ggml_backend_alloc_ctx_tensors(m->ctx_meta, m->plan.primary);
+    ggml_backend_buffer_t buf = ggml_backend_alloc_ctx_tensors(m->ctx_meta, m->plan.primary);
     if (buf == nullptr) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "%s: ggml_backend_alloc_ctx_tensors failed", kTag);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: ggml_backend_alloc_ctx_tensors failed", kTag);
         return TRANSCRIBE_ERR_GGUF;
     }
     m->backend_buffer = buf;
     ggml_backend_buffer_set_usage(buf, GGML_BACKEND_BUFFER_USAGE_WEIGHTS);
 
     // ---- Stream tensor bytes from the .bin ----
-    if (auto st = transcribe::bin_loader::stream_tensor_data_from_bin(
-            bm.path, stream_slots, "whisper");
-        st != TRANSCRIBE_OK)
-    {
+    if (auto st = transcribe::bin_loader::stream_tensor_data_from_bin(bm.path, stream_slots, "whisper");
+        st != TRANSCRIBE_OK) {
         return st;
     }
 
     // ---- Frontend: fill the catalog tensors and install MelFrontend ----
     {
-        std::vector<float> filterbank = bm.mel_filterbank;     // copy
+        std::vector<float> filterbank = bm.mel_filterbank;  // copy
         std::vector<float> window     = hann_periodic(m->hparams.fe_n_fft);
 
         // weights.frontend.* are populated for catalog completeness only (the
@@ -641,41 +625,35 @@ transcribe_status load_from_bin(const char *                           path,
             const size_t have = filterbank.size() * sizeof(float);
             if (have != want) {
                 log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                             "%s: mel filterbank size mismatch "
-                             "(have %zu bytes, expected %zu)",
-                             kTag, have, want);
+                        "%s: mel filterbank size mismatch "
+                        "(have %zu bytes, expected %zu)",
+                        kTag, have, want);
                 return TRANSCRIBE_ERR_GGUF;
             }
-            ggml_backend_tensor_set(
-                m->weights.frontend.mel_filterbank,
-                filterbank.data(), 0, have);
+            ggml_backend_tensor_set(m->weights.frontend.mel_filterbank, filterbank.data(), 0, have);
         }
         if (m->weights.frontend.window != nullptr) {
             const size_t want = ggml_nbytes(m->weights.frontend.window);
             const size_t have = window.size() * sizeof(float);
             if (have != want) {
                 log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                             "%s: hann window size mismatch "
-                             "(have %zu bytes, expected %zu)",
-                             kTag, have, want);
+                        "%s: hann window size mismatch "
+                        "(have %zu bytes, expected %zu)",
+                        kTag, have, want);
                 return TRANSCRIBE_ERR_GGUF;
             }
-            ggml_backend_tensor_set(
-                m->weights.frontend.window,
-                window.data(), 0, have);
+            ggml_backend_tensor_set(m->weights.frontend.window, window.data(), 0, have);
         }
 
-        if (auto st = install_mel_from_buffers(
-                m->hparams, std::move(filterbank), std::move(window), m->mel);
-            st != TRANSCRIBE_OK)
-        {
+        if (auto st = install_mel_from_buffers(m->hparams, std::move(filterbank), std::move(window), m->mel);
+            st != TRANSCRIBE_OK) {
             return st;
         }
     }
 
     m->t_load_us = ggml_time_us() - t_load_start;
-    *out_model = m.release();
+    *out_model   = m.release();
     return TRANSCRIBE_OK;
 }
 
-} // namespace transcribe::whisper
+}  // namespace transcribe::whisper
diff --git a/src/arch/whisper/bin_load.h b/src/arch/whisper/bin_load.h
index 5ddde41b..a08573fc 100644
--- a/src/arch/whisper/bin_load.h
+++ b/src/arch/whisper/bin_load.h
@@ -31,8 +31,8 @@ namespace transcribe::whisper {
 //   TRANSCRIBE_ERR_GGUF             - structural / tensor failure
 //   TRANSCRIBE_ERR_INVALID_ARG      - bad params
 //   TRANSCRIBE_ERR_BACKEND          - backend init failure
-transcribe_status load_from_bin(const char *                           path,
+transcribe_status load_from_bin(const char *                                path,
                                 const struct transcribe_model_load_params * params,
-                                struct transcribe_model **             out_model);
+                                struct transcribe_model **                  out_model);
 
-} // namespace transcribe::whisper
+}  // namespace transcribe::whisper
diff --git a/src/arch/whisper/capabilities.cpp b/src/arch/whisper/capabilities.cpp
index 478df099..565a9daf 100644
--- a/src/arch/whisper/capabilities.cpp
+++ b/src/arch/whisper/capabilities.cpp
@@ -22,10 +22,10 @@ void apply_family_invariants(transcribe_model & model) {
 
     // Run knobs are reached through transcribe_whisper_run_ext. No PNC/ITN
     // runtime toggle — whisper emits whatever its training distribution does.
-    transcribe::set_feature(&model, TRANSCRIBE_FEATURE_INITIAL_PROMPT,       true);
+    transcribe::set_feature(&model, TRANSCRIBE_FEATURE_INITIAL_PROMPT, true);
     transcribe::set_feature(&model, TRANSCRIBE_FEATURE_TEMPERATURE_FALLBACK, true);
-    transcribe::set_feature(&model, TRANSCRIBE_FEATURE_LONG_FORM,            true);
-    transcribe::set_feature(&model, TRANSCRIBE_FEATURE_CANCELLATION,         true);
+    transcribe::set_feature(&model, TRANSCRIBE_FEATURE_LONG_FORM, true);
+    transcribe::set_feature(&model, TRANSCRIBE_FEATURE_CANCELLATION, true);
 }
 
-} // namespace transcribe::whisper
+}  // namespace transcribe::whisper
diff --git a/src/arch/whisper/decoder.cpp b/src/arch/whisper/decoder.cpp
index e0a96f7c..4808dbbf 100644
--- a/src/arch/whisper/decoder.cpp
+++ b/src/arch/whisper/decoder.cpp
@@ -16,15 +16,13 @@
 
 #include "decoder.h"
 
-#include "encoder.h"      // for transcribe::conformer namespace alias context
-#include "weights.h"
-#include "whisper.h"
-
 #include "conformer/conformer.h"
+#include "encoder.h"  // for transcribe::conformer namespace alias context
+#include "ggml.h"
 #include "transcribe-debug.h"
 #include "transcribe-log.h"
-
-#include "ggml.h"
+#include "weights.h"
+#include "whisper.h"
 
 #include <algorithm>
 #include <cmath>
@@ -35,8 +33,8 @@ namespace transcribe::whisper {
 namespace {
 
 namespace conf = transcribe::conformer;
-using conf::named;
 using conf::layer_norm;
+using conf::named;
 
 // Standard multi-head attention used by both self- and cross-attention
 // in the decoder. context==nullptr selects self-attention (Q/K/V from x);
@@ -50,14 +48,16 @@ ggml_tensor * mha_decoder(ggml_context * ctx,
                           ggml_tensor *  x,
                           ggml_tensor *  context,
                           ggml_tensor *  mask,
-                          ggml_tensor *  q_w, ggml_tensor * q_b,
+                          ggml_tensor *  q_w,
+                          ggml_tensor *  q_b,
                           ggml_tensor *  k_w,
-                          ggml_tensor *  v_w, ggml_tensor * v_b,
-                          ggml_tensor *  out_w, ggml_tensor * out_b,
+                          ggml_tensor *  v_w,
+                          ggml_tensor *  v_b,
+                          ggml_tensor *  out_w,
+                          ggml_tensor *  out_b,
                           int            n_heads,
                           int            d_model,
-                          bool           use_flash)
-{
+                          bool           use_flash) {
     const int     head_dim = d_model / n_heads;
     const float   scale    = 1.0f / std::sqrt(static_cast<float>(head_dim));
     const int64_t T_q      = x->ne[1];
@@ -66,12 +66,16 @@ ggml_tensor * mha_decoder(ggml_context * ctx,
     const int64_t T_k    = source->ne[1];
 
     ggml_tensor * q = ggml_mul_mat(ctx, q_w, x);
-    if (q_b != nullptr) q = ggml_add(ctx, q, q_b);
+    if (q_b != nullptr) {
+        q = ggml_add(ctx, q, q_b);
+    }
 
     ggml_tensor * k = ggml_mul_mat(ctx, k_w, source);  // k has no bias
 
     ggml_tensor * v = ggml_mul_mat(ctx, v_w, source);
-    if (v_b != nullptr) v = ggml_add(ctx, v, v_b);
+    if (v_b != nullptr) {
+        v = ggml_add(ctx, v, v_b);
+    }
 
     // [d_model, T] -> [head_dim, n_heads, T] -> permute to
     // [head_dim, T, n_heads] for both flash and manual paths.
@@ -89,15 +93,14 @@ ggml_tensor * mha_decoder(ggml_context * ctx,
         ggml_tensor * q_c = ggml_cont(ctx, q);
         ggml_tensor * k_c = ggml_cont(ctx, k);
         ggml_tensor * v_c = ggml_cont(ctx, v);
-        o = ggml_flash_attn_ext(ctx, q_c, k_c, v_c, mask, scale, 0.0f, 0.0f);
-        o = ggml_reshape_2d(ctx, o, d_model, T_q);
+        o                 = ggml_flash_attn_ext(ctx, q_c, k_c, v_c, mask, scale, 0.0f, 0.0f);
+        o                 = ggml_reshape_2d(ctx, o, d_model, T_q);
     } else {
-        ggml_tensor * kq      = ggml_mul_mat(ctx, ggml_cont(ctx, k),
-                                             ggml_cont(ctx, q));
+        ggml_tensor * kq      = ggml_mul_mat(ctx, ggml_cont(ctx, k), ggml_cont(ctx, q));
         ggml_tensor * kq_soft = ggml_soft_max_ext(ctx, kq, mask, scale, 0.0f);
 
         ggml_tensor * v_t = ggml_cont(ctx, ggml_permute(ctx, v, 1, 0, 2, 3));
-        o = ggml_mul_mat(ctx, v_t, kq_soft);
+        o                 = ggml_mul_mat(ctx, v_t, kq_soft);
 
         o = ggml_permute(ctx, o, 0, 2, 1, 3);
         o = ggml_cont(ctx, o);
@@ -105,22 +108,30 @@ ggml_tensor * mha_decoder(ggml_context * ctx,
     }
 
     o = ggml_mul_mat(ctx, out_w, o);
-    if (out_b != nullptr) o = ggml_add(ctx, o, out_b);
+    if (out_b != nullptr) {
+        o = ggml_add(ctx, o, out_b);
+    }
     return o;
 }
 
 // FFN: fc1 -> GELU -> fc2. Both projections carry bias.
 ggml_tensor * ffn(ggml_context * ctx,
                   ggml_tensor *  x,
-                  ggml_tensor *  fc1_w, ggml_tensor * fc1_b,
-                  ggml_tensor *  fc2_w, ggml_tensor * fc2_b) {
+                  ggml_tensor *  fc1_w,
+                  ggml_tensor *  fc1_b,
+                  ggml_tensor *  fc2_w,
+                  ggml_tensor *  fc2_b) {
     ggml_tensor * h = ggml_mul_mat(ctx, fc1_w, x);
-    if (fc1_b != nullptr) h = ggml_add(ctx, h, fc1_b);
+    if (fc1_b != nullptr) {
+        h = ggml_add(ctx, h, fc1_b);
+    }
     // HF Whisper uses nn.functional.gelu (exact erf form); ggml_gelu
     // is the tanh approximation and drifts ~1e-4 per element.
-    h = ggml_gelu_erf(ctx, h);
+    h               = ggml_gelu_erf(ctx, h);
     ggml_tensor * o = ggml_mul_mat(ctx, fc2_w, h);
-    if (fc2_b != nullptr) o = ggml_add(ctx, o, fc2_b);
+    if (fc2_b != nullptr) {
+        o = ggml_add(ctx, o, fc2_b);
+    }
     return o;
 }
 
@@ -131,37 +142,26 @@ ggml_tensor * build_block(ggml_context *          ctx,
                           const WhisperDecBlock & b,
                           int                     n_heads,
                           int                     d_model,
-                          bool                    use_flash)
-{
+                          bool                    use_flash) {
     // Self-attention (causal).
     {
         ggml_tensor * y = layer_norm(ctx, x, b.norm_self_w, b.norm_self_b);
-        y = mha_decoder(ctx, y, /*context=*/nullptr, causal_mask,
-                        b.self_q_w, b.self_q_b,
-                        b.self_k_w,
-                        b.self_v_w, b.self_v_b,
-                        b.self_out_w, b.self_out_b,
-                        n_heads, d_model, use_flash);
+        y = mha_decoder(ctx, y, /*context=*/nullptr, causal_mask, b.self_q_w, b.self_q_b, b.self_k_w, b.self_v_w,
+                        b.self_v_b, b.self_out_w, b.self_out_b, n_heads, d_model, use_flash);
         x = ggml_add(ctx, x, y);
     }
     // Cross-attention (no mask; queries decoder state against encoder).
     {
         ggml_tensor * y = layer_norm(ctx, x, b.norm_cross_w, b.norm_cross_b);
-        y = mha_decoder(ctx, y, encoder_hidden, /*mask=*/nullptr,
-                        b.cross_q_w, b.cross_q_b,
-                        b.cross_k_w,
-                        b.cross_v_w, b.cross_v_b,
-                        b.cross_out_w, b.cross_out_b,
-                        n_heads, d_model, use_flash);
+        y = mha_decoder(ctx, y, encoder_hidden, /*mask=*/nullptr, b.cross_q_w, b.cross_q_b, b.cross_k_w, b.cross_v_w,
+                        b.cross_v_b, b.cross_out_w, b.cross_out_b, n_heads, d_model, use_flash);
         x = ggml_add(ctx, x, y);
     }
     // FFN.
     {
         ggml_tensor * y = layer_norm(ctx, x, b.norm_ffn_w, b.norm_ffn_b);
-        y = ffn(ctx, y,
-                b.ffn_fc1_w, b.ffn_fc1_b,
-                b.ffn_fc2_w, b.ffn_fc2_b);
-        x = ggml_add(ctx, x, y);
+        y               = ffn(ctx, y, b.ffn_fc1_w, b.ffn_fc1_b, b.ffn_fc2_w, b.ffn_fc2_b);
+        x               = ggml_add(ctx, x, y);
     }
     return x;
 }
@@ -188,37 +188,43 @@ ggml_tensor * mha_self_cached(ggml_context *   ctx,
                               ggml_tensor *    x,
                               WhisperKvCache & kv_cache,
                               ggml_tensor *    mask,
-                              ggml_tensor *    q_w, ggml_tensor * q_b,
+                              ggml_tensor *    q_w,
+                              ggml_tensor *    q_b,
                               ggml_tensor *    k_w,
-                              ggml_tensor *    v_w, ggml_tensor * v_b,
-                              ggml_tensor *    out_w, ggml_tensor * out_b,
+                              ggml_tensor *    v_w,
+                              ggml_tensor *    v_b,
+                              ggml_tensor *    out_w,
+                              ggml_tensor *    out_b,
                               int              n_heads,
                               int              d_model,
                               int              il,
                               int              n_past,
                               int              n_tokens,
                               int              n_kv,
-                              bool             use_flash)
-{
-    const int head_dim = d_model / n_heads;
-    const float scale  = 1.0f / std::sqrt(static_cast<float>(head_dim));
-    const int n_ctx    = kv_cache.n_ctx;
+                              bool             use_flash) {
+    const int   head_dim = d_model / n_heads;
+    const float scale    = 1.0f / std::sqrt(static_cast<float>(head_dim));
+    const int   n_ctx    = kv_cache.n_ctx;
     // n_kv may be padded beyond n_past + n_tokens (FA-friendly multiple);
     // trailing slots are masked to -inf. The cache write still touches only
     // [n_past, n_past+n_tokens).
 
     // Q / K / V projections for the new tokens only.
     ggml_tensor * Qcur = ggml_mul_mat(ctx, q_w, x);
-    if (q_b != nullptr) Qcur = ggml_add(ctx, Qcur, q_b);
+    if (q_b != nullptr) {
+        Qcur = ggml_add(ctx, Qcur, q_b);
+    }
 
     ggml_tensor * Kcur = ggml_mul_mat(ctx, k_w, x);
 
     ggml_tensor * Vcur = ggml_mul_mat(ctx, v_w, x);
-    if (v_b != nullptr) Vcur = ggml_add(ctx, Vcur, v_b);
+    if (v_b != nullptr) {
+        Vcur = ggml_add(ctx, Vcur, v_b);
+    }
 
     // Q in [head_dim, n_tokens, n_heads] for flash / manual paths.
     ggml_tensor * Q = ggml_reshape_3d(ctx, Qcur, head_dim, n_heads, n_tokens);
-    Q = ggml_permute(ctx, Q, 0, 2, 1, 3);
+    Q               = ggml_permute(ctx, Q, 0, 2, 1, 3);
 
     // Write new K/V into the cache. Layout is [hidden, n_ctx] per layer,
     // stored as a flat 1D buffer. Layer il occupies
@@ -227,42 +233,28 @@ ggml_tensor * mha_self_cached(ggml_context *   ctx,
         const size_t k_elem = ggml_element_size(kv_cache.self_k);
         const size_t v_elem = ggml_element_size(kv_cache.self_v);
 
-        ggml_tensor * k_dst = ggml_view_1d(
-            ctx, kv_cache.self_k,
-            static_cast<int64_t>(n_tokens) * d_model,
-            k_elem * static_cast<size_t>(
-                static_cast<int64_t>(il) * n_ctx * d_model +
-                static_cast<int64_t>(n_past) * d_model));
+        ggml_tensor * k_dst = ggml_view_1d(ctx, kv_cache.self_k, static_cast<int64_t>(n_tokens) * d_model,
+                                           k_elem * static_cast<size_t>(static_cast<int64_t>(il) * n_ctx * d_model +
+                                                                        static_cast<int64_t>(n_past) * d_model));
 
-        ggml_tensor * v_dst = ggml_view_1d(
-            ctx, kv_cache.self_v,
-            static_cast<int64_t>(n_tokens) * d_model,
-            v_elem * static_cast<size_t>(
-                static_cast<int64_t>(il) * n_ctx * d_model +
-                static_cast<int64_t>(n_past) * d_model));
+        ggml_tensor * v_dst = ggml_view_1d(ctx, kv_cache.self_v, static_cast<int64_t>(n_tokens) * d_model,
+                                           v_elem * static_cast<size_t>(static_cast<int64_t>(il) * n_ctx * d_model +
+                                                                        static_cast<int64_t>(n_past) * d_model));
 
         ggml_build_forward_expand(gf, ggml_cpy(ctx, Kcur, k_dst));
         ggml_build_forward_expand(gf, ggml_cpy(ctx, Vcur, v_dst));
     }
 
     // Read K / V as [head_dim, n_kv, n_heads] for attention.
-    const size_t k_elem = ggml_element_size(kv_cache.self_k);
-    ggml_tensor * K = ggml_view_3d(
-        ctx, kv_cache.self_k,
-        head_dim, n_kv, n_heads,
-        k_elem * d_model,        // nb1: stride between positions (one full d_model row)
-        k_elem * head_dim,       // nb2: stride between heads inside a position
-        k_elem * static_cast<size_t>(
-            static_cast<int64_t>(il) * n_ctx * d_model));
-
-    const size_t v_elem = ggml_element_size(kv_cache.self_v);
-    ggml_tensor * V = ggml_view_3d(
-        ctx, kv_cache.self_v,
-        head_dim, n_kv, n_heads,
-        v_elem * d_model,
-        v_elem * head_dim,
-        v_elem * static_cast<size_t>(
-            static_cast<int64_t>(il) * n_ctx * d_model));
+    const size_t  k_elem = ggml_element_size(kv_cache.self_k);
+    ggml_tensor * K      = ggml_view_3d(ctx, kv_cache.self_k, head_dim, n_kv, n_heads,
+                                        k_elem * d_model,   // nb1: stride between positions (one full d_model row)
+                                        k_elem * head_dim,  // nb2: stride between heads inside a position
+                                        k_elem * static_cast<size_t>(static_cast<int64_t>(il) * n_ctx * d_model));
+
+    const size_t  v_elem = ggml_element_size(kv_cache.self_v);
+    ggml_tensor * V = ggml_view_3d(ctx, kv_cache.self_v, head_dim, n_kv, n_heads, v_elem * d_model, v_elem * head_dim,
+                                   v_elem * static_cast<size_t>(static_cast<int64_t>(il) * n_ctx * d_model));
 
     ggml_tensor * o;
     if (use_flash) {
@@ -272,14 +264,16 @@ ggml_tensor * mha_self_cached(ggml_context *   ctx,
         ggml_tensor * kq      = ggml_mul_mat(ctx, K, Q);
         ggml_tensor * kq_soft = ggml_soft_max_ext(ctx, kq, mask, scale, 0.0f);
         ggml_tensor * v_t     = ggml_cont(ctx, ggml_permute(ctx, V, 1, 0, 2, 3));
-        o = ggml_mul_mat(ctx, v_t, kq_soft);
-        o = ggml_permute(ctx, o, 0, 2, 1, 3);
-        o = ggml_cont(ctx, o);
-        o = ggml_reshape_2d(ctx, o, d_model, n_tokens);
+        o                     = ggml_mul_mat(ctx, v_t, kq_soft);
+        o                     = ggml_permute(ctx, o, 0, 2, 1, 3);
+        o                     = ggml_cont(ctx, o);
+        o                     = ggml_reshape_2d(ctx, o, d_model, n_tokens);
     }
 
     o = ggml_mul_mat(ctx, out_w, o);
-    if (out_b != nullptr) o = ggml_add(ctx, o, out_b);
+    if (out_b != nullptr) {
+        o = ggml_add(ctx, o, out_b);
+    }
     return o;
 }
 
@@ -293,77 +287,65 @@ ggml_tensor * mha_self_step(ggml_context *   ctx,
                             WhisperKvCache & kv_cache,
                             ggml_tensor *    mask,
                             ggml_tensor *    kv_idx,
-                            ggml_tensor *    q_w, ggml_tensor * q_b,
+                            ggml_tensor *    q_w,
+                            ggml_tensor *    q_b,
                             ggml_tensor *    k_w,
-                            ggml_tensor *    v_w, ggml_tensor * v_b,
-                            ggml_tensor *    out_w, ggml_tensor * out_b,
+                            ggml_tensor *    v_w,
+                            ggml_tensor *    v_b,
+                            ggml_tensor *    out_w,
+                            ggml_tensor *    out_b,
                             int              n_heads,
                             int              d_model,
                             int              il,
                             int              max_n_kv,
-                            bool             use_flash)
-{
-    const int head_dim = d_model / n_heads;
-    const float scale  = 1.0f / std::sqrt(static_cast<float>(head_dim));
-    const int n_ctx    = kv_cache.n_ctx;
+                            bool             use_flash) {
+    const int   head_dim = d_model / n_heads;
+    const float scale    = 1.0f / std::sqrt(static_cast<float>(head_dim));
+    const int   n_ctx    = kv_cache.n_ctx;
 
     ggml_tensor * Qcur = ggml_mul_mat(ctx, q_w, x);
-    if (q_b != nullptr) Qcur = ggml_add(ctx, Qcur, q_b);
+    if (q_b != nullptr) {
+        Qcur = ggml_add(ctx, Qcur, q_b);
+    }
 
     ggml_tensor * Kcur = ggml_mul_mat(ctx, k_w, x);
 
     ggml_tensor * Vcur = ggml_mul_mat(ctx, v_w, x);
-    if (v_b != nullptr) Vcur = ggml_add(ctx, Vcur, v_b);
+    if (v_b != nullptr) {
+        Vcur = ggml_add(ctx, Vcur, v_b);
+    }
 
     ggml_tensor * Q = ggml_reshape_3d(ctx, Qcur, head_dim, n_heads, /*n_tokens=*/1);
-    Q = ggml_permute(ctx, Q, 0, 2, 1, 3);
+    Q               = ggml_permute(ctx, Q, 0, 2, 1, 3);
 
     // KV cache write via ggml_set_rows. Per-layer view spans [d_model, n_ctx];
     // we write one [d_model, 1] row at the kv_idx position.
     {
-        const size_t k_elem = ggml_element_size(kv_cache.self_k);
-        const size_t v_elem = ggml_element_size(kv_cache.self_v);
-        const size_t layer_off_k = k_elem * static_cast<size_t>(
-            static_cast<int64_t>(il) * n_ctx * d_model);
-        const size_t layer_off_v = v_elem * static_cast<size_t>(
-            static_cast<int64_t>(il) * n_ctx * d_model);
-
-        ggml_tensor * k_layer = ggml_view_2d(
-            ctx, kv_cache.self_k,
-            d_model, n_ctx,
-            k_elem * d_model, layer_off_k);
-        ggml_tensor * v_layer = ggml_view_2d(
-            ctx, kv_cache.self_v,
-            d_model, n_ctx,
-            v_elem * d_model, layer_off_v);
+        const size_t k_elem      = ggml_element_size(kv_cache.self_k);
+        const size_t v_elem      = ggml_element_size(kv_cache.self_v);
+        const size_t layer_off_k = k_elem * static_cast<size_t>(static_cast<int64_t>(il) * n_ctx * d_model);
+        const size_t layer_off_v = v_elem * static_cast<size_t>(static_cast<int64_t>(il) * n_ctx * d_model);
+
+        ggml_tensor * k_layer = ggml_view_2d(ctx, kv_cache.self_k, d_model, n_ctx, k_elem * d_model, layer_off_k);
+        ggml_tensor * v_layer = ggml_view_2d(ctx, kv_cache.self_v, d_model, n_ctx, v_elem * d_model, layer_off_v);
 
         ggml_tensor * K_row = ggml_reshape_2d(ctx, Kcur, d_model, 1);
         ggml_tensor * V_row = ggml_reshape_2d(ctx, Vcur, d_model, 1);
 
-        ggml_build_forward_expand(
-            gf, ggml_set_rows(ctx, k_layer, K_row, kv_idx));
-        ggml_build_forward_expand(
-            gf, ggml_set_rows(ctx, v_layer, V_row, kv_idx));
+        ggml_build_forward_expand(gf, ggml_set_rows(ctx, k_layer, K_row, kv_idx));
+        ggml_build_forward_expand(gf, ggml_set_rows(ctx, v_layer, V_row, kv_idx));
     }
 
     // Static read across [0, max_n_kv).
-    const size_t k_elem = ggml_element_size(kv_cache.self_k);
-    ggml_tensor * K = ggml_view_3d(
-        ctx, kv_cache.self_k,
-        head_dim, max_n_kv, n_heads,
-        k_elem * d_model,
-        k_elem * head_dim,
-        k_elem * static_cast<size_t>(
-            static_cast<int64_t>(il) * n_ctx * d_model));
-
-    const size_t v_elem = ggml_element_size(kv_cache.self_v);
-    ggml_tensor * V = ggml_view_3d(
-        ctx, kv_cache.self_v,
-        head_dim, max_n_kv, n_heads,
-        v_elem * d_model,
-        v_elem * head_dim,
-        v_elem * static_cast<size_t>(
-            static_cast<int64_t>(il) * n_ctx * d_model));
+    const size_t  k_elem = ggml_element_size(kv_cache.self_k);
+    ggml_tensor * K =
+        ggml_view_3d(ctx, kv_cache.self_k, head_dim, max_n_kv, n_heads, k_elem * d_model, k_elem * head_dim,
+                     k_elem * static_cast<size_t>(static_cast<int64_t>(il) * n_ctx * d_model));
+
+    const size_t  v_elem = ggml_element_size(kv_cache.self_v);
+    ggml_tensor * V =
+        ggml_view_3d(ctx, kv_cache.self_v, head_dim, max_n_kv, n_heads, v_elem * d_model, v_elem * head_dim,
+                     v_elem * static_cast<size_t>(static_cast<int64_t>(il) * n_ctx * d_model));
 
     ggml_tensor * o;
     if (use_flash) {
@@ -373,14 +355,16 @@ ggml_tensor * mha_self_step(ggml_context *   ctx,
         ggml_tensor * kq      = ggml_mul_mat(ctx, K, Q);
         ggml_tensor * kq_soft = ggml_soft_max_ext(ctx, kq, mask, scale, 0.0f);
         ggml_tensor * v_t     = ggml_cont(ctx, ggml_permute(ctx, V, 1, 0, 2, 3));
-        o = ggml_mul_mat(ctx, v_t, kq_soft);
-        o = ggml_permute(ctx, o, 0, 2, 1, 3);
-        o = ggml_cont(ctx, o);
-        o = ggml_reshape_2d(ctx, o, d_model, 1);
+        o                     = ggml_mul_mat(ctx, v_t, kq_soft);
+        o                     = ggml_permute(ctx, o, 0, 2, 1, 3);
+        o                     = ggml_cont(ctx, o);
+        o                     = ggml_reshape_2d(ctx, o, d_model, 1);
     }
 
     o = ggml_mul_mat(ctx, out_w, o);
-    if (out_b != nullptr) o = ggml_add(ctx, o, out_b);
+    if (out_b != nullptr) {
+        o = ggml_add(ctx, o, out_b);
+    }
     return o;
 }
 
@@ -390,49 +374,43 @@ ggml_tensor * mha_cross_cached(ggml_context *   ctx,
                                ggml_tensor *    x,
                                WhisperKvCache & kv_cache,
                                ggml_tensor *    mask,
-                               ggml_tensor *    q_w, ggml_tensor * q_b,
-                               ggml_tensor *    out_w, ggml_tensor * out_b,
+                               ggml_tensor *    q_w,
+                               ggml_tensor *    q_b,
+                               ggml_tensor *    out_w,
+                               ggml_tensor *    out_b,
                                int              n_heads,
                                int              d_model,
                                int              il,
                                int              T_enc,
-                               bool             use_flash)
-{
-    const int head_dim = d_model / n_heads;
-    const float scale  = 1.0f / std::sqrt(static_cast<float>(head_dim));
+                               bool             use_flash) {
+    const int     head_dim = d_model / n_heads;
+    const float   scale    = 1.0f / std::sqrt(static_cast<float>(head_dim));
     const int64_t n_tokens = x->ne[1];
 
     // Cross cache is T_enc_pad rows per layer; trailing rows hold zeros (never
     // written). FA reads the padded shape — kernel-friendly seq dim at the cost
     // of small dilution unless the caller masks the padded slots.
-    const int T_enc_pad = kv_cache.T_enc_pad > 0
-                              ? kv_cache.T_enc_pad : T_enc;
-    (void)T_enc;
+    const int T_enc_pad = kv_cache.T_enc_pad > 0 ? kv_cache.T_enc_pad : T_enc;
+    (void) T_enc;
 
     // Q from current input; K / V read from the cross cache.
     ggml_tensor * Qcur = ggml_mul_mat(ctx, q_w, x);
-    if (q_b != nullptr) Qcur = ggml_add(ctx, Qcur, q_b);
+    if (q_b != nullptr) {
+        Qcur = ggml_add(ctx, Qcur, q_b);
+    }
 
     ggml_tensor * Q = ggml_reshape_3d(ctx, Qcur, head_dim, n_heads, n_tokens);
-    Q = ggml_permute(ctx, Q, 0, 2, 1, 3);
+    Q               = ggml_permute(ctx, Q, 0, 2, 1, 3);
 
-    const size_t k_elem = ggml_element_size(kv_cache.cross_k);
-    ggml_tensor * K = ggml_view_3d(
-        ctx, kv_cache.cross_k,
-        head_dim, T_enc_pad, n_heads,
-        k_elem * d_model,
-        k_elem * head_dim,
-        k_elem * static_cast<size_t>(
-            static_cast<int64_t>(il) * T_enc_pad * d_model));
+    const size_t  k_elem = ggml_element_size(kv_cache.cross_k);
+    ggml_tensor * K =
+        ggml_view_3d(ctx, kv_cache.cross_k, head_dim, T_enc_pad, n_heads, k_elem * d_model, k_elem * head_dim,
+                     k_elem * static_cast<size_t>(static_cast<int64_t>(il) * T_enc_pad * d_model));
 
-    const size_t v_elem = ggml_element_size(kv_cache.cross_v);
-    ggml_tensor * V = ggml_view_3d(
-        ctx, kv_cache.cross_v,
-        head_dim, T_enc_pad, n_heads,
-        v_elem * d_model,
-        v_elem * head_dim,
-        v_elem * static_cast<size_t>(
-            static_cast<int64_t>(il) * T_enc_pad * d_model));
+    const size_t  v_elem = ggml_element_size(kv_cache.cross_v);
+    ggml_tensor * V =
+        ggml_view_3d(ctx, kv_cache.cross_v, head_dim, T_enc_pad, n_heads, v_elem * d_model, v_elem * head_dim,
+                     v_elem * static_cast<size_t>(static_cast<int64_t>(il) * T_enc_pad * d_model));
 
     ggml_tensor * o;
     if (use_flash) {
@@ -442,40 +420,41 @@ ggml_tensor * mha_cross_cached(ggml_context *   ctx,
         ggml_tensor * kq      = ggml_mul_mat(ctx, K, Q);
         ggml_tensor * kq_soft = ggml_soft_max_ext(ctx, kq, mask, scale, 0.0f);
         ggml_tensor * v_t     = ggml_cont(ctx, ggml_permute(ctx, V, 1, 0, 2, 3));
-        o = ggml_mul_mat(ctx, v_t, kq_soft);
-        o = ggml_permute(ctx, o, 0, 2, 1, 3);
-        o = ggml_cont(ctx, o);
-        o = ggml_reshape_2d(ctx, o, d_model, n_tokens);
+        o                     = ggml_mul_mat(ctx, v_t, kq_soft);
+        o                     = ggml_permute(ctx, o, 0, 2, 1, 3);
+        o                     = ggml_cont(ctx, o);
+        o                     = ggml_reshape_2d(ctx, o, d_model, n_tokens);
     }
 
     o = ggml_mul_mat(ctx, out_w, o);
-    if (out_b != nullptr) o = ggml_add(ctx, o, out_b);
+    if (out_b != nullptr) {
+        o = ggml_add(ctx, o, out_b);
+    }
     return o;
 }
 
-} // namespace
+}  // namespace
 
 DecoderBuild build_decoder_prefill_graph(ggml_context *         ctx,
                                          const WhisperWeights & w,
                                          const WhisperHParams & hp,
                                          int                    seq_len,
                                          int                    T_enc,
-                                         bool                   use_flash)
-{
-    DecoderBuild db {};
+                                         bool                   use_flash) {
+    DecoderBuild db{};
 
     if (ctx == nullptr || seq_len <= 0 || T_enc <= 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "whisper decoder: invalid arg "
-                     "(ctx=%p, seq_len=%d, T_enc=%d)",
-                     static_cast<void *>(ctx), seq_len, T_enc);
+                "whisper decoder: invalid arg "
+                "(ctx=%p, seq_len=%d, T_enc=%d)",
+                static_cast<void *>(ctx), seq_len, T_enc);
         return db;
     }
     if (seq_len > hp.dec_max_target_positions) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "whisper decoder: seq_len=%d exceeds "
-                     "max_target_positions=%d",
-                     seq_len, hp.dec_max_target_positions);
+                "whisper decoder: seq_len=%d exceeds "
+                "max_target_positions=%d",
+                seq_len, hp.dec_max_target_positions);
         return db;
     }
 
@@ -496,8 +475,7 @@ DecoderBuild build_decoder_prefill_graph(ggml_context *         ctx,
     // soft_max_ext want f16).
     ggml_tensor * causal_mask = nullptr;
     if (seq_len > 1) {
-        db.causal_mask_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32,
-                                               seq_len, seq_len);
+        db.causal_mask_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, seq_len, seq_len);
         named(db.causal_mask_in, "dec.causal_mask");
         ggml_set_input(db.causal_mask_in);
         causal_mask = ggml_cast(ctx, db.causal_mask_in, GGML_TYPE_F16);
@@ -505,8 +483,7 @@ DecoderBuild build_decoder_prefill_graph(ggml_context *         ctx,
 
     // ---- Token embedding ----
     // get_rows(token_embd_w [d_model, vocab], ids [seq_len]) -> [d_model, seq_len].
-    ggml_tensor * tok_emb = ggml_get_rows(ctx, w.dec_top.token_embd_w,
-                                          db.token_ids_in);
+    ggml_tensor * tok_emb = ggml_get_rows(ctx, w.dec_top.token_embd_w, db.token_ids_in);
     named(tok_emb, "dec.token_emb");
     transcribe::debug::mark_tensor_for_dump(tok_emb);
     db.dumps.token_emb = tok_emb;
@@ -516,9 +493,7 @@ DecoderBuild build_decoder_prefill_graph(ggml_context *         ctx,
     // view of the leading seq_len rows is the same data (no pos-id input).
     ggml_tensor * pos_emb = w.dec_top.pos_emb_w;
     if (seq_len != hp.dec_max_target_positions) {
-        pos_emb = ggml_view_2d(ctx, w.dec_top.pos_emb_w,
-                               d_model, seq_len,
-                               w.dec_top.pos_emb_w->nb[1], 0);
+        pos_emb = ggml_view_2d(ctx, w.dec_top.pos_emb_w, d_model, seq_len, w.dec_top.pos_emb_w->nb[1], 0);
     }
     named(pos_emb, "dec.pos_emb");
     transcribe::debug::mark_tensor_for_dump(pos_emb);
@@ -534,8 +509,7 @@ DecoderBuild build_decoder_prefill_graph(ggml_context *         ctx,
     const int n_blocks = static_cast<int>(w.dec_blocks.size());
     db.dumps.block_outs.reserve(static_cast<size_t>(n_blocks));
     for (int i = 0; i < n_blocks; ++i) {
-        x = build_block(ctx, x, db.encoder_out_in, causal_mask,
-                        w.dec_blocks[i], n_heads, d_model, use_flash);
+        x = build_block(ctx, x, db.encoder_out_in, causal_mask, w.dec_blocks[i], n_heads, d_model, use_flash);
 
         char bname[64];
         std::snprintf(bname, sizeof(bname), "dec.block.%d.out", i);
@@ -568,13 +542,12 @@ DecoderBuild build_decoder_prefill_graph(ggml_context *         ctx,
     // 8192 leaves headroom up to large-v3 (32 blocks, ~20 ops each).
     db.graph = ggml_new_graph_custom(ctx, 8192, false);
     if (db.graph == nullptr) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "whisper decoder: ggml_new_graph_custom failed");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "whisper decoder: ggml_new_graph_custom failed");
         return db;
     }
     ggml_build_forward_expand(db.graph, db.out);
 
-    (void)vocab;
+    (void) vocab;
 
     return db;
 }
@@ -586,16 +559,14 @@ DecoderBuild build_cross_kv_graph(ggml_context *         ctx,
                                   const WhisperHParams & hp,
                                   WhisperKvCache &       kv_cache,
                                   ggml_tensor *          encoder_out,
-                                  int                    T_enc)
-{
-    DecoderBuild db {};
+                                  int                    T_enc) {
+    DecoderBuild db{};
 
     if (ctx == nullptr || encoder_out == nullptr || T_enc <= 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "whisper cross_kv: invalid arg "
-                     "(ctx=%p, encoder_out=%p, T_enc=%d)",
-                     static_cast<void *>(ctx),
-                     static_cast<void *>(encoder_out), T_enc);
+                "whisper cross_kv: invalid arg "
+                "(ctx=%p, encoder_out=%p, T_enc=%d)",
+                static_cast<void *>(ctx), static_cast<void *>(encoder_out), T_enc);
         return db;
     }
 
@@ -603,32 +574,26 @@ DecoderBuild build_cross_kv_graph(ggml_context *         ctx,
 
     // View the persistent encoder_out tensor into this compute_ctx (no copy;
     // shares storage with the encoder-populated source on the same backend).
-    db.encoder_out_in = ggml_view_2d(ctx, encoder_out,
-                                     d_model, T_enc,
-                                     encoder_out->nb[1], 0);
+    db.encoder_out_in = ggml_view_2d(ctx, encoder_out, d_model, T_enc, encoder_out->nb[1], 0);
     named(db.encoder_out_in, "dec.encoder_out");
 
     db.graph = ggml_new_graph_custom(ctx, 4096, false);
     if (db.graph == nullptr) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "whisper cross_kv: ggml_new_graph_custom failed");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "whisper cross_kv: ggml_new_graph_custom failed");
         return db;
     }
 
     // Layer slots are spaced by T_enc_pad (allocator size) but each writes
     // only T_enc rows; trailing T_enc_pad - T_enc rows stay zero.
-    const int T_enc_pad = kv_cache.T_enc_pad > 0
-                              ? kv_cache.T_enc_pad : T_enc;
+    const int T_enc_pad = kv_cache.T_enc_pad > 0 ? kv_cache.T_enc_pad : T_enc;
 
     const int n_layers = static_cast<int>(w.dec_blocks.size());
     for (int il = 0; il < n_layers; ++il) {
         const auto & blk = w.dec_blocks[il];
 
         // Cross k has no bias; cross v does.
-        ggml_tensor * Kcross = ggml_mul_mat(ctx, blk.cross_k_w,
-                                            db.encoder_out_in);
-        ggml_tensor * Vcross = ggml_mul_mat(ctx, blk.cross_v_w,
-                                            db.encoder_out_in);
+        ggml_tensor * Kcross = ggml_mul_mat(ctx, blk.cross_k_w, db.encoder_out_in);
+        ggml_tensor * Vcross = ggml_mul_mat(ctx, blk.cross_v_w, db.encoder_out_in);
         if (blk.cross_v_b != nullptr) {
             Vcross = ggml_add(ctx, Vcross, blk.cross_v_b);
         }
@@ -638,17 +603,13 @@ DecoderBuild build_cross_kv_graph(ggml_context *         ctx,
         const size_t k_elem = ggml_element_size(kv_cache.cross_k);
         const size_t v_elem = ggml_element_size(kv_cache.cross_v);
 
-        ggml_tensor * k_dst = ggml_view_1d(
-            ctx, kv_cache.cross_k,
-            static_cast<int64_t>(T_enc) * d_model,
-            k_elem * static_cast<size_t>(
-                static_cast<int64_t>(il) * T_enc_pad * d_model));
+        ggml_tensor * k_dst =
+            ggml_view_1d(ctx, kv_cache.cross_k, static_cast<int64_t>(T_enc) * d_model,
+                         k_elem * static_cast<size_t>(static_cast<int64_t>(il) * T_enc_pad * d_model));
 
-        ggml_tensor * v_dst = ggml_view_1d(
-            ctx, kv_cache.cross_v,
-            static_cast<int64_t>(T_enc) * d_model,
-            v_elem * static_cast<size_t>(
-                static_cast<int64_t>(il) * T_enc_pad * d_model));
+        ggml_tensor * v_dst =
+            ggml_view_1d(ctx, kv_cache.cross_v, static_cast<int64_t>(T_enc) * d_model,
+                         v_elem * static_cast<size_t>(static_cast<int64_t>(il) * T_enc_pad * d_model));
 
         ggml_build_forward_expand(db.graph, ggml_cpy(ctx, Kcross, k_dst));
         ggml_build_forward_expand(db.graph, ggml_cpy(ctx, Vcross, v_dst));
@@ -666,22 +627,20 @@ DecoderBuild build_decoder_graph_kv(ggml_context *         ctx,
                                     int                    T_enc,
                                     int                    kv_pad,
                                     bool                   skip_log_softmax,
-                                    bool                   use_flash)
-{
-    DecoderBuild db {};
+                                    bool                   use_flash) {
+    DecoderBuild db{};
 
     if (ctx == nullptr || n_tokens <= 0 || T_enc <= 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "whisper decoder_kv: invalid arg "
-                     "(ctx=%p, n_tokens=%d, T_enc=%d)",
-                     static_cast<void *>(ctx), n_tokens, T_enc);
+                "whisper decoder_kv: invalid arg "
+                "(ctx=%p, n_tokens=%d, T_enc=%d)",
+                static_cast<void *>(ctx), n_tokens, T_enc);
         return db;
     }
     const int n_kv_active = n_past + n_tokens;
     if (n_kv_active > kv_cache.n_ctx) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "whisper decoder_kv: n_kv=%d exceeds n_ctx=%d",
-                     n_kv_active, kv_cache.n_ctx);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "whisper decoder_kv: n_kv=%d exceeds n_ctx=%d", n_kv_active,
+                kv_cache.n_ctx);
         return db;
     }
 
@@ -689,11 +648,12 @@ DecoderBuild build_decoder_graph_kv(ggml_context *         ctx,
     // [n_kv_active, n_kv) hold zeros or stale K/V; the mask zeroes them.
     // Clamp to n_ctx so we don't read past the allocation.
     const int kv_pad_eff = kv_pad > 0 ? kv_pad : 1;
-    int n_kv = n_kv_active;
+    int       n_kv       = n_kv_active;
     if (kv_pad_eff > 1) {
-        n_kv = std::max(kv_pad_eff,
-                        static_cast<int>(GGML_PAD(n_kv_active, kv_pad_eff)));
-        if (n_kv > kv_cache.n_ctx) n_kv = kv_cache.n_ctx;
+        n_kv = std::max(kv_pad_eff, static_cast<int>(GGML_PAD(n_kv_active, kv_pad_eff)));
+        if (n_kv > kv_cache.n_ctx) {
+            n_kv = kv_cache.n_ctx;
+        }
     }
     const bool has_padding = n_kv > n_kv_active;
 
@@ -716,35 +676,30 @@ DecoderBuild build_decoder_graph_kv(ggml_context *         ctx,
     // and for k > q + n_past. Omitted on the unpadded single-token step (it
     // attends the full real cache window); model.cpp fills the values.
     ggml_tensor * causal_mask = nullptr;
-    const bool need_mask = (n_tokens > 1) || has_padding;
+    const bool    need_mask   = (n_tokens > 1) || has_padding;
     if (need_mask) {
-        db.causal_mask_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32,
-                                               n_kv, n_tokens);
+        db.causal_mask_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, n_kv, n_tokens);
         named(db.causal_mask_in, "dec.causal_mask");
         ggml_set_input(db.causal_mask_in);
         causal_mask = ggml_cast(ctx, db.causal_mask_in, GGML_TYPE_F16);
     } else {
-        GGML_ASSERT(n_tokens == 1 &&
-                    "decoder_kv mask-null branch requires single-token step");
+        GGML_ASSERT(n_tokens == 1 && "decoder_kv mask-null branch requires single-token step");
     }
 
     // Cross-attention mask, only when the cross cache is padded (T_enc_pad >
     // T_enc): the trailing zero-K/V slots would dilute the FA softmax, so -inf
     // there restores equivalence to an unpadded view.
     ggml_tensor * cross_mask = nullptr;
-    const int T_enc_pad = kv_cache.T_enc_pad > 0
-                              ? kv_cache.T_enc_pad : T_enc;
+    const int     T_enc_pad  = kv_cache.T_enc_pad > 0 ? kv_cache.T_enc_pad : T_enc;
     if (T_enc_pad > T_enc) {
-        db.cross_mask_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32,
-                                              T_enc_pad, n_tokens);
+        db.cross_mask_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, T_enc_pad, n_tokens);
         named(db.cross_mask_in, "dec.cross_mask");
         ggml_set_input(db.cross_mask_in);
         cross_mask = ggml_cast(ctx, db.cross_mask_in, GGML_TYPE_F16);
     }
 
     // ---- Token embedding ----
-    ggml_tensor * tok_emb = ggml_get_rows(ctx, w.dec_top.token_embd_w,
-                                          db.token_ids_in);
+    ggml_tensor * tok_emb = ggml_get_rows(ctx, w.dec_top.token_embd_w, db.token_ids_in);
     named(tok_emb, "dec.token_emb");
     if (n_past == 0) {
         transcribe::debug::mark_tensor_for_dump(tok_emb);
@@ -752,8 +707,7 @@ DecoderBuild build_decoder_graph_kv(ggml_context *         ctx,
     }
 
     // ---- Positional embedding ----
-    ggml_tensor * pos_emb = ggml_get_rows(ctx, w.dec_top.pos_emb_w,
-                                          pos_ids_in);
+    ggml_tensor * pos_emb = ggml_get_rows(ctx, w.dec_top.pos_emb_w, pos_ids_in);
     named(pos_emb, "dec.pos_emb");
     if (n_past == 0) {
         transcribe::debug::mark_tensor_for_dump(pos_emb);
@@ -771,8 +725,7 @@ DecoderBuild build_decoder_graph_kv(ggml_context *         ctx,
     // Pre-create the graph so mha_self_cached can wire cache writes into it.
     db.graph = ggml_new_graph_custom(ctx, 8192, false);
     if (db.graph == nullptr) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "whisper decoder_kv: ggml_new_graph_custom failed");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "whisper decoder_kv: ggml_new_graph_custom failed");
         return db;
     }
 
@@ -785,33 +738,23 @@ DecoderBuild build_decoder_graph_kv(ggml_context *         ctx,
         // Self-attention (pre-LN, causal via mask when prompt pass).
         {
             ggml_tensor * y = layer_norm(ctx, x, b.norm_self_w, b.norm_self_b);
-            y = mha_self_cached(
-                ctx, db.graph, y, kv_cache, causal_mask,
-                b.self_q_w, b.self_q_b,
-                b.self_k_w,
-                b.self_v_w, b.self_v_b,
-                b.self_out_w, b.self_out_b,
-                n_heads, d_model,
-                i, n_past, n_tokens, n_kv, use_flash);
+            y = mha_self_cached(ctx, db.graph, y, kv_cache, causal_mask, b.self_q_w, b.self_q_b, b.self_k_w, b.self_v_w,
+                                b.self_v_b, b.self_out_w, b.self_out_b, n_heads, d_model, i, n_past, n_tokens, n_kv,
+                                use_flash);
             x = ggml_add(ctx, x, y);
         }
         // Cross-attention (pre-LN, reads cross cache).
         {
             ggml_tensor * y = layer_norm(ctx, x, b.norm_cross_w, b.norm_cross_b);
-            y = mha_cross_cached(
-                ctx, y, kv_cache, cross_mask,
-                b.cross_q_w, b.cross_q_b,
-                b.cross_out_w, b.cross_out_b,
-                n_heads, d_model, i, T_enc, use_flash);
+            y = mha_cross_cached(ctx, y, kv_cache, cross_mask, b.cross_q_w, b.cross_q_b, b.cross_out_w, b.cross_out_b,
+                                 n_heads, d_model, i, T_enc, use_flash);
             x = ggml_add(ctx, x, y);
         }
         // FFN.
         {
             ggml_tensor * y = layer_norm(ctx, x, b.norm_ffn_w, b.norm_ffn_b);
-            y = ffn(ctx, y,
-                    b.ffn_fc1_w, b.ffn_fc1_b,
-                    b.ffn_fc2_w, b.ffn_fc2_b);
-            x = ggml_add(ctx, x, y);
+            y               = ffn(ctx, y, b.ffn_fc1_w, b.ffn_fc1_b, b.ffn_fc2_w, b.ffn_fc2_b);
+            x               = ggml_add(ctx, x, y);
         }
 
         char bname[64];
@@ -863,27 +806,23 @@ StepBuild build_step_graph(ggml_context *         ctx,
                            WhisperKvCache &       kv_cache,
                            int                    max_n_kv,
                            int                    T_enc,
-                           bool                   use_flash)
-{
-    StepBuild sb {};
+                           bool                   use_flash) {
+    StepBuild sb{};
     sb.max_n_kv = max_n_kv;
 
     if (ctx == nullptr || max_n_kv <= 0 || T_enc <= 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "whisper step: invalid arg (max_n_kv=%d, T_enc=%d)",
-                     max_n_kv, T_enc);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "whisper step: invalid arg (max_n_kv=%d, T_enc=%d)", max_n_kv, T_enc);
         return sb;
     }
     if (max_n_kv > kv_cache.n_ctx) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "whisper step: max_n_kv=%d exceeds kv_cache.n_ctx=%d",
-                     max_n_kv, kv_cache.n_ctx);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "whisper step: max_n_kv=%d exceeds kv_cache.n_ctx=%d", max_n_kv,
+                kv_cache.n_ctx);
         return sb;
     }
 
-    const int d_model = hp.dec_d_model;
-    const int n_heads = hp.dec_n_heads;
-    const int T_enc_pad = kv_cache.T_enc_pad > 0 ? kv_cache.T_enc_pad : T_enc;
+    const int  d_model         = hp.dec_d_model;
+    const int  n_heads         = hp.dec_n_heads;
+    const int  T_enc_pad       = kv_cache.T_enc_pad > 0 ? kv_cache.T_enc_pad : T_enc;
     const bool need_cross_mask = (T_enc_pad > T_enc);
 
     sb.token_id_in = ggml_new_tensor_1d(ctx, GGML_TYPE_I32, 1);
@@ -907,9 +846,7 @@ StepBuild build_step_graph(ggml_context *         ctx,
         ggml_set_name(sb.cross_mask_in, "step.cross_mask");
         ggml_set_input(sb.cross_mask_in);
     }
-    ggml_tensor * cross_mask_f16 = need_cross_mask
-        ? ggml_cast(ctx, sb.cross_mask_in, GGML_TYPE_F16)
-        : nullptr;
+    ggml_tensor * cross_mask_f16 = need_cross_mask ? ggml_cast(ctx, sb.cross_mask_in, GGML_TYPE_F16) : nullptr;
 
     sb.graph = ggml_new_graph_custom(ctx, 8192, false);
     if (sb.graph == nullptr) {
@@ -919,8 +856,8 @@ StepBuild build_step_graph(ggml_context *         ctx,
 
     // Token + positional embedding (no post-embed LayerNorm).
     ggml_tensor * tok_emb = ggml_get_rows(ctx, w.dec_top.token_embd_w, sb.token_id_in);
-    ggml_tensor * pos_emb = ggml_get_rows(ctx, w.dec_top.pos_emb_w,    sb.pos_id_in);
-    ggml_tensor * x = ggml_add(ctx, tok_emb, pos_emb);
+    ggml_tensor * pos_emb = ggml_get_rows(ctx, w.dec_top.pos_emb_w, sb.pos_id_in);
+    ggml_tensor * x       = ggml_add(ctx, tok_emb, pos_emb);
 
     const int n_blocks = static_cast<int>(w.dec_blocks.size());
     for (int i = 0; i < n_blocks; ++i) {
@@ -929,33 +866,23 @@ StepBuild build_step_graph(ggml_context *         ctx,
         // Self-attention (pre-LN, set_rows-based KV write).
         {
             ggml_tensor * y = layer_norm(ctx, x, b.norm_self_w, b.norm_self_b);
-            y = mha_self_step(
-                ctx, sb.graph, y, kv_cache, sb.mask_in, sb.kv_idx_in,
-                b.self_q_w, b.self_q_b,
-                b.self_k_w,
-                b.self_v_w, b.self_v_b,
-                b.self_out_w, b.self_out_b,
-                n_heads, d_model,
-                i, max_n_kv, use_flash);
+            y = mha_self_step(ctx, sb.graph, y, kv_cache, sb.mask_in, sb.kv_idx_in, b.self_q_w, b.self_q_b, b.self_k_w,
+                              b.self_v_w, b.self_v_b, b.self_out_w, b.self_out_b, n_heads, d_model, i, max_n_kv,
+                              use_flash);
             x = ggml_add(ctx, x, y);
         }
         // Cross-attention (pre-LN, reads pre-populated cross cache).
         {
             ggml_tensor * y = layer_norm(ctx, x, b.norm_cross_w, b.norm_cross_b);
-            y = mha_cross_cached(
-                ctx, y, kv_cache, cross_mask_f16,
-                b.cross_q_w, b.cross_q_b,
-                b.cross_out_w, b.cross_out_b,
-                n_heads, d_model, i, T_enc, use_flash);
+            y = mha_cross_cached(ctx, y, kv_cache, cross_mask_f16, b.cross_q_w, b.cross_q_b, b.cross_out_w,
+                                 b.cross_out_b, n_heads, d_model, i, T_enc, use_flash);
             x = ggml_add(ctx, x, y);
         }
         // FFN (pre-LN, GELU).
         {
             ggml_tensor * y = layer_norm(ctx, x, b.norm_ffn_w, b.norm_ffn_b);
-            y = ffn(ctx, y,
-                    b.ffn_fc1_w, b.ffn_fc1_b,
-                    b.ffn_fc2_w, b.ffn_fc2_b);
-            x = ggml_add(ctx, x, y);
+            y               = ffn(ctx, y, b.ffn_fc1_w, b.ffn_fc1_b, b.ffn_fc2_w, b.ffn_fc2_b);
+            x               = ggml_add(ctx, x, y);
         }
     }
 
@@ -977,118 +904,133 @@ namespace {
 // Batched self-attention step. x: [d_model, B] (one token per utterance).
 // Mirrors mha_self_step but threads the utterance batch on the trailing
 // flash axis (ne[3]); KV slab per layer is [d_model, n_ctx, B]. Flash-only.
-ggml_tensor * mha_self_step_batched(
-    ggml_context * ctx, ggml_cgraph * gf,
-    ggml_tensor * x, WhisperKvCache & kv_cache,
-    ggml_tensor * mask, ggml_tensor * kv_idx,
-    ggml_tensor * q_w, ggml_tensor * q_b,
-    ggml_tensor * k_w,
-    ggml_tensor * v_w, ggml_tensor * v_b,
-    ggml_tensor * out_w, ggml_tensor * out_b,
-    int n_heads, int d_model, int il, int max_n_kv, int B)
-{
-    const int head_dim = d_model / n_heads;
-    const float scale  = 1.0f / std::sqrt(static_cast<float>(head_dim));
-    const int64_t n_ctx = kv_cache.n_ctx;
-    const size_t k_elem = ggml_element_size(kv_cache.self_k);
-    const size_t v_elem = ggml_element_size(kv_cache.self_v);
+ggml_tensor * mha_self_step_batched(ggml_context *   ctx,
+                                    ggml_cgraph *    gf,
+                                    ggml_tensor *    x,
+                                    WhisperKvCache & kv_cache,
+                                    ggml_tensor *    mask,
+                                    ggml_tensor *    kv_idx,
+                                    ggml_tensor *    q_w,
+                                    ggml_tensor *    q_b,
+                                    ggml_tensor *    k_w,
+                                    ggml_tensor *    v_w,
+                                    ggml_tensor *    v_b,
+                                    ggml_tensor *    out_w,
+                                    ggml_tensor *    out_b,
+                                    int              n_heads,
+                                    int              d_model,
+                                    int              il,
+                                    int              max_n_kv,
+                                    int              B) {
+    const int     head_dim = d_model / n_heads;
+    const float   scale    = 1.0f / std::sqrt(static_cast<float>(head_dim));
+    const int64_t n_ctx    = kv_cache.n_ctx;
+    const size_t  k_elem   = ggml_element_size(kv_cache.self_k);
+    const size_t  v_elem   = ggml_element_size(kv_cache.self_v);
 
     ggml_tensor * Qcur = ggml_mul_mat(ctx, q_w, x);
-    if (q_b != nullptr) Qcur = ggml_add(ctx, Qcur, q_b);
-    ggml_tensor * Kcur = ggml_mul_mat(ctx, k_w, x);   // k has no bias
+    if (q_b != nullptr) {
+        Qcur = ggml_add(ctx, Qcur, q_b);
+    }
+    ggml_tensor * Kcur = ggml_mul_mat(ctx, k_w, x);  // k has no bias
     ggml_tensor * Vcur = ggml_mul_mat(ctx, v_w, x);
-    if (v_b != nullptr) Vcur = ggml_add(ctx, Vcur, v_b);
+    if (v_b != nullptr) {
+        Vcur = ggml_add(ctx, Vcur, v_b);
+    }
 
     ggml_tensor * Q = ggml_reshape_3d(ctx, Qcur, head_dim, n_heads, B);
 
     // KV write: per-layer slab [d_model, n_ctx, B]; one set_rows writes B
     // rows at B independent indices kv_idx[b].
     {
-        const size_t layer_off_k =
-            k_elem * static_cast<size_t>(il) * n_ctx * d_model * B;
-        const size_t layer_off_v =
-            v_elem * static_cast<size_t>(il) * n_ctx * d_model * B;
-        ggml_tensor * k_layer = ggml_view_3d(ctx, kv_cache.self_k,
-            d_model, n_ctx, B, k_elem * d_model, k_elem * d_model * n_ctx, layer_off_k);
-        ggml_tensor * v_layer = ggml_view_3d(ctx, kv_cache.self_v,
-            d_model, n_ctx, B, v_elem * d_model, v_elem * d_model * n_ctx, layer_off_v);
-        ggml_tensor * K_row = ggml_reshape_3d(ctx, Kcur, d_model, 1, B);
-        ggml_tensor * V_row = ggml_reshape_3d(ctx, Vcur, d_model, 1, B);
+        const size_t  layer_off_k = k_elem * static_cast<size_t>(il) * n_ctx * d_model * B;
+        const size_t  layer_off_v = v_elem * static_cast<size_t>(il) * n_ctx * d_model * B;
+        ggml_tensor * k_layer     = ggml_view_3d(ctx, kv_cache.self_k, d_model, n_ctx, B, k_elem * d_model,
+                                                 k_elem * d_model * n_ctx, layer_off_k);
+        ggml_tensor * v_layer     = ggml_view_3d(ctx, kv_cache.self_v, d_model, n_ctx, B, v_elem * d_model,
+                                                 v_elem * d_model * n_ctx, layer_off_v);
+        ggml_tensor * K_row       = ggml_reshape_3d(ctx, Kcur, d_model, 1, B);
+        ggml_tensor * V_row       = ggml_reshape_3d(ctx, Vcur, d_model, 1, B);
         ggml_build_forward_expand(gf, ggml_set_rows(ctx, k_layer, K_row, kv_idx));
         ggml_build_forward_expand(gf, ggml_set_rows(ctx, v_layer, V_row, kv_idx));
     }
 
-    const size_t layer_off_k =
-        k_elem * static_cast<size_t>(il) * n_ctx * d_model * B;
-    const size_t layer_off_v =
-        v_elem * static_cast<size_t>(il) * n_ctx * d_model * B;
-    ggml_tensor * K = ggml_view_4d(ctx, kv_cache.self_k,
-        head_dim, max_n_kv, n_heads, B,
-        k_elem * d_model, k_elem * head_dim, k_elem * d_model * n_ctx, layer_off_k);
-    ggml_tensor * V = ggml_view_4d(ctx, kv_cache.self_v,
-        head_dim, max_n_kv, n_heads, B,
-        v_elem * d_model, v_elem * head_dim, v_elem * d_model * n_ctx, layer_off_v);
+    const size_t  layer_off_k = k_elem * static_cast<size_t>(il) * n_ctx * d_model * B;
+    const size_t  layer_off_v = v_elem * static_cast<size_t>(il) * n_ctx * d_model * B;
+    ggml_tensor * K           = ggml_view_4d(ctx, kv_cache.self_k, head_dim, max_n_kv, n_heads, B, k_elem * d_model,
+                                             k_elem * head_dim, k_elem * d_model * n_ctx, layer_off_k);
+    ggml_tensor * V           = ggml_view_4d(ctx, kv_cache.self_v, head_dim, max_n_kv, n_heads, B, v_elem * d_model,
+                                             v_elem * head_dim, v_elem * d_model * n_ctx, layer_off_v);
 
     // Q [head_dim, n_heads, B] -> [head_dim, 1, n_heads, B] for flash.
     ggml_tensor * Q_att = ggml_cont(ctx, ggml_permute(ctx, Q, 0, 2, 3, 1));
-    ggml_tensor * o = ggml_flash_attn_ext(ctx, Q_att, K, V, mask, scale, 0.0f, 0.0f);
-    o = ggml_reshape_2d(ctx, o, d_model, B);
+    ggml_tensor * o     = ggml_flash_attn_ext(ctx, Q_att, K, V, mask, scale, 0.0f, 0.0f);
+    o                   = ggml_reshape_2d(ctx, o, d_model, B);
 
     o = ggml_mul_mat(ctx, out_w, o);
-    if (out_b != nullptr) o = ggml_add(ctx, o, out_b);
+    if (out_b != nullptr) {
+        o = ggml_add(ctx, o, out_b);
+    }
     return o;
 }
 
 // Batched cross-attention step. x: [d_model, B]; reads cross slab
 // [d_model, T_enc_max, B] per layer with a per-utterance cross-pad mask.
 // Whisper cross: q/out carry bias; k/v already live in the cache.
-ggml_tensor * mha_cross_step_batched(
-    ggml_context * ctx, ggml_tensor * x, WhisperKvCache & kv_cache,
-    ggml_tensor * cross_mask,
-    ggml_tensor * q_w, ggml_tensor * q_b,
-    ggml_tensor * out_w, ggml_tensor * out_b,
-    int n_heads, int d_model, int il, int T_enc_max, int B)
-{
-    const int head_dim = d_model / n_heads;
-    const float scale  = 1.0f / std::sqrt(static_cast<float>(head_dim));
-    const size_t k_elem = ggml_element_size(kv_cache.cross_k);
-    const size_t v_elem = ggml_element_size(kv_cache.cross_v);
+ggml_tensor * mha_cross_step_batched(ggml_context *   ctx,
+                                     ggml_tensor *    x,
+                                     WhisperKvCache & kv_cache,
+                                     ggml_tensor *    cross_mask,
+                                     ggml_tensor *    q_w,
+                                     ggml_tensor *    q_b,
+                                     ggml_tensor *    out_w,
+                                     ggml_tensor *    out_b,
+                                     int              n_heads,
+                                     int              d_model,
+                                     int              il,
+                                     int              T_enc_max,
+                                     int              B) {
+    const int    head_dim = d_model / n_heads;
+    const float  scale    = 1.0f / std::sqrt(static_cast<float>(head_dim));
+    const size_t k_elem   = ggml_element_size(kv_cache.cross_k);
+    const size_t v_elem   = ggml_element_size(kv_cache.cross_v);
 
     ggml_tensor * Qcur = ggml_mul_mat(ctx, q_w, x);
-    if (q_b != nullptr) Qcur = ggml_add(ctx, Qcur, q_b);
-    ggml_tensor * Q = ggml_reshape_3d(ctx, Qcur, head_dim, n_heads, B);
+    if (q_b != nullptr) {
+        Qcur = ggml_add(ctx, Qcur, q_b);
+    }
+    ggml_tensor * Q     = ggml_reshape_3d(ctx, Qcur, head_dim, n_heads, B);
     ggml_tensor * Q_att = ggml_cont(ctx, ggml_permute(ctx, Q, 0, 2, 3, 1));
 
-    const size_t layer_off_k =
-        k_elem * static_cast<size_t>(il) * T_enc_max * d_model * B;
-    const size_t layer_off_v =
-        v_elem * static_cast<size_t>(il) * T_enc_max * d_model * B;
-    ggml_tensor * K = ggml_view_4d(ctx, kv_cache.cross_k,
-        head_dim, T_enc_max, n_heads, B,
-        k_elem * d_model, k_elem * head_dim, k_elem * d_model * T_enc_max, layer_off_k);
-    ggml_tensor * V = ggml_view_4d(ctx, kv_cache.cross_v,
-        head_dim, T_enc_max, n_heads, B,
-        v_elem * d_model, v_elem * head_dim, v_elem * d_model * T_enc_max, layer_off_v);
+    const size_t  layer_off_k = k_elem * static_cast<size_t>(il) * T_enc_max * d_model * B;
+    const size_t  layer_off_v = v_elem * static_cast<size_t>(il) * T_enc_max * d_model * B;
+    ggml_tensor * K           = ggml_view_4d(ctx, kv_cache.cross_k, head_dim, T_enc_max, n_heads, B, k_elem * d_model,
+                                             k_elem * head_dim, k_elem * d_model * T_enc_max, layer_off_k);
+    ggml_tensor * V           = ggml_view_4d(ctx, kv_cache.cross_v, head_dim, T_enc_max, n_heads, B, v_elem * d_model,
+                                             v_elem * head_dim, v_elem * d_model * T_enc_max, layer_off_v);
 
     ggml_tensor * o = ggml_flash_attn_ext(ctx, Q_att, K, V, cross_mask, scale, 0.0f, 0.0f);
-    o = ggml_reshape_2d(ctx, o, d_model, B);
+    o               = ggml_reshape_2d(ctx, o, d_model, B);
 
     o = ggml_mul_mat(ctx, out_w, o);
-    if (out_b != nullptr) o = ggml_add(ctx, o, out_b);
+    if (out_b != nullptr) {
+        o = ggml_add(ctx, o, out_b);
+    }
     return o;
 }
 
-} // namespace
+}  // namespace
 
 DecoderBuild build_cross_kv_graph_batched(ggml_context *         ctx,
                                           const WhisperWeights & w,
                                           const WhisperHParams & hp,
                                           WhisperKvCache &       kv_cache,
                                           int                    T_enc_max,
-                                          int                    n_batch)
-{
-    DecoderBuild db {};
-    if (ctx == nullptr || T_enc_max <= 0 || n_batch <= 0) return db;
+                                          int                    n_batch) {
+    DecoderBuild db{};
+    if (ctx == nullptr || T_enc_max <= 0 || n_batch <= 0) {
+        return db;
+    }
 
     const int64_t d_model = hp.dec_d_model;
     const int     B       = n_batch;
@@ -1098,7 +1040,9 @@ DecoderBuild build_cross_kv_graph_batched(ggml_context *         ctx,
     ggml_set_input(db.encoder_out_in);
 
     db.graph = ggml_new_graph_custom(ctx, 8192, false);
-    if (db.graph == nullptr) return db;
+    if (db.graph == nullptr) {
+        return db;
+    }
 
     const size_t k_elem = ggml_element_size(kv_cache.cross_k);
     const size_t v_elem = ggml_element_size(kv_cache.cross_v);
@@ -1110,17 +1054,17 @@ DecoderBuild build_cross_kv_graph_batched(ggml_context *         ctx,
         // Cross k has no bias; cross v does.
         ggml_tensor * Kc = ggml_mul_mat(ctx, blk.cross_k_w, db.encoder_out_in);
         ggml_tensor * Vc = ggml_mul_mat(ctx, blk.cross_v_w, db.encoder_out_in);
-        if (blk.cross_v_b != nullptr) Vc = ggml_add(ctx, Vc, blk.cross_v_b);
+        if (blk.cross_v_b != nullptr) {
+            Vc = ggml_add(ctx, Vc, blk.cross_v_b);
+        }
         // Kc/Vc: [d_model, T_enc_max, B].
 
-        const size_t off_k =
-            k_elem * static_cast<size_t>(il) * T_enc_max * d_model * B;
-        const size_t off_v =
-            v_elem * static_cast<size_t>(il) * T_enc_max * d_model * B;
-        ggml_tensor * k_dst = ggml_view_3d(ctx, kv_cache.cross_k,
-            d_model, T_enc_max, B, k_elem * d_model, k_elem * d_model * T_enc_max, off_k);
-        ggml_tensor * v_dst = ggml_view_3d(ctx, kv_cache.cross_v,
-            d_model, T_enc_max, B, v_elem * d_model, v_elem * d_model * T_enc_max, off_v);
+        const size_t  off_k = k_elem * static_cast<size_t>(il) * T_enc_max * d_model * B;
+        const size_t  off_v = v_elem * static_cast<size_t>(il) * T_enc_max * d_model * B;
+        ggml_tensor * k_dst = ggml_view_3d(ctx, kv_cache.cross_k, d_model, T_enc_max, B, k_elem * d_model,
+                                           k_elem * d_model * T_enc_max, off_k);
+        ggml_tensor * v_dst = ggml_view_3d(ctx, kv_cache.cross_v, d_model, T_enc_max, B, v_elem * d_model,
+                                           v_elem * d_model * T_enc_max, off_v);
         ggml_build_forward_expand(db.graph, ggml_cpy(ctx, Kc, k_dst));
         ggml_build_forward_expand(db.graph, ggml_cpy(ctx, Vc, v_dst));
     }
@@ -1134,12 +1078,13 @@ StepBuildBatched build_step_graph_batched(ggml_context *         ctx,
                                           int                    max_n_kv,
                                           int                    T_enc_max,
                                           int                    n_batch,
-                                          bool                   use_flash)
-{
-    StepBuildBatched sb {};
+                                          bool                   use_flash) {
+    StepBuildBatched sb{};
     sb.max_n_kv = max_n_kv;
     sb.n_batch  = n_batch;
-    if (ctx == nullptr || max_n_kv <= 0 || T_enc_max <= 0 || n_batch <= 0) return sb;
+    if (ctx == nullptr || max_n_kv <= 0 || T_enc_max <= 0 || n_batch <= 0) {
+        return sb;
+    }
     if (!use_flash) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "whisper step(batched): requires flash path");
         return sb;
@@ -1150,48 +1095,51 @@ StepBuildBatched build_step_graph_batched(ggml_context *         ctx,
     const int B       = n_batch;
 
     sb.token_ids_in = ggml_new_tensor_1d(ctx, GGML_TYPE_I32, B);
-    ggml_set_name(sb.token_ids_in, "step.token_ids"); ggml_set_input(sb.token_ids_in);
+    ggml_set_name(sb.token_ids_in, "step.token_ids");
+    ggml_set_input(sb.token_ids_in);
     sb.pos_ids_in = ggml_new_tensor_1d(ctx, GGML_TYPE_I32, B);
-    ggml_set_name(sb.pos_ids_in, "step.pos_ids"); ggml_set_input(sb.pos_ids_in);
+    ggml_set_name(sb.pos_ids_in, "step.pos_ids");
+    ggml_set_input(sb.pos_ids_in);
     sb.kv_idx_in = ggml_new_tensor_2d(ctx, GGML_TYPE_I64, 1, B);
-    ggml_set_name(sb.kv_idx_in, "step.kv_idx"); ggml_set_input(sb.kv_idx_in);
+    ggml_set_name(sb.kv_idx_in, "step.kv_idx");
+    ggml_set_input(sb.kv_idx_in);
     sb.self_mask_in = ggml_new_tensor_4d(ctx, GGML_TYPE_F16, max_n_kv, 1, 1, B);
-    ggml_set_name(sb.self_mask_in, "step.self_mask"); ggml_set_input(sb.self_mask_in);
+    ggml_set_name(sb.self_mask_in, "step.self_mask");
+    ggml_set_input(sb.self_mask_in);
     sb.cross_mask_in = ggml_new_tensor_4d(ctx, GGML_TYPE_F16, T_enc_max, 1, 1, B);
-    ggml_set_name(sb.cross_mask_in, "step.cross_mask"); ggml_set_input(sb.cross_mask_in);
+    ggml_set_name(sb.cross_mask_in, "step.cross_mask");
+    ggml_set_input(sb.cross_mask_in);
 
     sb.graph = ggml_new_graph_custom(ctx, 16384, false);
-    if (sb.graph == nullptr) return sb;
+    if (sb.graph == nullptr) {
+        return sb;
+    }
 
     // Token + positional embedding (no post-embed LayerNorm).
     ggml_tensor * tok_emb = ggml_get_rows(ctx, w.dec_top.token_embd_w, sb.token_ids_in);
-    ggml_tensor * pos_emb = ggml_get_rows(ctx, w.dec_top.pos_emb_w,    sb.pos_ids_in);
-    ggml_tensor * x = ggml_add(ctx, tok_emb, pos_emb);
+    ggml_tensor * pos_emb = ggml_get_rows(ctx, w.dec_top.pos_emb_w, sb.pos_ids_in);
+    ggml_tensor * x       = ggml_add(ctx, tok_emb, pos_emb);
 
     const int n_blocks = static_cast<int>(w.dec_blocks.size());
     for (int i = 0; i < n_blocks; ++i) {
         const auto & b = w.dec_blocks[i];
         {
-            ggml_tensor * y = layer_norm(ctx, x, b.norm_self_w, b.norm_self_b);
-            ggml_tensor * so = mha_self_step_batched(
-                ctx, sb.graph, y, kv_cache, sb.self_mask_in, sb.kv_idx_in,
-                b.self_q_w, b.self_q_b, b.self_k_w,
-                b.self_v_w, b.self_v_b, b.self_out_w, b.self_out_b,
-                n_heads, d_model, i, max_n_kv, B);
-            x = ggml_add(ctx, x, so);
+            ggml_tensor * y  = layer_norm(ctx, x, b.norm_self_w, b.norm_self_b);
+            ggml_tensor * so = mha_self_step_batched(ctx, sb.graph, y, kv_cache, sb.self_mask_in, sb.kv_idx_in,
+                                                     b.self_q_w, b.self_q_b, b.self_k_w, b.self_v_w, b.self_v_b,
+                                                     b.self_out_w, b.self_out_b, n_heads, d_model, i, max_n_kv, B);
+            x                = ggml_add(ctx, x, so);
         }
         {
-            ggml_tensor * y = layer_norm(ctx, x, b.norm_cross_w, b.norm_cross_b);
-            ggml_tensor * co = mha_cross_step_batched(
-                ctx, y, kv_cache, sb.cross_mask_in,
-                b.cross_q_w, b.cross_q_b, b.cross_out_w, b.cross_out_b,
-                n_heads, d_model, i, T_enc_max, B);
-            x = ggml_add(ctx, x, co);
+            ggml_tensor * y  = layer_norm(ctx, x, b.norm_cross_w, b.norm_cross_b);
+            ggml_tensor * co = mha_cross_step_batched(ctx, y, kv_cache, sb.cross_mask_in, b.cross_q_w, b.cross_q_b,
+                                                      b.cross_out_w, b.cross_out_b, n_heads, d_model, i, T_enc_max, B);
+            x                = ggml_add(ctx, x, co);
         }
         {
             ggml_tensor * y = layer_norm(ctx, x, b.norm_ffn_w, b.norm_ffn_b);
-            y = ffn(ctx, y, b.ffn_fc1_w, b.ffn_fc1_b, b.ffn_fc2_w, b.ffn_fc2_b);
-            x = ggml_add(ctx, x, y);
+            y               = ffn(ctx, y, b.ffn_fc1_w, b.ffn_fc1_b, b.ffn_fc2_w, b.ffn_fc2_b);
+            x               = ggml_add(ctx, x, y);
         }
     }
 
@@ -1206,4 +1154,4 @@ StepBuildBatched build_step_graph_batched(ggml_context *         ctx,
     return sb;
 }
 
-} // namespace transcribe::whisper
+}  // namespace transcribe::whisper
diff --git a/src/arch/whisper/decoder.h b/src/arch/whisper/decoder.h
index cc662b61..42b83326 100644
--- a/src/arch/whisper/decoder.h
+++ b/src/arch/whisper/decoder.h
@@ -32,13 +32,13 @@ struct WhisperWeights;
 struct WhisperKvCache;
 
 struct DecoderDumps {
-    ggml_tensor * token_emb       = nullptr;
-    ggml_tensor * pos_emb         = nullptr;
-    ggml_tensor * embed_sum       = nullptr;
-    std::vector<ggml_tensor *> block_outs;       // per-layer residual stream
-    ggml_tensor * out_before_head = nullptr;     // post final LN
-    ggml_tensor * logits_raw      = nullptr;     // pre log-softmax logits
-    ggml_tensor * logits          = nullptr;     // log-softmax(logits_raw)
+    ggml_tensor *              token_emb = nullptr;
+    ggml_tensor *              pos_emb   = nullptr;
+    ggml_tensor *              embed_sum = nullptr;
+    std::vector<ggml_tensor *> block_outs;                 // per-layer residual stream
+    ggml_tensor *              out_before_head = nullptr;  // post final LN
+    ggml_tensor *              logits_raw      = nullptr;  // pre log-softmax logits
+    ggml_tensor *              logits          = nullptr;  // log-softmax(logits_raw)
 };
 
 struct DecoderBuild {
@@ -52,12 +52,12 @@ struct DecoderBuild {
     // (cast to f16 inside). Caller populates with 0 for k in [0,
     // T_enc) and -inf for k in [T_enc, T_enc_pad), so the unmasked
     // padded slots do not contribute to the cross-attn output.
-    ggml_tensor * cross_mask_in  = nullptr;
+    ggml_tensor * cross_mask_in = nullptr;
 
     // Output: log-softmax logits [vocab_size, seq_len].
     ggml_tensor * out = nullptr;
 
-    DecoderDumps  dumps {};
+    DecoderDumps  dumps{};
     ggml_cgraph * graph = nullptr;
 };
 
@@ -128,14 +128,14 @@ DecoderBuild build_decoder_graph_kv(ggml_context *         compute_ctx,
 // the in-graph argmax shortcut from canary/cohere/moonshine doesn't
 // apply.
 struct StepBuild {
-    ggml_tensor * token_id_in    = nullptr;  // i32 [1]
-    ggml_tensor * pos_id_in      = nullptr;  // i32 [1]
-    ggml_tensor * kv_idx_in      = nullptr;  // i64 [1]
-    ggml_tensor * mask_in        = nullptr;  // f16 [max_n_kv, 1]
-    ggml_tensor * cross_mask_in  = nullptr;  // f32 [T_enc_pad, 1], may be null
-    ggml_tensor * logits_out     = nullptr;  // f32 [vocab, 1] raw logits
-    int           max_n_kv       = 0;
-    ggml_cgraph * graph          = nullptr;
+    ggml_tensor * token_id_in   = nullptr;  // i32 [1]
+    ggml_tensor * pos_id_in     = nullptr;  // i32 [1]
+    ggml_tensor * kv_idx_in     = nullptr;  // i64 [1]
+    ggml_tensor * mask_in       = nullptr;  // f16 [max_n_kv, 1]
+    ggml_tensor * cross_mask_in = nullptr;  // f32 [T_enc_pad, 1], may be null
+    ggml_tensor * logits_out    = nullptr;  // f32 [vocab, 1] raw logits
+    int           max_n_kv      = 0;
+    ggml_cgraph * graph         = nullptr;
 };
 
 StepBuild build_step_graph(ggml_context *         compute_ctx,
@@ -183,4 +183,4 @@ StepBuildBatched build_step_graph_batched(ggml_context *         compute_ctx,
                                           int                    n_batch,
                                           bool                   use_flash = true);
 
-} // namespace transcribe::whisper
+}  // namespace transcribe::whisper
diff --git a/src/arch/whisper/encoder.cpp b/src/arch/whisper/encoder.cpp
index 8fe8ade8..bf6a976d 100644
--- a/src/arch/whisper/encoder.cpp
+++ b/src/arch/whisper/encoder.cpp
@@ -21,13 +21,11 @@
 
 #include "encoder.h"
 
-#include "weights.h"
-
 #include "conformer/conformer.h"
+#include "ggml.h"
 #include "transcribe-debug.h"
 #include "transcribe-log.h"
-
-#include "ggml.h"
+#include "weights.h"
 
 #include <cmath>
 #include <cstdio>
@@ -38,19 +36,19 @@ namespace transcribe::whisper {
 namespace {
 
 namespace conf = transcribe::conformer;
-using conf::named;
 using conf::layer_norm;
+using conf::named;
 
 // Reshape a 1D conv bias [Cout] into a 4D tensor [1, Cout, 1, 1] so it
 // broadcasts across T when added to a ggml_conv_1d output
 // [T_out, Cout, 1, 1]. ggml's `add_conv_bias` in conformer.cpp is for
 // 2D conv (channels at ne[2]) and does not fit here.
-ggml_tensor * add_conv1d_bias(ggml_context * ctx,
-                              ggml_tensor *  conv_out,
-                              ggml_tensor *  bias_1d) {
-    if (bias_1d == nullptr) return conv_out;
+ggml_tensor * add_conv1d_bias(ggml_context * ctx, ggml_tensor * conv_out, ggml_tensor * bias_1d) {
+    if (bias_1d == nullptr) {
+        return conv_out;
+    }
     const int64_t channels = bias_1d->ne[0];
-    ggml_tensor * bias_4d = ggml_reshape_4d(ctx, bias_1d, 1, channels, 1, 1);
+    ggml_tensor * bias_4d  = ggml_reshape_4d(ctx, bias_1d, 1, channels, 1, 1);
     return ggml_add(ctx, conv_out, bias_4d);
 }
 
@@ -59,26 +57,32 @@ ggml_tensor * add_conv1d_bias(ggml_context * ctx,
 // (no causal mask).
 ggml_tensor * mha_encoder(ggml_context * ctx,
                           ggml_tensor *  x,
-                          ggml_tensor *  q_w, ggml_tensor * q_b,
+                          ggml_tensor *  q_w,
+                          ggml_tensor *  q_b,
                           ggml_tensor *  k_w,
-                          ggml_tensor *  v_w, ggml_tensor * v_b,
-                          ggml_tensor *  out_w, ggml_tensor * out_b,
+                          ggml_tensor *  v_w,
+                          ggml_tensor *  v_b,
+                          ggml_tensor *  out_w,
+                          ggml_tensor *  out_b,
                           int            n_heads,
                           int            d_model,
-                          bool           use_flash)
-{
+                          bool           use_flash) {
     const int     head_dim = d_model / n_heads;
     const float   scale    = 1.0f / std::sqrt(static_cast<float>(head_dim));
     const int64_t T        = x->ne[1];
 
     // Q, K, V projections (k has no bias).
     ggml_tensor * q = ggml_mul_mat(ctx, q_w, x);
-    if (q_b != nullptr) q = ggml_add(ctx, q, q_b);
+    if (q_b != nullptr) {
+        q = ggml_add(ctx, q, q_b);
+    }
 
     ggml_tensor * k = ggml_mul_mat(ctx, k_w, x);
 
     ggml_tensor * v = ggml_mul_mat(ctx, v_w, x);
-    if (v_b != nullptr) v = ggml_add(ctx, v, v_b);
+    if (v_b != nullptr) {
+        v = ggml_add(ctx, v, v_b);
+    }
 
     // Split into heads: [d_model, T] -> [head_dim, n_heads, T] ->
     // permute to [head_dim, T, n_heads] so flash_attn / manual path
@@ -98,8 +102,8 @@ ggml_tensor * mha_encoder(ggml_context * ctx,
         ggml_tensor * q_c = ggml_cont(ctx, q);
         ggml_tensor * k_c = ggml_cont(ctx, k);
         ggml_tensor * v_c = ggml_cont(ctx, v);
-        o = ggml_flash_attn_ext(ctx, q_c, k_c, v_c, nullptr, scale, 0.0f, 0.0f);
-        o = ggml_reshape_2d(ctx, o, d_model, T);
+        o                 = ggml_flash_attn_ext(ctx, q_c, k_c, v_c, nullptr, scale, 0.0f, 0.0f);
+        o                 = ggml_reshape_2d(ctx, o, d_model, T);
     } else {
         // Manual attention path: mul_mat(K, Q) gives [T_k, T_q, n_heads]
         // per the standard cohere pattern.
@@ -108,7 +112,7 @@ ggml_tensor * mha_encoder(ggml_context * ctx,
 
         // v^T so the final mul_mat yields [head_dim, T_q, n_heads].
         ggml_tensor * v_t = ggml_cont(ctx, ggml_permute(ctx, v, 1, 0, 2, 3));
-        o = ggml_mul_mat(ctx, v_t, kq_soft);
+        o                 = ggml_mul_mat(ctx, v_t, kq_soft);
 
         // Merge heads: [head_dim, T_q, n_heads] -> [head_dim, n_heads, T_q]
         // -> cont -> reshape to [d_model, T_q].
@@ -119,20 +123,28 @@ ggml_tensor * mha_encoder(ggml_context * ctx,
 
     // Output projection with bias.
     o = ggml_mul_mat(ctx, out_w, o);
-    if (out_b != nullptr) o = ggml_add(ctx, o, out_b);
+    if (out_b != nullptr) {
+        o = ggml_add(ctx, o, out_b);
+    }
     return o;
 }
 
 // FFN: fc2(GELU(fc1(x))); pre-LN wrapped outside. fc1/fc2 carry bias.
 ggml_tensor * ffn(ggml_context * ctx,
                   ggml_tensor *  x,
-                  ggml_tensor *  fc1_w, ggml_tensor * fc1_b,
-                  ggml_tensor *  fc2_w, ggml_tensor * fc2_b) {
+                  ggml_tensor *  fc1_w,
+                  ggml_tensor *  fc1_b,
+                  ggml_tensor *  fc2_w,
+                  ggml_tensor *  fc2_b) {
     ggml_tensor * h = ggml_mul_mat(ctx, fc1_w, x);
-    if (fc1_b != nullptr) h = ggml_add(ctx, h, fc1_b);
-    h = ggml_gelu_erf(ctx, h);
+    if (fc1_b != nullptr) {
+        h = ggml_add(ctx, h, fc1_b);
+    }
+    h               = ggml_gelu_erf(ctx, h);
     ggml_tensor * o = ggml_mul_mat(ctx, fc2_w, h);
-    if (fc2_b != nullptr) o = ggml_add(ctx, o, fc2_b);
+    if (fc2_b != nullptr) {
+        o = ggml_add(ctx, o, fc2_b);
+    }
     return o;
 }
 
@@ -144,54 +156,45 @@ ggml_tensor * build_block(ggml_context *          ctx,
                           const WhisperEncBlock & b,
                           int                     n_heads,
                           int                     d_model,
-                          bool                    use_flash)
-{
+                          bool                    use_flash) {
     // Self-attention sublayer.
     {
         ggml_tensor * y = layer_norm(ctx, x, b.norm_attn_w, b.norm_attn_b);
-        y = mha_encoder(ctx, y,
-                        b.attn_q_w, b.attn_q_b,
-                        b.attn_k_w,
-                        b.attn_v_w, b.attn_v_b,
-                        b.attn_out_w, b.attn_out_b,
+        y = mha_encoder(ctx, y, b.attn_q_w, b.attn_q_b, b.attn_k_w, b.attn_v_w, b.attn_v_b, b.attn_out_w, b.attn_out_b,
                         n_heads, d_model, use_flash);
         x = ggml_add(ctx, x, y);
     }
     // FFN sublayer.
     {
         ggml_tensor * y = layer_norm(ctx, x, b.norm_ffn_w, b.norm_ffn_b);
-        y = ffn(ctx, y,
-                b.ffn_fc1_w, b.ffn_fc1_b,
-                b.ffn_fc2_w, b.ffn_fc2_b);
-        x = ggml_add(ctx, x, y);
+        y               = ffn(ctx, y, b.ffn_fc1_w, b.ffn_fc1_b, b.ffn_fc2_w, b.ffn_fc2_b);
+        x               = ggml_add(ctx, x, y);
     }
     return x;
 }
 
-} // namespace
+}  // namespace
 
-EncoderBuild build_encoder_graph(ggml_context *          ctx,
-                                 const WhisperWeights &  w,
-                                 const WhisperHParams &  hp,
-                                 int                     n_mel_frames,
-                                 bool                    use_flash,
-                                 const char *            backend_name)
-{
-    (void)backend_name;
+EncoderBuild build_encoder_graph(ggml_context *         ctx,
+                                 const WhisperWeights & w,
+                                 const WhisperHParams & hp,
+                                 int                    n_mel_frames,
+                                 bool                   use_flash,
+                                 const char *           backend_name) {
+    (void) backend_name;
 
-    EncoderBuild eb {};
+    EncoderBuild eb{};
 
     if (ctx == nullptr || n_mel_frames <= 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "whisper encoder: invalid arg (ctx=%p, n_mel_frames=%d)",
-                     static_cast<void *>(ctx), n_mel_frames);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "whisper encoder: invalid arg (ctx=%p, n_mel_frames=%d)",
+                static_cast<void *>(ctx), n_mel_frames);
         return eb;
     }
     if (n_mel_frames % 2 != 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "whisper encoder: n_mel_frames=%d must be even "
-                     "(stride-2 conv2 would produce fractional T_enc)",
-                     n_mel_frames);
+                "whisper encoder: n_mel_frames=%d must be even "
+                "(stride-2 conv2 would produce fractional T_enc)",
+                n_mel_frames);
         return eb;
     }
 
@@ -201,16 +204,17 @@ EncoderBuild build_encoder_graph(ggml_context *          ctx,
     const int T_enc   = n_mel_frames / 2;
 
     if (T_enc > hp.enc_max_source_positions) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "whisper encoder: T_enc=%d exceeds max_source_positions=%d",
-                     T_enc, hp.enc_max_source_positions);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "whisper encoder: T_enc=%d exceeds max_source_positions=%d", T_enc,
+                hp.enc_max_source_positions);
         return eb;
     }
 
     // mel input handle. ggml ne=[n_mels, T]; caller uploads the mel
     // spectrogram row-major in this layout.
     eb.mel_in = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, n_mels, n_mel_frames);
-    if (eb.mel_in == nullptr) return eb;
+    if (eb.mel_in == nullptr) {
+        return eb;
+    }
     named(eb.mel_in, "enc.mel.in");
     ggml_set_input(eb.mel_in);
     eb.dumps.mel_in = eb.mel_in;
@@ -246,9 +250,7 @@ EncoderBuild build_encoder_graph(ggml_context *          ctx,
     // for T_enc < max take a prefix view (no-op when T_enc == max).
     ggml_tensor * pos_emb = w.enc_top.pos_emb_w;
     if (T_enc != hp.enc_max_source_positions) {
-        pos_emb = ggml_view_2d(ctx, w.enc_top.pos_emb_w,
-                               d_model, T_enc,
-                               w.enc_top.pos_emb_w->nb[1], 0);
+        pos_emb = ggml_view_2d(ctx, w.enc_top.pos_emb_w, d_model, T_enc, w.enc_top.pos_emb_w->nb[1], 0);
     }
     named(pos_emb, "enc.pos_emb");
     eb.dumps.pos_emb = pos_emb;
@@ -292,8 +294,7 @@ EncoderBuild build_encoder_graph(ggml_context *          ctx,
     // Build the forward cgraph. 8192 leaves headroom up to large (32 blocks).
     eb.graph = ggml_new_graph_custom(ctx, 8192, false);
     if (eb.graph == nullptr) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "whisper encoder: ggml_new_graph_custom failed");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "whisper encoder: ggml_new_graph_custom failed");
         return eb;
     }
     ggml_build_forward_expand(eb.graph, eb.out);
@@ -301,4 +302,4 @@ EncoderBuild build_encoder_graph(ggml_context *          ctx,
     return eb;
 }
 
-} // namespace transcribe::whisper
+}  // namespace transcribe::whisper
diff --git a/src/arch/whisper/encoder.h b/src/arch/whisper/encoder.h
index acc4119d..21b844ba 100644
--- a/src/arch/whisper/encoder.h
+++ b/src/arch/whisper/encoder.h
@@ -24,14 +24,14 @@ struct WhisperHParams;
 struct WhisperWeights;
 
 struct EncoderDumps {
-    ggml_tensor * mel_in     = nullptr;
-    ggml_tensor * conv1_out  = nullptr;
-    ggml_tensor * conv2_out  = nullptr;
-    ggml_tensor * pos_emb    = nullptr;
-    ggml_tensor * embed_out  = nullptr;
-    ggml_tensor * block0_out = nullptr;
+    ggml_tensor * mel_in         = nullptr;
+    ggml_tensor * conv1_out      = nullptr;
+    ggml_tensor * conv2_out      = nullptr;
+    ggml_tensor * pos_emb        = nullptr;
+    ggml_tensor * embed_out      = nullptr;
+    ggml_tensor * block0_out     = nullptr;
     ggml_tensor * block_last_out = nullptr;
-    ggml_tensor * final_out  = nullptr;
+    ggml_tensor * final_out      = nullptr;
 
     // Every post-block residual stream output, in block order (alongside
     // block0_out / block_last_out for callers that want all N layers).
@@ -49,7 +49,7 @@ struct EncoderBuild {
     // after the stride-2 second conv.
     ggml_tensor * out = nullptr;
 
-    EncoderDumps  dumps {};
+    EncoderDumps  dumps{};
     ggml_cgraph * graph = nullptr;
 };
 
@@ -59,11 +59,11 @@ struct EncoderBuild {
 // even values are accepted for test fixtures). use_flash selects
 // ggml_flash_attn_ext vs. manual mul_mat + soft_max; the caller gates it
 // against backend support. backend_name is informational only.
-EncoderBuild build_encoder_graph(ggml_context *          compute_ctx,
-                                 const WhisperWeights &  weights,
-                                 const WhisperHParams &  hp,
-                                 int                     n_mel_frames,
-                                 bool                    use_flash = true,
-                                 const char *            backend_name = "");
+EncoderBuild build_encoder_graph(ggml_context *         compute_ctx,
+                                 const WhisperWeights & weights,
+                                 const WhisperHParams & hp,
+                                 int                    n_mel_frames,
+                                 bool                   use_flash    = true,
+                                 const char *           backend_name = "");
 
-} // namespace transcribe::whisper
+}  // namespace transcribe::whisper
diff --git a/src/arch/whisper/model.cpp b/src/arch/whisper/model.cpp
index f0479077..3cca310d 100644
--- a/src/arch/whisper/model.cpp
+++ b/src/arch/whisper/model.cpp
@@ -4,12 +4,12 @@
 // path below; TRANSCRIBE_MEL_FROM_REF can inject a reference mel tensor
 // to isolate encoder/decoder drift during numerical validation.
 
-#include "whisper.h"
-
 #include "decoder.h"
 #include "encoder.h"
-#include "weights.h"
-
+#include "ggml-alloc.h"
+#include "ggml-backend.h"
+#include "ggml.h"
+#include "gguf.h"
 #include "transcribe-arch.h"
 #include "transcribe-batch-util.h"
 #include "transcribe-debug.h"
@@ -17,13 +17,10 @@
 #include "transcribe-flash-policy.h"
 #include "transcribe-load-common.h"
 #include "transcribe-loader.h"
-#include "transcribe-meta.h"
 #include "transcribe-log.h"
-
-#include "ggml.h"
-#include "ggml-alloc.h"
-#include "ggml-backend.h"
-#include "gguf.h"
+#include "transcribe-meta.h"
+#include "weights.h"
+#include "whisper.h"
 
 // miniz (vendored, src/third_party/miniz) replaces system zlib for the
 // compression-ratio heuristic below. Built trimmed with
@@ -50,7 +47,7 @@ namespace transcribe::whisper {
 
 extern const Arch arch;
 
-static_assert(std::is_base_of_v<transcribe_model,   WhisperModel>);
+static_assert(std::is_base_of_v<transcribe_model, WhisperModel>);
 static_assert(std::is_base_of_v<transcribe_session, WhisperSession>);
 
 WhisperModel::~WhisperModel() {
@@ -62,9 +59,7 @@ WhisperModel::~WhisperModel() {
         ggml_backend_buffer_free(backend_buffer);
         backend_buffer = nullptr;
     }
-    for (auto it = plan.scheduler_list.rbegin();
-         it != plan.scheduler_list.rend(); ++it)
-    {
+    for (auto it = plan.scheduler_list.rbegin(); it != plan.scheduler_list.rend(); ++it) {
         ggml_backend_free(*it);
     }
     plan.scheduler_list.clear();
@@ -86,15 +81,11 @@ WhisperSession::~WhisperSession() {
     compute_ctx_size = 0;
 }
 
-bool enc_out_init(WhisperEncOut & enc_out,
-                  ggml_backend_t  backend,
-                  int             d_model,
-                  int             T_enc)
-{
+bool enc_out_init(WhisperEncOut & enc_out, ggml_backend_t backend, int d_model, int T_enc) {
     enc_out.free();
 
-    const size_t ctx_size = ggml_tensor_overhead() + 256;
-    ggml_init_params params {};
+    const size_t     ctx_size = ggml_tensor_overhead() + 256;
+    ggml_init_params params{};
     params.mem_size   = ctx_size;
     params.mem_buffer = nullptr;
     params.no_alloc   = true;
@@ -105,8 +96,7 @@ bool enc_out_init(WhisperEncOut & enc_out,
         return false;
     }
 
-    enc_out.tensor = ggml_new_tensor_2d(enc_out.ctx, GGML_TYPE_F32,
-                                        d_model, T_enc);
+    enc_out.tensor = ggml_new_tensor_2d(enc_out.ctx, GGML_TYPE_F32, d_model, T_enc);
     ggml_set_name(enc_out.tensor, "enc_out");
 
     enc_out.buffer = ggml_backend_alloc_ctx_tensors(enc_out.ctx, backend);
@@ -124,12 +114,16 @@ bool enc_out_init(WhisperEncOut & enc_out,
 }
 
 int kv_pad_self_attn(transcribe::BackendKind kind, bool use_flash) {
-    if (!use_flash) return 1;
+    if (!use_flash) {
+        return 1;
+    }
     switch (kind) {
         // Match whisper.cpp's whisper_kv_cache_get_padding (Metal+FA).
-        case transcribe::BackendKind::Metal: return 32;
+        case transcribe::BackendKind::Metal:
+            return 32;
         // CUDA uses 256 in whisper.cpp; not exercised here yet.
-        default: return 1;
+        default:
+            return 1;
     }
 }
 
@@ -139,17 +133,17 @@ bool kv_cache_init(WhisperKvCache & cache,
                    int              T_enc,
                    int              d_model,
                    int              n_layer,
-                   ggml_type        kv_type)
-{
+                   ggml_type        kv_type) {
     if (kv_type != GGML_TYPE_F16 && kv_type != GGML_TYPE_F32) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "whisper kv_cache: unsupported kv_type=%d "
-                     "(only F16/F32)", static_cast<int>(kv_type));
+                "whisper kv_cache: unsupported kv_type=%d "
+                "(only F16/F32)",
+                static_cast<int>(kv_type));
         return false;
     }
 
-    const size_t ctx_size = 4 * ggml_tensor_overhead() + 256;
-    ggml_init_params params {};
+    const size_t     ctx_size = 4 * ggml_tensor_overhead() + 256;
+    ggml_init_params params{};
     params.mem_size   = ctx_size;
     params.mem_buffer = nullptr;
     params.no_alloc   = true;
@@ -167,8 +161,8 @@ bool kv_cache_init(WhisperKvCache & cache,
     // (buffer_clear below). With K=V=0 in the padded slots, the
     // unmasked FA cross-attn output picks up a small dilution
     // factor — whisper.cpp ships with this trade-off.
-    const int     T_enc_pad     = static_cast<int>(GGML_PAD(T_enc, k_cross_kv_pad));
-    const int64_t self_elements = static_cast<int64_t>(d_model) * n_layer * n_ctx;
+    const int     T_enc_pad      = static_cast<int>(GGML_PAD(T_enc, k_cross_kv_pad));
+    const int64_t self_elements  = static_cast<int64_t>(d_model) * n_layer * n_ctx;
     const int64_t cross_elements = static_cast<int64_t>(d_model) * n_layer * T_enc_pad;
 
     cache.self_k  = ggml_new_tensor_1d(cache.ctx, kv_type, self_elements);
@@ -176,8 +170,8 @@ bool kv_cache_init(WhisperKvCache & cache,
     cache.cross_k = ggml_new_tensor_1d(cache.ctx, kv_type, cross_elements);
     cache.cross_v = ggml_new_tensor_1d(cache.ctx, kv_type, cross_elements);
 
-    ggml_set_name(cache.self_k,  "kv_self_k");
-    ggml_set_name(cache.self_v,  "kv_self_v");
+    ggml_set_name(cache.self_k, "kv_self_k");
+    ggml_set_name(cache.self_v, "kv_self_v");
     ggml_set_name(cache.cross_k, "kv_cross_k");
     ggml_set_name(cache.cross_v, "kv_cross_v");
 
@@ -190,12 +184,12 @@ bool kv_cache_init(WhisperKvCache & cache,
     }
     ggml_backend_buffer_clear(cache.buffer, 0);
 
-    cache.n_ctx     = n_ctx;
-    cache.n_batch   = 1;
-    cache.T_enc     = T_enc;
-    cache.T_enc_pad = T_enc_pad;
-    cache.n         = 0;
-    cache.head      = 0;
+    cache.n_ctx           = n_ctx;
+    cache.n_batch         = 1;
+    cache.T_enc           = T_enc;
+    cache.T_enc_pad       = T_enc_pad;
+    cache.n               = 0;
+    cache.head            = 0;
     cache.cross_populated = false;
 
     return true;
@@ -208,25 +202,22 @@ bool kv_cache_init_batched(WhisperKvCache & cache,
                            int              d_model,
                            int              n_layer,
                            int              n_batch,
-                           ggml_type        kv_type)
-{
+                           ggml_type        kv_type) {
     if (n_batch <= 1) {
         // Degenerate batch — defer to the single-shot layout so callers
         // that accidentally pass n_batch==1 stay byte-identical.
-        return kv_cache_init(cache, backend, n_ctx, T_enc, d_model,
-                             n_layer, kv_type);
+        return kv_cache_init(cache, backend, n_ctx, T_enc, d_model, n_layer, kv_type);
     }
     if (kv_type != GGML_TYPE_F16 && kv_type != GGML_TYPE_F32) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "whisper kv_cache(batched): unsupported kv_type=%d",
-                     static_cast<int>(kv_type));
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "whisper kv_cache(batched): unsupported kv_type=%d",
+                static_cast<int>(kv_type));
         return false;
     }
 
     cache.free();
 
-    const size_t ctx_size = 4 * ggml_tensor_overhead() + 256;
-    ggml_init_params params {};
+    const size_t     ctx_size = 4 * ggml_tensor_overhead() + 256;
+    ggml_init_params params{};
     params.mem_size   = ctx_size;
     params.mem_buffer = nullptr;
     params.no_alloc   = true;
@@ -240,18 +231,16 @@ bool kv_cache_init_batched(WhisperKvCache & cache,
     // No 256-row cross pad in the batched layout: every short-form
     // utterance has T_enc == 1500 and the batched cross graph writes the
     // full slab; the per-utterance cross-pad mask gates invalid columns.
-    const int64_t self_elements =
-        static_cast<int64_t>(d_model) * n_ctx * n_batch * n_layer;
-    const int64_t cross_elements =
-        static_cast<int64_t>(d_model) * T_enc * n_batch * n_layer;
+    const int64_t self_elements  = static_cast<int64_t>(d_model) * n_ctx * n_batch * n_layer;
+    const int64_t cross_elements = static_cast<int64_t>(d_model) * T_enc * n_batch * n_layer;
 
     cache.self_k  = ggml_new_tensor_1d(cache.ctx, kv_type, self_elements);
     cache.self_v  = ggml_new_tensor_1d(cache.ctx, kv_type, self_elements);
     cache.cross_k = ggml_new_tensor_1d(cache.ctx, kv_type, cross_elements);
     cache.cross_v = ggml_new_tensor_1d(cache.ctx, kv_type, cross_elements);
 
-    ggml_set_name(cache.self_k,  "kv_self_k_b");
-    ggml_set_name(cache.self_v,  "kv_self_v_b");
+    ggml_set_name(cache.self_k, "kv_self_k_b");
+    ggml_set_name(cache.self_v, "kv_self_v_b");
     ggml_set_name(cache.cross_k, "kv_cross_k_b");
     ggml_set_name(cache.cross_v, "kv_cross_v_b");
 
@@ -264,12 +253,12 @@ bool kv_cache_init_batched(WhisperKvCache & cache,
     }
     ggml_backend_buffer_clear(cache.buffer, 0);
 
-    cache.n_ctx     = n_ctx;
-    cache.n_batch   = n_batch;
-    cache.T_enc     = T_enc;
-    cache.T_enc_pad = T_enc;   // no extra pad in batched layout
-    cache.n         = 0;
-    cache.head      = 0;
+    cache.n_ctx           = n_ctx;
+    cache.n_batch         = n_batch;
+    cache.T_enc           = T_enc;
+    cache.T_enc_pad       = T_enc;  // no extra pad in batched layout
+    cache.n               = 0;
+    cache.head            = 0;
     cache.cross_populated = false;
 
     return true;
@@ -293,10 +282,10 @@ bool ensure_compute_ctx(WhisperSession * cc, size_t mem) {
         cc->compute_ctx_size = 0;
     }
 
-    ggml_init_params p {};
-    p.mem_size   = mem;
-    p.mem_buffer = nullptr;
-    p.no_alloc   = true;
+    ggml_init_params p{};
+    p.mem_size      = mem;
+    p.mem_buffer    = nullptr;
+    p.no_alloc      = true;
     cc->compute_ctx = ggml_init(p);
     if (cc->compute_ctx == nullptr) {
         return false;
@@ -313,10 +302,7 @@ bool ensure_compute_ctx(WhisperSession * cc, size_t mem) {
 // metric most directly comparable to whisper.cpp's bench numbers.
 void print_whisper_perf(const WhisperPerf & p) {
     auto avg_us = [](const WhisperPerfStage & s) -> double {
-        return s.count > 0
-                   ? static_cast<double>(s.total_us) /
-                         static_cast<double>(s.count)
-                   : 0.0;
+        return s.count > 0 ? static_cast<double>(s.total_us) / static_cast<double>(s.count) : 0.0;
     };
     auto ms = [](int64_t us) -> double {
         return static_cast<double>(us) / 1000.0;
@@ -325,87 +311,70 @@ void print_whisper_perf(const WhisperPerf & p) {
         return s.total_us;
     };
 
-    const int64_t enc_total =
-        stage_total(p.enc_build) + stage_total(p.enc_alloc) +
-        stage_total(p.enc_compute) + stage_total(p.enc_tensor_get);
-    const int64_t cross_total =
-        stage_total(p.cross_build) + stage_total(p.cross_alloc) +
-        stage_total(p.cross_compute);
-    const int64_t prompt_total =
-        stage_total(p.prompt_build) + stage_total(p.prompt_alloc) +
-        stage_total(p.prompt_compute) + stage_total(p.prompt_tensor_get) +
-        stage_total(p.prompt_cpu);
-    const int64_t step_total =
-        stage_total(p.step_build) + stage_total(p.step_alloc) +
-        stage_total(p.step_compute) + stage_total(p.step_tensor_get) +
-        stage_total(p.step_cpu);
-
-    log_msg(TRANSCRIBE_LOG_LEVEL_DEBUG,
-        "[whisper-perf] chunks=%d  encs=%d  crosses=%d  prompts=%d  steps=%d",
-        p.chunks, p.enc_compute.count, p.cross_compute.count,
-        p.prompt_compute.count, p.step_compute.count);
+    const int64_t enc_total    = stage_total(p.enc_build) + stage_total(p.enc_alloc) + stage_total(p.enc_compute) +
+                                 stage_total(p.enc_tensor_get);
+    const int64_t cross_total  = stage_total(p.cross_build) + stage_total(p.cross_alloc) + stage_total(p.cross_compute);
+    const int64_t prompt_total = stage_total(p.prompt_build) + stage_total(p.prompt_alloc) +
+                                 stage_total(p.prompt_compute) + stage_total(p.prompt_tensor_get) +
+                                 stage_total(p.prompt_cpu);
+    const int64_t step_total   = stage_total(p.step_build) + stage_total(p.step_alloc) + stage_total(p.step_compute) +
+                                 stage_total(p.step_tensor_get) + stage_total(p.step_cpu);
+
+    log_msg(TRANSCRIBE_LOG_LEVEL_DEBUG, "[whisper-perf] chunks=%d  encs=%d  crosses=%d  prompts=%d  steps=%d", p.chunks,
+            p.enc_compute.count, p.cross_compute.count, p.prompt_compute.count, p.step_compute.count);
     log_msg(TRANSCRIBE_LOG_LEVEL_DEBUG,
-        "[whisper-perf] enc    total=%7.2f ms  build=%7.2f  alloc=%7.2f  "
-        "compute=%7.2f  tget=%7.2f",
-        ms(enc_total), ms(p.enc_build.total_us), ms(p.enc_alloc.total_us),
-        ms(p.enc_compute.total_us), ms(p.enc_tensor_get.total_us));
+            "[whisper-perf] enc    total=%7.2f ms  build=%7.2f  alloc=%7.2f  "
+            "compute=%7.2f  tget=%7.2f",
+            ms(enc_total), ms(p.enc_build.total_us), ms(p.enc_alloc.total_us), ms(p.enc_compute.total_us),
+            ms(p.enc_tensor_get.total_us));
     log_msg(TRANSCRIBE_LOG_LEVEL_DEBUG,
-        "[whisper-perf] cross  total=%7.2f ms  build=%7.2f  alloc=%7.2f  "
-        "compute=%7.2f",
-        ms(cross_total), ms(p.cross_build.total_us),
-        ms(p.cross_alloc.total_us), ms(p.cross_compute.total_us));
+            "[whisper-perf] cross  total=%7.2f ms  build=%7.2f  alloc=%7.2f  "
+            "compute=%7.2f",
+            ms(cross_total), ms(p.cross_build.total_us), ms(p.cross_alloc.total_us), ms(p.cross_compute.total_us));
     log_msg(TRANSCRIBE_LOG_LEVEL_DEBUG,
-        "[whisper-perf] prompt total=%7.2f ms  build=%7.2f  alloc=%7.2f  "
-        "compute=%7.2f  tget=%7.2f  cpu=%7.2f",
-        ms(prompt_total), ms(p.prompt_build.total_us),
-        ms(p.prompt_alloc.total_us), ms(p.prompt_compute.total_us),
-        ms(p.prompt_tensor_get.total_us), ms(p.prompt_cpu.total_us));
+            "[whisper-perf] prompt total=%7.2f ms  build=%7.2f  alloc=%7.2f  "
+            "compute=%7.2f  tget=%7.2f  cpu=%7.2f",
+            ms(prompt_total), ms(p.prompt_build.total_us), ms(p.prompt_alloc.total_us), ms(p.prompt_compute.total_us),
+            ms(p.prompt_tensor_get.total_us), ms(p.prompt_cpu.total_us));
     log_msg(TRANSCRIBE_LOG_LEVEL_DEBUG,
-        "[whisper-perf] step   total=%7.2f ms  build=%7.2f  alloc=%7.2f  "
-        "compute=%7.2f  tget=%7.2f  cpu=%7.2f",
-        ms(step_total), ms(p.step_build.total_us),
-        ms(p.step_alloc.total_us), ms(p.step_compute.total_us),
-        ms(p.step_tensor_get.total_us), ms(p.step_cpu.total_us));
+            "[whisper-perf] step   total=%7.2f ms  build=%7.2f  alloc=%7.2f  "
+            "compute=%7.2f  tget=%7.2f  cpu=%7.2f",
+            ms(step_total), ms(p.step_build.total_us), ms(p.step_alloc.total_us), ms(p.step_compute.total_us),
+            ms(p.step_tensor_get.total_us), ms(p.step_cpu.total_us));
     log_msg(TRANSCRIBE_LOG_LEVEL_DEBUG,
-        "[whisper-perf] step avg us  build=%6.1f  alloc=%6.1f  "
-        "compute=%6.1f  tget=%6.1f  cpu=%6.1f",
-        avg_us(p.step_build), avg_us(p.step_alloc),
-        avg_us(p.step_compute), avg_us(p.step_tensor_get),
-        avg_us(p.step_cpu));
+            "[whisper-perf] step avg us  build=%6.1f  alloc=%6.1f  "
+            "compute=%6.1f  tget=%6.1f  cpu=%6.1f",
+            avg_us(p.step_build), avg_us(p.step_alloc), avg_us(p.step_compute), avg_us(p.step_tensor_get),
+            avg_us(p.step_cpu));
 
     // CPU sub-section breakdown — opt-in via TRANSCRIBE_PERF_DEBUG values
     // that contain "cpu" or "all". Keeps the default profile output
     // unchanged for existing benchmarks while still surfacing
     // suppress/timestamp/sample/logprob splits when needed.
-    const char * profile_env = transcribe::env::str("TRANSCRIBE_PERF_DEBUG");
-    bool show_cpu_breakdown = false;
+    const char * profile_env        = transcribe::env::str("TRANSCRIBE_PERF_DEBUG");
+    bool         show_cpu_breakdown = false;
     if (profile_env != nullptr) {
         const std::string v = profile_env;
-        if (v.find("cpu") != std::string::npos ||
-            v.find("all") != std::string::npos) {
+        if (v.find("cpu") != std::string::npos || v.find("all") != std::string::npos) {
             show_cpu_breakdown = true;
         }
     }
     if (show_cpu_breakdown) {
         log_msg(TRANSCRIBE_LOG_LEVEL_DEBUG,
-            "[whisper-perf] prompt cpu  suppress=%7.2f  ts=%7.2f  "
-            "sample=%7.2f  logprob=%7.2f  (ms)",
-            ms(p.prompt_cpu_suppress.total_us),
-            ms(p.prompt_cpu_timestamp.total_us),
-            ms(p.prompt_cpu_sample.total_us),
-            ms(p.prompt_cpu_logprob.total_us));
+                "[whisper-perf] prompt cpu  suppress=%7.2f  ts=%7.2f  "
+                "sample=%7.2f  logprob=%7.2f  (ms)",
+                ms(p.prompt_cpu_suppress.total_us), ms(p.prompt_cpu_timestamp.total_us),
+                ms(p.prompt_cpu_sample.total_us), ms(p.prompt_cpu_logprob.total_us));
         log_msg(TRANSCRIBE_LOG_LEVEL_DEBUG,
-            "[whisper-perf] step   cpu  suppress=%7.2f  ts=%7.2f  "
-            "sample=%7.2f  logprob=%7.2f  (ms)",
-            ms(p.step_cpu_suppress.total_us),
-            ms(p.step_cpu_timestamp.total_us),
-            ms(p.step_cpu_sample.total_us),
-            ms(p.step_cpu_logprob.total_us));
+                "[whisper-perf] step   cpu  suppress=%7.2f  ts=%7.2f  "
+                "sample=%7.2f  logprob=%7.2f  (ms)",
+                ms(p.step_cpu_suppress.total_us), ms(p.step_cpu_timestamp.total_us), ms(p.step_cpu_sample.total_us),
+                ms(p.step_cpu_logprob.total_us));
         log_msg(TRANSCRIBE_LOG_LEVEL_DEBUG,
-            "[whisper-perf] step avg us  suppress=%6.1f  ts=%6.1f  "
-            "sample=%6.1f  logprob=%6.1f",
-            avg_us(p.step_cpu_suppress), avg_us(p.step_cpu_timestamp),
-            avg_us(p.step_cpu_sample),   avg_us(p.step_cpu_logprob));
+                "[whisper-perf] step avg us  suppress=%6.1f  ts=%6.1f  "
+                "sample=%6.1f  logprob=%6.1f",
+                avg_us(p.step_cpu_suppress), avg_us(p.step_cpu_timestamp), avg_us(p.step_cpu_sample),
+                avg_us(p.step_cpu_logprob));
     }
 }
 
@@ -414,14 +383,12 @@ bool whisper_perf_enabled() {
 }
 
 // load
-transcribe_status whisper_load(
-    Loader &                          loader,
-    const transcribe_model_load_params *   params,
-    transcribe_model **               out_model)
-{
+transcribe_status whisper_load(Loader &                             loader,
+                               const transcribe_model_load_params * params,
+                               transcribe_model **                  out_model) {
     const int64_t t_load_start = ggml_time_us();
 
-    auto m = std::make_unique<WhisperModel>();
+    auto m       = std::make_unique<WhisperModel>();
     m->arch      = &arch;
     m->t_load_us = 0;
     m->variant   = loader.variant().empty() ? k_default_variant : loader.variant();
@@ -429,9 +396,7 @@ transcribe_status whisper_load(
 
     // Hparams first: the frontend / encoder config and the decoder
     // vocab size come from here.
-    if (const transcribe_status st = read_whisper_hparams(loader.gguf(), m->hparams);
-        st != TRANSCRIBE_OK)
-    {
+    if (const transcribe_status st = read_whisper_hparams(loader.gguf(), m->hparams); st != TRANSCRIBE_OK) {
         return st;
     }
 
@@ -440,9 +405,7 @@ transcribe_status whisper_load(
     // vocab (51865 multilingual) exceeds tokenizer.tokens (50258) because
     // language/timestamp/task specials are model-emitted but not in the tokens
     // array. That gap is by design.
-    if (const transcribe_status st = m->tok.load(loader.gguf());
-        st != TRANSCRIBE_OK)
-    {
+    if (const transcribe_status st = m->tok.load(loader.gguf()); st != TRANSCRIBE_OK) {
         return st;
     }
     // Whisper uses the canonical GPT-2 pretokenizer regex (digit runs
@@ -472,80 +435,64 @@ transcribe_status whisper_load(
         std::vector<float> win_buf;
 
         const size_t fb_elems =
-            static_cast<size_t>(m->hparams.fe_num_mels) *
-            static_cast<size_t>(m->hparams.fe_n_fft / 2 + 1);
+            static_cast<size_t>(m->hparams.fe_num_mels) * static_cast<size_t>(m->hparams.fe_n_fft / 2 + 1);
         const auto fb_rc = transcribe::load_common::read_f32_tensor_checked(
-            loader.gguf(), loader.path(),
-            "frontend.mel_filterbank", fb_elems,
-            "whisper", fb_buf);
+            loader.gguf(), loader.path(), "frontend.mel_filterbank", fb_elems, "whisper", fb_buf);
         if (fb_rc != R::Ok && fb_rc != R::Absent) {
             return TRANSCRIBE_ERR_GGUF;
         }
         const size_t win_elems = static_cast<size_t>(m->hparams.fe_n_fft);
-        const auto win_rc = transcribe::load_common::read_f32_tensor_checked(
-            loader.gguf(), loader.path(),
-            "frontend.window", win_elems,
-            "whisper", win_buf);
+        const auto   win_rc    = transcribe::load_common::read_f32_tensor_checked(
+            loader.gguf(), loader.path(), "frontend.window", win_elems, "whisper", win_buf);
         if (win_rc != R::Ok && win_rc != R::Absent) {
             return TRANSCRIBE_ERR_GGUF;
         }
 
-        if (const transcribe_status st = install_mel_from_buffers(
-                m->hparams, std::move(fb_buf), std::move(win_buf), m->mel);
-            st != TRANSCRIBE_OK)
-        {
+        if (const transcribe_status st =
+                install_mel_from_buffers(m->hparams, std::move(fb_buf), std::move(win_buf), m->mel);
+            st != TRANSCRIBE_OK) {
             return st;
         }
     }
 
     // Reopen with no_alloc to build the tensor catalog.
-    gguf_init_params init_params {};
+    gguf_init_params init_params{};
     init_params.no_alloc = true;
     init_params.ctx      = &m->ctx_meta;
 
-    gguf_context * gguf_data = gguf_init_from_file(loader.path().c_str(),
-                                                   init_params);
+    gguf_context * gguf_data = gguf_init_from_file(loader.path().c_str(), init_params);
     if (gguf_data == nullptr) {
         return TRANSCRIBE_ERR_GGUF;
     }
 
-    if (const transcribe_status st = build_whisper_weights(
-            m->ctx_meta, m->hparams, m->weights);
-        st != TRANSCRIBE_OK)
-    {
+    if (const transcribe_status st = build_whisper_weights(m->ctx_meta, m->hparams, m->weights); st != TRANSCRIBE_OK) {
         gguf_free(gguf_data);
         return st;
     }
 
     // Backend plan.
-    const transcribe_backend_request backend_req =
-        (params != nullptr) ? params->backend : TRANSCRIBE_BACKEND_AUTO;
+    const transcribe_backend_request backend_req = (params != nullptr) ? params->backend : TRANSCRIBE_BACKEND_AUTO;
     if (const transcribe_status st = transcribe::load_common::init_backends(
             backend_req, (params != nullptr) ? params->gpu_device : 0, "whisper", m->plan);
-        st != TRANSCRIBE_OK)
-    {
+        st != TRANSCRIBE_OK) {
         gguf_free(gguf_data);
         return st;
     }
-    m->backend = ggml_backend_name(m->plan.primary);
+    m->backend         = ggml_backend_name(m->plan.primary);
     m->primary_backend = m->plan.primary;
 
-    ggml_backend_buffer_t weights_buffer =
-        ggml_backend_alloc_ctx_tensors(m->ctx_meta, m->plan.primary);
+    ggml_backend_buffer_t weights_buffer = ggml_backend_alloc_ctx_tensors(m->ctx_meta, m->plan.primary);
     if (weights_buffer == nullptr) {
         gguf_free(gguf_data);
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "whisper: ggml_backend_alloc_ctx_tensors failed");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "whisper: ggml_backend_alloc_ctx_tensors failed");
         return TRANSCRIBE_ERR_GGUF;
     }
     m->backend_buffer = weights_buffer;
-    ggml_backend_buffer_set_usage(weights_buffer,
-                                  GGML_BACKEND_BUFFER_USAGE_WEIGHTS);
+    ggml_backend_buffer_set_usage(weights_buffer, GGML_BACKEND_BUFFER_USAGE_WEIGHTS);
 
-    if (const transcribe_status st = transcribe::load_common::stream_tensor_data(
-            loader.path(), gguf_data, m->ctx_meta, "whisper");
-        st != TRANSCRIBE_OK)
-    {
+    if (const transcribe_status st =
+            transcribe::load_common::stream_tensor_data(loader.path(), gguf_data, m->ctx_meta, "whisper");
+        st != TRANSCRIBE_OK) {
         gguf_free(gguf_data);
         return st;
     }
@@ -557,14 +504,10 @@ transcribe_status whisper_load(
     m->caps.n_languages = 0;
     m->caps.languages   = nullptr;
 
-    if (const transcribe_status st = read_capability_kv(loader.gguf(), m->caps);
-        st != TRANSCRIBE_OK)
-    {
+    if (const transcribe_status st = read_capability_kv(loader.gguf(), m->caps); st != TRANSCRIBE_OK) {
         return st;
     }
-    if (const transcribe_status st = read_languages_kv(loader.gguf(), *m);
-        st != TRANSCRIBE_OK)
-    {
+    if (const transcribe_status st = read_languages_kv(loader.gguf(), *m); st != TRANSCRIBE_OK) {
         return st;
     }
 
@@ -586,18 +529,20 @@ transcribe_status whisper_load(
         }
         for (int i = 0; i < m->caps.n_languages; ++i) {
             const char * code = m->caps.languages[i];
-            if (code == nullptr || code[0] == '\0') continue;
+            if (code == nullptr || code[0] == '\0') {
+                continue;
+            }
             m->lang_codes.emplace_back(code);
             if (!is_multilingual) {
                 continue;
             }
             const std::string piece = std::string("<|") + code + "|>";
-            const int id = m->tok.find(piece);
+            const int         id    = m->tok.find(piece);
             if (id < 0) {
                 log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                             "whisper: language '%s' has no '%s' token "
-                             "in tokenizer vocab",
-                             code, piece.c_str());
+                        "whisper: language '%s' has no '%s' token "
+                        "in tokenizer vocab",
+                        code, piece.c_str());
                 return TRANSCRIBE_ERR_GGUF;
             }
             m->lang_token_ids.push_back(static_cast<int32_t>(id));
@@ -605,21 +550,19 @@ transcribe_status whisper_load(
     }
 
     m->t_load_us = ggml_time_us() - t_load_start;
-    *out_model = m.release();
+    *out_model   = m.release();
     return TRANSCRIBE_OK;
 }
 
 // init_context
-transcribe_status whisper_init_context(
-    transcribe_model *                model,
-    const transcribe_session_params * params,
-    transcribe_session **             out_ctx)
-{
+transcribe_status whisper_init_context(transcribe_model *                model,
+                                       const transcribe_session_params * params,
+                                       transcribe_session **             out_ctx) {
     if (model->arch != &arch) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
 
-    auto cc = std::make_unique<WhisperSession>();
+    auto cc       = std::make_unique<WhisperSession>();
     cc->model     = model;
     cc->n_threads = params->n_threads;
     cc->kv_type   = params->kv_type;
@@ -627,8 +570,7 @@ transcribe_status whisper_init_context(
     // Whisper defaults: both flash-on (see WhisperSession). Env overrides below.
     cc->encoder_use_flash = true;
     cc->decoder_use_flash = true;
-    transcribe::flash::apply_env_overrides(
-        cc->encoder_use_flash, cc->decoder_use_flash);
+    transcribe::flash::apply_env_overrides(cc->encoder_use_flash, cc->decoder_use_flash);
 
     *out_ctx = cc.release();
     return TRANSCRIBE_OK;
@@ -650,25 +592,21 @@ namespace {
 // allow_dumps gates encoder-intermediate emission: true for the first chunk
 // (and short-form), false afterwards so the long-form loop doesn't overwrite
 // the first chunk's dumps.
-transcribe_status run_whisper_encoder_on_window(
-    WhisperSession * cc,
-    WhisperModel *   cm,
-    const float *    mel_data,
-    int              n_mels,
-    int              n_mel_frames,
-    bool             allow_dumps,
-    int &            out_T_enc)
-{
+transcribe_status run_whisper_encoder_on_window(WhisperSession * cc,
+                                                WhisperModel *   cm,
+                                                const float *    mel_data,
+                                                int              n_mels,
+                                                int              n_mel_frames,
+                                                bool             allow_dumps,
+                                                int &            out_T_enc) {
     const int64_t t_enc_build_start = ggml_time_us();
     if (!ensure_compute_ctx(cc, 8 * 1024 * 1024)) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "whisper run: ensure_compute_ctx (encoder) failed");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "whisper run: ensure_compute_ctx (encoder) failed");
         return TRANSCRIBE_ERR_GGUF;
     }
 
-    EncoderBuild eb = build_encoder_graph(
-        cc->compute_ctx, cm->weights, cm->hparams, n_mel_frames,
-        cc->encoder_use_flash, cm->backend.c_str());
+    EncoderBuild eb = build_encoder_graph(cc->compute_ctx, cm->weights, cm->hparams, n_mel_frames,
+                                          cc->encoder_use_flash, cm->backend.c_str());
     if (eb.mel_in == nullptr || eb.out == nullptr || eb.graph == nullptr) {
         return TRANSCRIBE_ERR_GGUF;
     }
@@ -680,38 +618,25 @@ transcribe_status run_whisper_encoder_on_window(
     {
         const int d_enc_g = static_cast<int>(eb.out->ne[0]);
         const int T_enc_g = static_cast<int>(eb.out->ne[1]);
-        if (cc->enc_out.tensor == nullptr ||
-            cc->enc_out.d_model != d_enc_g ||
-            cc->enc_out.T_enc   != T_enc_g)
-        {
-            if (!enc_out_init(cc->enc_out, cm->plan.primary,
-                              d_enc_g, T_enc_g))
-            {
-                log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                             "whisper run: enc_out_init failed");
+        if (cc->enc_out.tensor == nullptr || cc->enc_out.d_model != d_enc_g || cc->enc_out.T_enc != T_enc_g) {
+            if (!enc_out_init(cc->enc_out, cm->plan.primary, d_enc_g, T_enc_g)) {
+                log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "whisper run: enc_out_init failed");
                 return TRANSCRIBE_ERR_GGUF;
             }
         }
-        ggml_tensor * enc_out_view = ggml_view_2d(
-            cc->compute_ctx, cc->enc_out.tensor,
-            d_enc_g, T_enc_g,
-            cc->enc_out.tensor->nb[1],
-            0);
-        ggml_build_forward_expand(
-            eb.graph, ggml_cpy(cc->compute_ctx, eb.out, enc_out_view));
+        ggml_tensor * enc_out_view =
+            ggml_view_2d(cc->compute_ctx, cc->enc_out.tensor, d_enc_g, T_enc_g, cc->enc_out.tensor->nb[1], 0);
+        ggml_build_forward_expand(eb.graph, ggml_cpy(cc->compute_ctx, eb.out, enc_out_view));
     }
     cc->perf.enc_build.add(ggml_time_us() - t_enc_build_start);
 
     // Allocate + compute encoder graph.
     const int64_t t_enc_alloc_start = ggml_time_us();
     if (cc->sched == nullptr) {
-        cc->sched = ggml_backend_sched_new(
-            cm->plan.scheduler_list.data(), nullptr,
-            static_cast<int>(cm->plan.scheduler_list.size()),
-            16384, false, true);
+        cc->sched = ggml_backend_sched_new(cm->plan.scheduler_list.data(), nullptr,
+                                           static_cast<int>(cm->plan.scheduler_list.size()), 16384, false, true);
         if (cc->sched == nullptr) {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "whisper run: ggml_backend_sched_new failed");
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "whisper run: ggml_backend_sched_new failed");
             return TRANSCRIBE_ERR_GGUF;
         }
 
@@ -724,27 +649,20 @@ transcribe_status run_whisper_encoder_on_window(
     ggml_backend_sched_reset(cc->sched);
     if (!ggml_backend_sched_alloc_graph(cc->sched, eb.graph)) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "whisper run: ggml_backend_sched_alloc_graph failed "
-                     "(encoder)");
+                "whisper run: ggml_backend_sched_alloc_graph failed "
+                "(encoder)");
         return TRANSCRIBE_ERR_GGUF;
     }
 
     // Upload mel.
-    const size_t mel_bytes = static_cast<size_t>(n_mels) *
-                             static_cast<size_t>(n_mel_frames) *
-                             sizeof(float);
+    const size_t mel_bytes = static_cast<size_t>(n_mels) * static_cast<size_t>(n_mel_frames) * sizeof(float);
     ggml_backend_tensor_set(eb.mel_in, mel_data, 0, mel_bytes);
     cc->perf.enc_alloc.add(ggml_time_us() - t_enc_alloc_start);
 
     // Compute.
     const int64_t t_enc_compute_start = ggml_time_us();
-    if (const ggml_status gs =
-            ggml_backend_sched_graph_compute(cc->sched, eb.graph);
-        gs != GGML_STATUS_SUCCESS)
-    {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "whisper run: encoder graph compute failed (%d)",
-                     static_cast<int>(gs));
+    if (const ggml_status gs = ggml_backend_sched_graph_compute(cc->sched, eb.graph); gs != GGML_STATUS_SUCCESS) {
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "whisper run: encoder graph compute failed (%d)", static_cast<int>(gs));
         return TRANSCRIBE_ERR_GGUF;
     }
     cc->perf.enc_compute.add(ggml_time_us() - t_enc_compute_start);
@@ -752,17 +670,15 @@ transcribe_status run_whisper_encoder_on_window(
     // Dumps. Only the first (or only) chunk emits intermediates so the
     // reference comparison sees stable output.
     if (allow_dumps) {
-        auto try_dump = [](const char * name, ggml_tensor * t,
-                           const char * stage)
-        {
+        auto try_dump = [](const char * name, ggml_tensor * t, const char * stage) {
             if (t != nullptr) {
                 transcribe::debug::dump_tensor(name, t, stage);
             }
         };
-        try_dump("enc.mel.in",    eb.dumps.mel_in,    "encoder.mel");
+        try_dump("enc.mel.in", eb.dumps.mel_in, "encoder.mel");
         try_dump("enc.conv1.out", eb.dumps.conv1_out, "encoder.conv1");
         try_dump("enc.conv2.out", eb.dumps.conv2_out, "encoder.conv2");
-        try_dump("enc.pos_emb",   eb.dumps.pos_emb,   "encoder.pos_emb");
+        try_dump("enc.pos_emb", eb.dumps.pos_emb, "encoder.pos_emb");
         try_dump("enc.embed.out", eb.dumps.embed_out, "encoder.embed");
         for (size_t i = 0; i < eb.dumps.block_outs.size(); ++i) {
             char bname[64], stage[64];
@@ -778,7 +694,7 @@ transcribe_status run_whisper_encoder_on_window(
     const int d_enc = static_cast<int>(eb.out->ne[0]);
     out_T_enc       = static_cast<int>(eb.out->ne[1]);
     cc->enc_T       = out_T_enc;
-    (void)d_enc;
+    (void) d_enc;
     return TRANSCRIBE_OK;
 }
 
@@ -795,39 +711,32 @@ transcribe_status run_whisper_encoder_on_window(
 // threshold, not numeric output, so small deltas do not move WER.
 //
 // Zero-length input returns 0 (no raw bytes to score).
-float compute_compression_ratio_hf(
-    const std::vector<int32_t> & tokens,
-    int64_t                      vocab_size)
-{
-    if (tokens.empty()) return 0.0f;
+float compute_compression_ratio_hf(const std::vector<int32_t> & tokens, int64_t vocab_size) {
+    if (tokens.empty()) {
+        return 0.0f;
+    }
     int bytes_per_token = 1;
     if (vocab_size > 1) {
         const double lg2 = std::log2(static_cast<double>(vocab_size));
-        bytes_per_token = static_cast<int>(std::floor(lg2 / 8.0)) + 1;
+        bytes_per_token  = static_cast<int>(std::floor(lg2 / 8.0)) + 1;
     }
 
-    std::vector<uint8_t> raw(tokens.size() *
-                             static_cast<size_t>(bytes_per_token));
+    std::vector<uint8_t> raw(tokens.size() * static_cast<size_t>(bytes_per_token));
     for (size_t i = 0; i < tokens.size(); ++i) {
-        uint64_t v = static_cast<uint64_t>(
-            static_cast<uint32_t>(tokens[i]));  // Whisper ids fit in u32
+        uint64_t v = static_cast<uint64_t>(static_cast<uint32_t>(tokens[i]));  // Whisper ids fit in u32
         for (int b = 0; b < bytes_per_token; ++b) {
-            raw[i * bytes_per_token + b] =
-                static_cast<uint8_t>((v >> (8 * b)) & 0xFF);
+            raw[i * bytes_per_token + b] = static_cast<uint8_t>((v >> (8 * b)) & 0xFF);
         }
     }
 
-    mz_ulong dest_len = mz_compressBound(static_cast<mz_ulong>(raw.size()));
+    mz_ulong                   dest_len = mz_compressBound(static_cast<mz_ulong>(raw.size()));
     std::vector<unsigned char> compressed(dest_len);
-    const int rc = mz_compress(compressed.data(), &dest_len,
-                               raw.data(),
-                               static_cast<mz_ulong>(raw.size()));
+    const int rc = mz_compress(compressed.data(), &dest_len, raw.data(), static_cast<mz_ulong>(raw.size()));
     if (rc != MZ_OK || dest_len == 0) {
         // Degenerate: treat as unratio-able so thresholds pass.
         return 0.0f;
     }
-    return static_cast<float>(raw.size()) /
-           static_cast<float>(dest_len);
+    return static_cast<float>(raw.size()) / static_cast<float>(dest_len);
 }
 
 // Sample from a distribution defined by last_logits at temperature T.
@@ -841,18 +750,19 @@ float compute_compression_ratio_hf(
 //
 // `scratch` is reused across calls to avoid the per-step double[vocab] alloc on
 // the T>0 hot path; sized lazily.
-int sample_from_logits(
-    const std::vector<float> & logits,
-    float                      temperature,
-    std::mt19937 &             rng,
-    std::vector<double> *      scratch = nullptr)
-{
+int sample_from_logits(const std::vector<float> & logits,
+                       float                      temperature,
+                       std::mt19937 &             rng,
+                       std::vector<double> *      scratch = nullptr) {
     const int n = static_cast<int>(logits.size());
     if (temperature <= 0.0f) {
-        int best_id = 0;
-        float best  = logits[0];
+        int   best_id = 0;
+        float best    = logits[0];
         for (int i = 1; i < n; ++i) {
-            if (logits[i] > best) { best = logits[i]; best_id = i; }
+            if (logits[i] > best) {
+                best    = logits[i];
+                best_id = i;
+            }
         }
         return best_id;
     }
@@ -862,7 +772,9 @@ int sample_from_logits(
     float max_l = -INFINITY;
     for (int i = 0; i < n; ++i) {
         const float l = logits[i];
-        if (std::isfinite(l) && l > max_l) max_l = l;
+        if (std::isfinite(l) && l > max_l) {
+            max_l = l;
+        }
     }
     if (!std::isfinite(max_l)) {
         // All -INF (shouldn't happen); fall back to argmax.
@@ -882,8 +794,7 @@ int sample_from_logits(
     for (int i = 0; i < n; ++i) {
         const float l = logits[i];
         if (std::isfinite(l)) {
-            const double p = std::exp(
-                static_cast<double>((l - max_l) / temperature));
+            const double p                = std::exp(static_cast<double>((l - max_l) / temperature));
             probs[static_cast<size_t>(i)] = p;
             sum += p;
         }
@@ -892,17 +803,21 @@ int sample_from_logits(
         // Defensive: argmax fallback.
         int best_id = 0;
         for (int i = 1; i < n; ++i) {
-            if (logits[i] > logits[best_id]) best_id = i;
+            if (logits[i] > logits[best_id]) {
+                best_id = i;
+            }
         }
         return best_id;
     }
 
     std::uniform_real_distribution<double> u(0.0, sum);
-    const double r = u(rng);
-    double acc = 0.0;
+    const double                           r   = u(rng);
+    double                                 acc = 0.0;
     for (int i = 0; i < n; ++i) {
         acc += probs[static_cast<size_t>(i)];
-        if (r < acc) return i;
+        if (r < acc) {
+            return i;
+        }
     }
     return n - 1;  // numerical edge
 }
@@ -918,18 +833,20 @@ int sample_from_logits(
 // contribute zero mass to the partition; if every entry is -INF
 // (shouldn't happen) the function returns id 0 with logprob -inf,
 // matching the existing fallback.
-int sample_argmax_and_logprob(
-    const std::vector<float> & logits,
-    float *                    out_logprob)
-{
-    const int n = static_cast<int>(logits.size());
-    int   best_id = 0;
-    float best_l  = logits[0];
-    float max_l   = std::isfinite(best_l) ? best_l : -INFINITY;
+int sample_argmax_and_logprob(const std::vector<float> & logits, float * out_logprob) {
+    const int n       = static_cast<int>(logits.size());
+    int       best_id = 0;
+    float     best_l  = logits[0];
+    float     max_l   = std::isfinite(best_l) ? best_l : -INFINITY;
     for (int i = 1; i < n; ++i) {
         const float l = logits[i];
-        if (l > best_l) { best_l = l; best_id = i; }
-        if (std::isfinite(l) && l > max_l) max_l = l;
+        if (l > best_l) {
+            best_l  = l;
+            best_id = i;
+        }
+        if (std::isfinite(l) && l > max_l) {
+            max_l = l;
+        }
     }
 
     if (out_logprob != nullptr) {
@@ -946,9 +863,8 @@ int sample_argmax_and_logprob(
             if (sum_exp <= 0.0) {
                 *out_logprob = -INFINITY;
             } else {
-                const float log_Z =
-                    max_l + static_cast<float>(std::log(sum_exp));
-                *out_logprob = best_l - log_Z;
+                const float log_Z = max_l + static_cast<float>(std::log(sum_exp));
+                *out_logprob      = best_l - log_Z;
             }
         }
     }
@@ -960,20 +876,18 @@ int sample_argmax_and_logprob(
 // — matches HF _retrieve_avg_logprobs scaling convention (the logits
 // stay the same shape but their relative gaps widen at low T, which is
 // the HF semantic choice).
-float logprob_of_token_hf(
-    const std::vector<float> & logits,
-    int                        token_id,
-    float                      temperature)
-{
+float logprob_of_token_hf(const std::vector<float> & logits, int token_id, float temperature) {
     const int n = static_cast<int>(logits.size());
     if (token_id < 0 || token_id >= n) {
         return -INFINITY;
     }
     const float rescale_T = (temperature > 0.0f) ? temperature : 1.0f;
-    float max_l = -INFINITY;
+    float       max_l     = -INFINITY;
     for (int i = 0; i < n; ++i) {
         const float l = logits[i] * rescale_T;
-        if (std::isfinite(l) && l > max_l) max_l = l;
+        if (std::isfinite(l) && l > max_l) {
+            max_l = l;
+        }
     }
     if (!std::isfinite(max_l)) {
         return -INFINITY;
@@ -985,7 +899,9 @@ float logprob_of_token_hf(
             sum_exp += std::exp(static_cast<double>(l - max_l));
         }
     }
-    if (sum_exp <= 0.0) return -INFINITY;
+    if (sum_exp <= 0.0) {
+        return -INFINITY;
+    }
     const float log_Z = max_l + static_cast<float>(std::log(sum_exp));
     return logits[token_id] * rescale_T - log_Z;
 }
@@ -995,44 +911,39 @@ float logprob_of_token_hf(
 // matches the reference dump: row-major (3000, 80) — exactly what we
 // need to upload into the ggml ne=[80, 3000] input tensor via a flat
 // memcpy.
-transcribe_status load_mel_from_ref(const char *         ref_dir,
-                                    int                  n_mels,
-                                    int                  n_mel_frames,
-                                    std::vector<float> & out)
-{
+transcribe_status load_mel_from_ref(const char * ref_dir, int n_mels, int n_mel_frames, std::vector<float> & out) {
     if (ref_dir == nullptr || ref_dir[0] == '\0') {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
     std::string path = ref_dir;
-    if (!path.empty() && path.back() != '/') path += '/';
+    if (!path.empty() && path.back() != '/') {
+        path += '/';
+    }
     path += "enc.mel.in.f32";
 
     std::ifstream f(path, std::ios::binary);
     if (!f) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "whisper run: cannot open mel ref '%s'", path.c_str());
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "whisper run: cannot open mel ref '%s'", path.c_str());
         return TRANSCRIBE_ERR_FILE_NOT_FOUND;
     }
 
-    const size_t n_elems = static_cast<size_t>(n_mels) *
-                           static_cast<size_t>(n_mel_frames);
+    const size_t n_elems = static_cast<size_t>(n_mels) * static_cast<size_t>(n_mel_frames);
     const size_t n_bytes = n_elems * sizeof(float);
 
     out.assign(n_elems, 0.0f);
-    f.read(reinterpret_cast<char *>(out.data()),
-           static_cast<std::streamsize>(n_bytes));
+    f.read(reinterpret_cast<char *>(out.data()), static_cast<std::streamsize>(n_bytes));
     if (static_cast<size_t>(f.gcount()) != n_bytes) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "whisper run: short read on mel ref '%s' "
-                     "(got %lld bytes, want %zu)",
-                     path.c_str(), static_cast<long long>(f.gcount()), n_bytes);
+                "whisper run: short read on mel ref '%s' "
+                "(got %lld bytes, want %zu)",
+                path.c_str(), static_cast<long long>(f.gcount()), n_bytes);
         return TRANSCRIBE_ERR_GGUF;
     }
     return TRANSCRIBE_OK;
 }
-#endif // TRANSCRIBE_ENABLE_VALIDATION_HOOKS
+#endif  // TRANSCRIBE_ENABLE_VALIDATION_HOOKS
 
-} // namespace
+}  // namespace
 
 namespace {
 
@@ -1040,16 +951,14 @@ namespace {
 // whisper_run_batch so per-step masking is identical. Mirrors transformers'
 // WhisperTimeStampLogitsProcessor. Mutates `logits` in place; no-op when
 // want_segment_timestamps is false.
-void apply_whisper_timestamp_rules(
-    std::vector<float> &         logits,
-    const std::vector<int32_t> & generated_ids,
-    bool                         want_segment_timestamps,
-    int                          no_timestamps_token_id,
-    int                          timestamp_begin,
-    int64_t                      vocab_size,
-    int                          eos_id,
-    int                          max_initial_timestamp_index)
-{
+void apply_whisper_timestamp_rules(std::vector<float> &         logits,
+                                   const std::vector<int32_t> & generated_ids,
+                                   bool                         want_segment_timestamps,
+                                   int                          no_timestamps_token_id,
+                                   int                          timestamp_begin,
+                                   int64_t                      vocab_size,
+                                   int                          eos_id,
+                                   int                          max_initial_timestamp_index) {
     if (!want_segment_timestamps) {
         return;
     }
@@ -1060,11 +969,8 @@ void apply_whisper_timestamp_rules(
         logits[static_cast<size_t>(no_timestamps_token_id)] = -INFINITY;
     }
 
-    const bool last_ts =
-        !generated_ids.empty() && token_is_timestamp(generated_ids.back());
-    const bool penult_ts =
-        generated_ids.size() < 2 ||
-        token_is_timestamp(generated_ids[generated_ids.size() - 2]);
+    const bool last_ts   = !generated_ids.empty() && token_is_timestamp(generated_ids.back());
+    const bool penult_ts = generated_ids.size() < 2 || token_is_timestamp(generated_ids[generated_ids.size() - 2]);
 
     if (last_ts) {
         if (penult_ts) {
@@ -1081,10 +987,13 @@ void apply_whisper_timestamp_rules(
 
     int last_ts_id = -1;
     for (auto it = generated_ids.rbegin(); it != generated_ids.rend(); ++it) {
-        if (token_is_timestamp(*it)) { last_ts_id = *it; break; }
+        if (token_is_timestamp(*it)) {
+            last_ts_id = *it;
+            break;
+        }
     }
     if (last_ts_id >= 0) {
-        const int ts_low = (last_ts && !penult_ts) ? last_ts_id : last_ts_id + 1;
+        const int ts_low   = (last_ts && !penult_ts) ? last_ts_id : last_ts_id + 1;
         const int clamp_hi = std::min(ts_low, static_cast<int>(vocab_size));
         for (int i = timestamp_begin; i < clamp_hi; ++i) {
             logits[static_cast<size_t>(i)] = -INFINITY;
@@ -1112,9 +1021,13 @@ void apply_whisper_timestamp_rules(
         double sum = 0.0;
         for (int i = timestamp_begin; i < static_cast<int>(vocab_size); ++i) {
             const float v = logits[static_cast<size_t>(i)];
-            if (std::isfinite(v)) sum += std::exp(static_cast<double>(v - max_ts));
+            if (std::isfinite(v)) {
+                sum += std::exp(static_cast<double>(v - max_ts));
+            }
+        }
+        if (sum > 0.0) {
+            ts_logsumexp = max_ts + static_cast<float>(std::log(sum));
         }
-        if (sum > 0.0) ts_logsumexp = max_ts + static_cast<float>(std::log(sum));
     }
     float max_text = -INFINITY;
     for (int i = 0; i < timestamp_begin; ++i) {
@@ -1140,15 +1053,13 @@ struct WhisperSegmentResult {
 // batched decode. Pure: reads generated_ids + the tokenizer, returns the
 // segments/slices/offset instead of mutating session state. (Short-form
 // callers pass time_offset_ms 0 and consume only `.segments`.)
-WhisperSegmentResult whisper_retrieve_segment(
-    const std::vector<int32_t> &  generated_ids,
-    const transcribe::Tokenizer & tok,
-    int64_t                       time_offset_ms,
-    int                           seek_num_frames,
-    bool                          want_segment_timestamps,
-    int                           timestamp_begin,
-    int64_t                       vocab_size)
-{
+WhisperSegmentResult whisper_retrieve_segment(const std::vector<int32_t> &  generated_ids,
+                                              const transcribe::Tokenizer & tok,
+                                              int64_t                       time_offset_ms,
+                                              int                           seek_num_frames,
+                                              bool                          want_segment_timestamps,
+                                              int                           timestamp_begin,
+                                              int64_t                       vocab_size) {
     WhisperSegmentResult out;
     out.segment_offset_frames = seek_num_frames;
 
@@ -1157,121 +1068,131 @@ WhisperSegmentResult whisper_retrieve_segment(
     };
     auto trim_ascii = [](std::string s) {
         size_t start = 0;
-        while (start < s.size() &&
-               (s[start] == ' ' || s[start] == '\t' ||
-                s[start] == '\n' || s[start] == '\r')) ++start;
+        while (start < s.size() && (s[start] == ' ' || s[start] == '\t' || s[start] == '\n' || s[start] == '\r')) {
+            ++start;
+        }
         size_t end = s.size();
-        while (end > start &&
-               (s[end - 1] == ' ' || s[end - 1] == '\t' ||
-                s[end - 1] == '\n' || s[end - 1] == '\r')) --end;
+        while (end > start && (s[end - 1] == ' ' || s[end - 1] == '\t' || s[end - 1] == '\n' || s[end - 1] == '\r')) {
+            --end;
+        }
         return s.substr(start, end - start);
     };
     auto decode_range = [&](int begin, int end) -> std::string {
-        if (begin >= end) return std::string();
+        if (begin >= end) {
+            return std::string();
+        }
         std::vector<int> ids_int;
         ids_int.reserve(static_cast<size_t>(end - begin));
         for (int i = begin; i < end; ++i) {
             const int32_t id = generated_ids[i];
-            if (id >= 0 && id < 50257 && !token_is_timestamp(id))
+            if (id >= 0 && id < 50257 && !token_is_timestamp(id)) {
                 ids_int.push_back(id);
+            }
         }
-        if (ids_int.empty()) return std::string();
-        return trim_ascii(tok.decode(ids_int.data(),
-                                     static_cast<int>(ids_int.size())));
+        if (ids_int.empty()) {
+            return std::string();
+        }
+        return trim_ascii(tok.decode(ids_int.data(), static_cast<int>(ids_int.size())));
     };
 
     const int gn = static_cast<int>(generated_ids.size());
 
     std::vector<int> slices;
     for (int i = 0; i + 1 < gn; ++i) {
-        if (token_is_timestamp(generated_ids[i]) &&
-            token_is_timestamp(generated_ids[i + 1]))
-        {
+        if (token_is_timestamp(generated_ids[i]) && token_is_timestamp(generated_ids[i + 1])) {
             slices.push_back(i + 1);
         }
     }
     const bool single_timestamp_ending =
-        gn >= 2 &&
-        !token_is_timestamp(generated_ids[gn - 2]) &&
-         token_is_timestamp(generated_ids[gn - 1]);
+        gn >= 2 && !token_is_timestamp(generated_ids[gn - 2]) && token_is_timestamp(generated_ids[gn - 1]);
 
     if (!slices.empty()) {
-        if (single_timestamp_ending) slices.push_back(gn);
-        else                         slices.back() += 1;
+        if (single_timestamp_ending) {
+            slices.push_back(gn);
+        } else {
+            slices.back() += 1;
+        }
 
         int last_slice = 0;
         for (size_t k = 0; k < slices.size(); ++k) {
-            const int current_slice = slices[k];
-            const bool is_last = (k + 1 == slices.size());
-            if (current_slice <= last_slice) { last_slice = current_slice; continue; }
+            const int  current_slice = slices[k];
+            const bool is_last       = (k + 1 == slices.size());
+            if (current_slice <= last_slice) {
+                last_slice = current_slice;
+                continue;
+            }
             const int32_t first_tok = generated_ids[last_slice];
-            if (!token_is_timestamp(first_tok)) { last_slice = current_slice; continue; }
-            const int end_token_idx =
-                (!is_last || single_timestamp_ending) ? current_slice - 1
-                                                      : current_slice - 2;
+            if (!token_is_timestamp(first_tok)) {
+                last_slice = current_slice;
+                continue;
+            }
+            const int end_token_idx = (!is_last || single_timestamp_ending) ? current_slice - 1 : current_slice - 2;
             if (end_token_idx < last_slice || end_token_idx >= gn) {
-                last_slice = current_slice; continue;
+                last_slice = current_slice;
+                continue;
             }
             const int32_t last_tok = generated_ids[end_token_idx];
-            if (!token_is_timestamp(last_tok)) { last_slice = current_slice; continue; }
+            if (!token_is_timestamp(last_tok)) {
+                last_slice = current_slice;
+                continue;
+            }
             const int64_t start_ts_pos = static_cast<int64_t>(first_tok - timestamp_begin);
             const int64_t end_ts_pos   = static_cast<int64_t>(last_tok - timestamp_begin);
 
             if (want_segment_timestamps) {
-                transcribe_session::SegmentEntry seg {};
+                transcribe_session::SegmentEntry seg{};
                 seg.t0_ms = time_offset_ms + start_ts_pos * 20;
-                seg.t1_ms = time_offset_ms + end_ts_pos   * 20;
-                if (seg.t1_ms < seg.t0_ms) seg.t1_ms = seg.t0_ms;
-                seg.text  = decode_range(last_slice, current_slice);
-                if (!seg.text.empty()) out.segments.push_back(std::move(seg));
-            }
-            out.prev_chunk_segments.emplace_back(
-                generated_ids.begin() + last_slice,
-                generated_ids.begin() + current_slice);
+                seg.t1_ms = time_offset_ms + end_ts_pos * 20;
+                if (seg.t1_ms < seg.t0_ms) {
+                    seg.t1_ms = seg.t0_ms;
+                }
+                seg.text = decode_range(last_slice, current_slice);
+                if (!seg.text.empty()) {
+                    out.segments.push_back(std::move(seg));
+                }
+            }
+            out.prev_chunk_segments.emplace_back(generated_ids.begin() + last_slice,
+                                                 generated_ids.begin() + current_slice);
             last_slice = current_slice;
         }
 
         if (single_timestamp_ending) {
             out.segment_offset_frames = seek_num_frames;
-        } else if (last_slice >= 2 && last_slice - 2 < gn &&
-                   token_is_timestamp(generated_ids[last_slice - 2]))
-        {
-            const int last_ts_pos = generated_ids[last_slice - 2] - timestamp_begin;
+        } else if (last_slice >= 2 && last_slice - 2 < gn && token_is_timestamp(generated_ids[last_slice - 2])) {
+            const int last_ts_pos     = generated_ids[last_slice - 2] - timestamp_begin;
             out.segment_offset_frames = last_ts_pos * 2;  // input_stride = 2
         }
     } else {
         int64_t last_ts_pos = static_cast<int64_t>(seek_num_frames) / 2;
         for (int i = gn - 1; i >= 0; --i) {
-            if (token_is_timestamp(generated_ids[i]) &&
-                generated_ids[i] != timestamp_begin)
-            {
+            if (token_is_timestamp(generated_ids[i]) && generated_ids[i] != timestamp_begin) {
                 last_ts_pos = static_cast<int64_t>(generated_ids[i] - timestamp_begin);
                 break;
             }
         }
         if (want_segment_timestamps && gn > 0) {
-            transcribe_session::SegmentEntry seg {};
+            transcribe_session::SegmentEntry seg{};
             seg.t0_ms = time_offset_ms;
             seg.t1_ms = time_offset_ms + last_ts_pos * 20;
             seg.text  = decode_range(0, gn);
-            if (!seg.text.empty()) out.segments.push_back(std::move(seg));
+            if (!seg.text.empty()) {
+                out.segments.push_back(std::move(seg));
+            }
+        }
+        if (gn > 0) {
+            out.prev_chunk_segments.emplace_back(generated_ids.begin(), generated_ids.end());
         }
-        if (gn > 0)
-            out.prev_chunk_segments.emplace_back(generated_ids.begin(),
-                                                 generated_ids.end());
         out.segment_offset_frames = seek_num_frames;
     }
     return out;
 }
 
-} // namespace
+}  // namespace
 
-transcribe_status whisper_run(
-    transcribe_session *      session,
-    const float *             pcm,
-    int                       n_samples,
-    const transcribe_run_params * params)
-{
+transcribe_status whisper_run(transcribe_session *          session,
+                              const float *                 pcm,
+                              int                           n_samples,
+                              const transcribe_run_params * params) {
     if (session == nullptr || pcm == nullptr || n_samples <= 0) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
@@ -1303,81 +1224,69 @@ transcribe_status whisper_run(
     //      - Long-form (> fe_n_samples): compute mel on raw audio (HF does the
     //        same — only short-form pads to 30s). The seek loop slices
     //        3000-frame windows and zero-pads the trailing short window.
-    const int n_mels                 = cm->hparams.enc_num_mel_bins;
-    const int n_mel_frames_per_chunk = cm->hparams.fe_nb_max_frames > 0
-                                           ? cm->hparams.fe_nb_max_frames : 3000;
-    const int n_samples_per_chunk    = cm->hparams.fe_n_samples > 0
-                                           ? cm->hparams.fe_n_samples : 480000;
+    const int  n_mels                 = cm->hparams.enc_num_mel_bins;
+    const int  n_mel_frames_per_chunk = cm->hparams.fe_nb_max_frames > 0 ? cm->hparams.fe_nb_max_frames : 3000;
+    const int  n_samples_per_chunk    = cm->hparams.fe_n_samples > 0 ? cm->hparams.fe_n_samples : 480000;
     // Short-form = fits a single 30s window; bypasses the dynamic-stride
     // machinery. HF's generate() takes a different code path for is_shortform,
     // so this is a numeric + behavioral parity gate (not just an optimization).
-    const bool is_short_form = (n_samples <= n_samples_per_chunk);
+    const bool is_short_form          = (n_samples <= n_samples_per_chunk);
 
-    const int64_t t_mel_start = ggml_time_us();
-    int total_mel_frames = 0;
-    bool mel_from_ref = false;
+    const int64_t t_mel_start      = ggml_time_us();
+    int           total_mel_frames = 0;
+    bool          mel_from_ref     = false;
 #ifdef TRANSCRIBE_ENABLE_VALIDATION_HOOKS
     if (const char * ref_dir = transcribe::env::str("TRANSCRIBE_MEL_FROM_REF")) {
-        if (const transcribe_status st = load_mel_from_ref(
-                ref_dir, n_mels, n_mel_frames_per_chunk, cc->mel_buf);
-            st != TRANSCRIBE_OK)
-        {
+        if (const transcribe_status st = load_mel_from_ref(ref_dir, n_mels, n_mel_frames_per_chunk, cc->mel_buf);
+            st != TRANSCRIBE_OK) {
             return st;
         }
         total_mel_frames = n_mel_frames_per_chunk;
-        mel_from_ref = true;
+        mel_from_ref     = true;
     }
 #endif
     if (!mel_from_ref) {
         if (!cm->mel.has_value()) {
             log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "whisper run: model has no MelFrontend "
-                         "(load skipped?)");
+                    "whisper run: model has no MelFrontend "
+                    "(load skipped?)");
             return TRANSCRIBE_ERR_GGUF;
         }
 
         std::vector<float> pcm_work;
-        const float * pcm_in   = pcm;
-        size_t        pcm_in_n = static_cast<size_t>(n_samples);
+        const float *      pcm_in   = pcm;
+        size_t             pcm_in_n = static_cast<size_t>(n_samples);
         if (is_short_form) {
             pcm_work.assign(static_cast<size_t>(n_samples_per_chunk), 0.0f);
             const int n_copy = std::min(n_samples, n_samples_per_chunk);
-            std::memcpy(pcm_work.data(), pcm,
-                        static_cast<size_t>(n_copy) * sizeof(float));
+            std::memcpy(pcm_work.data(), pcm, static_cast<size_t>(n_copy) * sizeof(float));
             pcm_in   = pcm_work.data();
             pcm_in_n = pcm_work.size();
         }
 
-        int mel_n_mels = 0, mel_n_frames = 0;
+        int                mel_n_mels = 0, mel_n_frames = 0;
         std::vector<float> mel_mn;  // [n_mels, n_frames] (MelFrontend layout)
-        if (const transcribe_status mst = cm->mel->compute(
-                pcm_in, pcm_in_n, mel_mn, mel_n_mels, mel_n_frames);
-            mst != TRANSCRIBE_OK)
-        {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "whisper run: MelFrontend::compute failed (%d)",
-                         static_cast<int>(mst));
+        if (const transcribe_status mst = cm->mel->compute(pcm_in, pcm_in_n, mel_mn, mel_n_mels, mel_n_frames);
+            mst != TRANSCRIBE_OK) {
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "whisper run: MelFrontend::compute failed (%d)", static_cast<int>(mst));
             return mst;
         }
         if (mel_n_mels != n_mels) {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "whisper run: mel n_mels %d != expected %d",
-                         mel_n_mels, n_mels);
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "whisper run: mel n_mels %d != expected %d", mel_n_mels, n_mels);
             return TRANSCRIBE_ERR_GGUF;
         }
         if (is_short_form && mel_n_frames != n_mel_frames_per_chunk) {
             log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "whisper run: short-form mel has %d frames, "
-                         "expected %d",
-                         mel_n_frames, n_mel_frames_per_chunk);
+                    "whisper run: short-form mel has %d frames, "
+                    "expected %d",
+                    mel_n_frames, n_mel_frames_per_chunk);
             return TRANSCRIBE_ERR_GGUF;
         }
 
         // Transpose [n_mels, n_frames] → [n_frames, n_mels] so that the
         // slice for chunk k is a contiguous row span
         //   mel_buf[k*3000*n_mels : (k+1)*3000*n_mels).
-        cc->mel_buf.resize(static_cast<size_t>(mel_n_mels) *
-                           static_cast<size_t>(mel_n_frames));
+        cc->mel_buf.resize(static_cast<size_t>(mel_n_mels) * static_cast<size_t>(mel_n_frames));
         for (int t = 0; t < mel_n_frames; ++t) {
             for (int m = 0; m < mel_n_mels; ++m) {
                 cc->mel_buf[static_cast<size_t>(t) * mel_n_mels + m] =
@@ -1393,10 +1302,10 @@ transcribe_status whisper_run(
     }
 
     // ----- Run-scoped constants -----
-    const int64_t n_ctx_decoder = cm->hparams.dec_max_target_positions;
-    const int64_t vocab_size    = cm->hparams.dec_vocab_size;
-    const int     eos_id        = cm->tok.eos_id() >= 0 ? cm->tok.eos_id() : 50257;
-    const int     timestamp_begin = cm->hparams.no_timestamps_token_id + 1;
+    const int64_t n_ctx_decoder    = cm->hparams.dec_max_target_positions;
+    const int64_t vocab_size       = cm->hparams.dec_vocab_size;
+    const int     eos_id           = cm->tok.eos_id() >= 0 ? cm->tok.eos_id() : 50257;
+    const int     timestamp_begin  = cm->hparams.no_timestamps_token_id + 1;
     constexpr int k_max_new_tokens = 256;
 
     const transcribe_timestamp_kind requested_timestamps =
@@ -1405,8 +1314,7 @@ transcribe_status whisper_run(
         return TRANSCRIBE_ERR_UNSUPPORTED_TIMESTAMPS;
     }
     const bool want_segment_timestamps =
-        requested_timestamps == TRANSCRIBE_TIMESTAMPS_AUTO ||
-        requested_timestamps == TRANSCRIBE_TIMESTAMPS_SEGMENT;
+        requested_timestamps == TRANSCRIBE_TIMESTAMPS_AUTO || requested_timestamps == TRANSCRIBE_TIMESTAMPS_SEGMENT;
 
     // Multilingual variants emit <|lang|> + <|task|> in the decoder prefix;
     // .en variants have just <|sot|> and no translate/transcribe/language
@@ -1415,16 +1323,15 @@ transcribe_status whisper_run(
 
     int32_t task_token = -1;
     if (is_multilingual) {
-        task_token = (params != nullptr && params->task == TRANSCRIBE_TASK_TRANSLATE)
-                         ? cm->hparams.translate_token_id
-                         : cm->hparams.transcribe_token_id;
+        task_token = (params != nullptr && params->task == TRANSCRIBE_TASK_TRANSLATE) ? cm->hparams.translate_token_id :
+                                                                                        cm->hparams.transcribe_token_id;
         if (task_token < 0) {
             return TRANSCRIBE_ERR_GGUF;
         }
     } else if (params != nullptr && params->task == TRANSCRIBE_TASK_TRANSLATE) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "whisper run: this model does not support translate "
-                     "(non-multilingual variant)");
+                "whisper run: this model does not support translate "
+                "(non-multilingual variant)");
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
 
@@ -1434,16 +1341,14 @@ transcribe_status whisper_run(
     // "en" and there is no language token to resolve — the prefix omits
     // the <|lang|> slot entirely.
     int32_t lang_token = -1;
-    if (params != nullptr && params->language != nullptr &&
-        params->language[0] != '\0')
-    {
+    if (params != nullptr && params->language != nullptr && params->language[0] != '\0') {
         const std::string lang_code = params->language;
         if (!is_multilingual) {
             if (lang_code != "en") {
                 log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                             "whisper run: language '%s' is not supported by "
-                             "this non-multilingual model (only 'en')",
-                             lang_code.c_str());
+                        "whisper run: language '%s' is not supported by "
+                        "this non-multilingual model (only 'en')",
+                        lang_code.c_str());
                 return TRANSCRIBE_ERR_INVALID_ARG;
             }
             // Accepted; lang_token stays -1 by design.
@@ -1456,9 +1361,9 @@ transcribe_status whisper_run(
             }
             if (lang_token < 0) {
                 log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                             "whisper run: language '%s' not in model's language "
-                             "table — cannot build decoder prompt",
-                             lang_code.c_str());
+                        "whisper run: language '%s' not in model's language "
+                        "table — cannot build decoder prompt",
+                        lang_code.c_str());
                 return TRANSCRIBE_ERR_INVALID_ARG;
             }
         }
@@ -1485,8 +1390,8 @@ transcribe_status whisper_run(
     all_text_ids.reserve(256);
 
     std::vector<float> last_logits(static_cast<size_t>(vocab_size));
-    int64_t t_decode_start = 0;
-    bool    t_decode_started = false;
+    int64_t            t_decode_start   = 0;
+    bool               t_decode_started = false;
 
     // Finalize the context's result state. Called at normal completion and at
     // every mid-run abort exit (the public contract requires partial
@@ -1494,42 +1399,32 @@ transcribe_status whisper_run(
     // normal accessors). Decodes all_text_ids to UTF-8, strips whitespace,
     // pushes the text-only segment for TIMESTAMPS_NONE mode, flips has_result.
     auto commit_result = [&]() {
-        cc->t_decode_us = t_decode_started
-                              ? ggml_time_us() - t_decode_start
-                              : 0;
+        cc->t_decode_us = t_decode_started ? ggml_time_us() - t_decode_start : 0;
 
         std::string text;
         if (!all_text_ids.empty()) {
-            std::vector<int> ids_int(all_text_ids.begin(),
-                                     all_text_ids.end());
-            text = cm->tok.decode(ids_int.data(),
-                                  static_cast<int>(ids_int.size()));
+            std::vector<int> ids_int(all_text_ids.begin(), all_text_ids.end());
+            text         = cm->tok.decode(ids_int.data(), static_cast<int>(ids_int.size()));
             size_t start = 0;
             while (start < text.size() &&
-                   (text[start] == ' ' || text[start] == '\t' ||
-                    text[start] == '\n' || text[start] == '\r'))
-            {
+                   (text[start] == ' ' || text[start] == '\t' || text[start] == '\n' || text[start] == '\r')) {
                 ++start;
             }
             size_t end = text.size();
             while (end > start &&
-                   (text[end - 1] == ' ' || text[end - 1] == '\t' ||
-                    text[end - 1] == '\n' || text[end - 1] == '\r'))
-            {
+                   (text[end - 1] == ' ' || text[end - 1] == '\t' || text[end - 1] == '\n' || text[end - 1] == '\r')) {
                 --end;
             }
             text = text.substr(start, end - start);
         }
 
         if (!want_segment_timestamps) {
-            transcribe_session::SegmentEntry seg {};
+            transcribe_session::SegmentEntry seg{};
             seg.text = text;
             cc->segments.push_back(std::move(seg));
         }
         cc->full_text   = std::move(text);
-        cc->result_kind = want_segment_timestamps
-                              ? TRANSCRIBE_TIMESTAMPS_SEGMENT
-                              : TRANSCRIBE_TIMESTAMPS_NONE;
+        cc->result_kind = want_segment_timestamps ? TRANSCRIBE_TIMESTAMPS_SEGMENT : TRANSCRIBE_TIMESTAMPS_NONE;
         cc->has_result  = true;
 
         if (whisper_perf_enabled()) {
@@ -1551,30 +1446,26 @@ transcribe_status whisper_run(
     // through the whole seek loop, so reseeding per chunk would replay the
     // same prefix each window and destroy long-form determinism. seed == 0
     // draws OS entropy once, then the rng advances across chunks and tiers.
-    if (const transcribe_status st = transcribe_ext_check(
-            params != nullptr ? params->family : nullptr,
-            TRANSCRIBE_EXT_KIND_WHISPER_RUN,
-            sizeof(struct transcribe_whisper_run_ext));
-        st != TRANSCRIBE_OK)
-    {
+    if (const transcribe_status st =
+            transcribe_ext_check(params != nullptr ? params->family : nullptr, TRANSCRIBE_EXT_KIND_WHISPER_RUN,
+                                 sizeof(struct transcribe_whisper_run_ext));
+        st != TRANSCRIBE_OK) {
         return st;
     }
-    transcribe_whisper_run_ext default_wp; transcribe_whisper_run_ext_init(&default_wp);
-    const transcribe_whisper_run_ext * wp =
-        (params != nullptr && params->family != nullptr)
-            ? reinterpret_cast<const transcribe_whisper_run_ext *>(params->family)
-            : &default_wp;
-    std::mt19937 rng(wp->seed != 0 ? wp->seed : std::random_device{}());
+    transcribe_whisper_run_ext default_wp;
+    transcribe_whisper_run_ext_init(&default_wp);
+    const transcribe_whisper_run_ext * wp = (params != nullptr && params->family != nullptr) ?
+                                                reinterpret_cast<const transcribe_whisper_run_ext *>(params->family) :
+                                                &default_wp;
+    std::mt19937                       rng(wp->seed != 0 ? wp->seed : std::random_device{}());
 
     // Prompt + condition_on_prev_tokens setup. HF raises ValueError when
     // prompt_condition_type=="all-segments" without condition_on_prev_tokens;
     // mirror as INVALID_ARG before any compute runs.
-    if (wp->prompt_condition == TRANSCRIBE_WHISPER_PROMPT_ALL_SEGMENTS &&
-        !wp->condition_on_prev_tokens)
-    {
+    if (wp->prompt_condition == TRANSCRIBE_WHISPER_PROMPT_ALL_SEGMENTS && !wp->condition_on_prev_tokens) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "whisper run: prompt_condition=ALL_SEGMENTS requires "
-                     "condition_on_prev_tokens=true (HF parity)");
+                "whisper run: prompt_condition=ALL_SEGMENTS requires "
+                "condition_on_prev_tokens=true (HF parity)");
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
 
@@ -1585,15 +1476,12 @@ transcribe_status whisper_run(
     if (prev_sot_id < 0) {
         prev_sot_id = cm->tok.find("<|startofprev|>");
     }
-    const bool prompt_requested =
-        (wp->prompt_tokens != nullptr && wp->n_prompt_tokens > 0) ||
-        (wp->initial_prompt != nullptr && wp->initial_prompt[0] != '\0');
-    if (prev_sot_id < 0 &&
-        (prompt_requested || wp->condition_on_prev_tokens))
-    {
+    const bool prompt_requested = (wp->prompt_tokens != nullptr && wp->n_prompt_tokens > 0) ||
+                                  (wp->initial_prompt != nullptr && wp->initial_prompt[0] != '\0');
+    if (prev_sot_id < 0 && (prompt_requested || wp->condition_on_prev_tokens)) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "whisper run: model has no <|startofprev|> token; "
-                     "initial_prompt / condition_on_prev_tokens unavailable");
+                "whisper run: model has no <|startofprev|> token; "
+                "initial_prompt / condition_on_prev_tokens unavailable");
         return TRANSCRIBE_ERR_GGUF;
     }
 
@@ -1602,33 +1490,33 @@ transcribe_status whisper_run(
     // text-side only); or initial_prompt string, tokenized as HF's
     // get_prompt_ids form ("<|startofprev|> " + strip) with any special token
     // (id >= eos_id) in the text rejected (tokenization_whisper.py).
-    const int max_prev_cap = wp->max_prev_context_tokens > 0
-                                 ? wp->max_prev_context_tokens
-                                 : (cm->hparams.dec_max_target_positions / 2 - 1);
+    const int max_prev_cap =
+        wp->max_prev_context_tokens > 0 ? wp->max_prev_context_tokens : (cm->hparams.dec_max_target_positions / 2 - 1);
     std::vector<int32_t> prompt_text_ids;
     if (wp->prompt_tokens != nullptr && wp->n_prompt_tokens > 0) {
         // The library prepends <|startofprev|>; a leading prev_sot id from the
         // caller would double-prepend, so reject it as INVALID_ARG.
         if (prev_sot_id >= 0 && wp->prompt_tokens[0] == prev_sot_id) {
             log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "whisper run: prompt_tokens must not include "
-                         "<|startofprev|> (id %d) at index 0; the library "
-                         "prepends it. See transcribe_whisper_run_ext docs.",
-                         prev_sot_id);
+                    "whisper run: prompt_tokens must not include "
+                    "<|startofprev|> (id %d) at index 0; the library "
+                    "prepends it. See transcribe_whisper_run_ext docs.",
+                    prev_sot_id);
             return TRANSCRIBE_ERR_INVALID_ARG;
         }
-        prompt_text_ids.assign(wp->prompt_tokens,
-                               wp->prompt_tokens + wp->n_prompt_tokens);
-    } else if (wp->initial_prompt != nullptr &&
-               wp->initial_prompt[0] != '\0')
-    {
+        prompt_text_ids.assign(wp->prompt_tokens, wp->prompt_tokens + wp->n_prompt_tokens);
+    } else if (wp->initial_prompt != nullptr && wp->initial_prompt[0] != '\0') {
         std::string s(wp->initial_prompt);
-        auto issp = [](char c) {
+        auto        issp = [](char c) {
             return c == ' ' || c == '\t' || c == '\n' || c == '\r';
         };
         size_t a = 0, b = s.size();
-        while (a < b && issp(s[a])) ++a;
-        while (b > a && issp(s[b - 1])) --b;
+        while (a < b && issp(s[a])) {
+            ++a;
+        }
+        while (b > a && issp(s[b - 1])) {
+            --b;
+        }
         if (b > a) {
             std::string text(" ");
             text.append(s.data() + a, b - a);
@@ -1643,18 +1531,18 @@ transcribe_status whisper_run(
             // byte-by-byte and slip through. Mirror HF's intent by
             // checking each "<|...|>" substring against the vocab
             // directly.
-            for (size_t i = 0; i + 1 < text.size(); ) {
+            for (size_t i = 0; i + 1 < text.size();) {
                 if (text[i] == '<' && text[i + 1] == '|') {
                     const size_t end = text.find("|>", i + 2);
                     if (end != std::string::npos) {
                         const size_t close = end + 2;
-                        std::string piece = text.substr(i, close - i);
-                        const int id = cm->tok.find(piece);
+                        std::string  piece = text.substr(i, close - i);
+                        const int    id    = cm->tok.find(piece);
                         if (id >= eos_id) {
                             log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                                         "whisper run: initial_prompt contains "
-                                         "disallowed special token \"%s\" (id %d)",
-                                         piece.c_str(), id);
+                                    "whisper run: initial_prompt contains "
+                                    "disallowed special token \"%s\" (id %d)",
+                                    piece.c_str(), id);
                             return TRANSCRIBE_ERR_INVALID_ARG;
                         }
                         i = close;
@@ -1666,15 +1554,16 @@ transcribe_status whisper_run(
 
             if (cm->tok.encode(text, prompt_text_ids) != TRANSCRIBE_OK) {
                 log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                             "whisper run: tokenizer.encode failed on "
-                             "initial_prompt");
+                        "whisper run: tokenizer.encode failed on "
+                        "initial_prompt");
                 return TRANSCRIBE_ERR_GGUF;
             }
             for (int32_t id : prompt_text_ids) {
                 if (id >= eos_id) {
                     log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                                 "whisper run: initial_prompt contains "
-                                 "disallowed special token id %d", id);
+                            "whisper run: initial_prompt contains "
+                            "disallowed special token id %d",
+                            id);
                     return TRANSCRIBE_ERR_INVALID_ARG;
                 }
             }
@@ -1682,17 +1571,14 @@ transcribe_status whisper_run(
     }
     // Cap prompt tokens to max_prev_cap (left-truncate, keep most-recent).
     if (static_cast<int>(prompt_text_ids.size()) > max_prev_cap) {
-        prompt_text_ids.erase(prompt_text_ids.begin(),
-                              prompt_text_ids.end() - max_prev_cap);
+        prompt_text_ids.erase(prompt_text_ids.begin(), prompt_text_ids.end() - max_prev_cap);
     }
 
     // History stored as segment token slices (not one flat vector) because
     // skip_ending_double_timestamps applies per-segment. FIRST_SEGMENT puts the
     // prompt at the head; ALL_SEGMENTS starts empty and re-prepends per chunk.
     std::vector<std::vector<int32_t>> prev_history_segments;
-    if (wp->prompt_condition == TRANSCRIBE_WHISPER_PROMPT_FIRST_SEGMENT &&
-        !prompt_text_ids.empty())
-    {
+    if (wp->prompt_condition == TRANSCRIBE_WHISPER_PROMPT_FIRST_SEGMENT && !prompt_text_ids.empty()) {
         prev_history_segments.push_back(prompt_text_ids);
     }
 
@@ -1708,63 +1594,49 @@ transcribe_status whisper_run(
         }
         cc->perf.chunks += 1;
 
-        const bool is_first_chunk = (seek == 0);
+        const bool    is_first_chunk = (seek == 0);
         const int64_t time_offset_ms = static_cast<int64_t>(seek) * 10;
 
         // Slice + zero-pad the mel window to n_mel_frames_per_chunk (pad after
         // the real frames, matching HF's F.pad). seek_num_frames is the real
         // (unpadded) frame count and the max `seek` can advance per iteration.
-        std::vector<float> chunk_mel(
-            static_cast<size_t>(n_mels) *
-                static_cast<size_t>(n_mel_frames_per_chunk),
-            0.0f);
-        const int seek_num_frames =
-            std::min(total_mel_frames - seek, n_mel_frames_per_chunk);
-        const int frames_avail = seek_num_frames;
-        std::memcpy(chunk_mel.data(),
-                    &cc->mel_buf[static_cast<size_t>(seek) *
-                                 static_cast<size_t>(n_mels)],
-                    static_cast<size_t>(frames_avail) *
-                    static_cast<size_t>(n_mels) * sizeof(float));
+        std::vector<float> chunk_mel(static_cast<size_t>(n_mels) * static_cast<size_t>(n_mel_frames_per_chunk), 0.0f);
+        const int          seek_num_frames = std::min(total_mel_frames - seek, n_mel_frames_per_chunk);
+        const int          frames_avail    = seek_num_frames;
+        std::memcpy(chunk_mel.data(), &cc->mel_buf[static_cast<size_t>(seek) * static_cast<size_t>(n_mels)],
+                    static_cast<size_t>(frames_avail) * static_cast<size_t>(n_mels) * sizeof(float));
 
         // Encoder (per chunk). enc_host is rewritten per call.
-        int T_enc_local = 0;
+        int           T_enc_local = 0;
         const int64_t t_enc_start = ggml_time_us();
-        if (const transcribe_status st = run_whisper_encoder_on_window(
-                cc, cm, chunk_mel.data(), n_mels, n_mel_frames_per_chunk,
-                /*allow_dumps=*/is_first_chunk, T_enc_local);
-            st != TRANSCRIBE_OK)
-        {
+        if (const transcribe_status st =
+                run_whisper_encoder_on_window(cc, cm, chunk_mel.data(), n_mels, n_mel_frames_per_chunk,
+                                              /*allow_dumps=*/is_first_chunk, T_enc_local);
+            st != TRANSCRIBE_OK) {
             return st;
         }
         if (is_first_chunk) {
-            cc->t_encode_us = ggml_time_us() - t_enc_start;
-            t_decode_start  = ggml_time_us();
+            cc->t_encode_us  = ggml_time_us() - t_enc_start;
+            t_decode_start   = ggml_time_us();
             t_decode_started = true;
         }
 
         // Language detection: once, first chunk, only if no hint and the model
         // has language tokens (.en has none, so it's skipped automatically).
-        if (is_first_chunk && is_multilingual &&
-            lang_token < 0 && !cm->lang_token_ids.empty())
-        {
+        if (is_first_chunk && is_multilingual && lang_token < 0 && !cm->lang_token_ids.empty()) {
             // Lazily materialize encoder output to host for the prefill
             // graph's encoder_out_in input (one-shot per run; the hot path
             // reads cc->enc_out.tensor directly).
             const int d_enc_lang = cc->enc_out.d_model;
             const int T_enc_lang = cc->enc_out.T_enc;
-            cc->enc_host.resize(static_cast<size_t>(d_enc_lang) *
-                                static_cast<size_t>(T_enc_lang));
-            ggml_backend_tensor_get(cc->enc_out.tensor,
-                                    cc->enc_host.data(), 0,
-                                    cc->enc_host.size() * sizeof(float));
+            cc->enc_host.resize(static_cast<size_t>(d_enc_lang) * static_cast<size_t>(T_enc_lang));
+            ggml_backend_tensor_get(cc->enc_out.tensor, cc->enc_host.data(), 0, cc->enc_host.size() * sizeof(float));
 
             if (!new_compute_ctx(16 * 1024 * 1024)) {
                 return TRANSCRIBE_ERR_GGUF;
             }
-            DecoderBuild det_db = build_decoder_prefill_graph(
-                cc->compute_ctx, cm->weights, cm->hparams,
-                /*seq_len=*/1, T_enc_local, cc->decoder_use_flash);
+            DecoderBuild det_db = build_decoder_prefill_graph(cc->compute_ctx, cm->weights, cm->hparams,
+                                                              /*seq_len=*/1, T_enc_local, cc->decoder_use_flash);
             if (det_db.out == nullptr || det_db.graph == nullptr) {
                 return TRANSCRIBE_ERR_GGUF;
             }
@@ -1773,33 +1645,26 @@ transcribe_status whisper_run(
                 return TRANSCRIBE_ERR_GGUF;
             }
             const int32_t sot = cm->hparams.decoder_start_token_id;
-            ggml_backend_tensor_set(det_db.token_ids_in, &sot,
-                                    0, sizeof(int32_t));
-            ggml_backend_tensor_set(det_db.encoder_out_in, cc->enc_host.data(),
-                                    0, cc->enc_host.size() * sizeof(float));
+            ggml_backend_tensor_set(det_db.token_ids_in, &sot, 0, sizeof(int32_t));
+            ggml_backend_tensor_set(det_db.encoder_out_in, cc->enc_host.data(), 0, cc->enc_host.size() * sizeof(float));
             if (det_db.causal_mask_in != nullptr) {
                 const float zero = 0.0f;
-                ggml_backend_tensor_set(det_db.causal_mask_in, &zero,
-                                        0, sizeof(float));
+                ggml_backend_tensor_set(det_db.causal_mask_in, &zero, 0, sizeof(float));
             }
-            if (ggml_backend_sched_graph_compute(cc->sched, det_db.graph) !=
-                GGML_STATUS_SUCCESS)
-            {
+            if (ggml_backend_sched_graph_compute(cc->sched, det_db.graph) != GGML_STATUS_SUCCESS) {
                 return TRANSCRIBE_ERR_GGUF;
             }
-            const size_t row_bytes =
-                static_cast<size_t>(vocab_size) * sizeof(float);
-            ggml_backend_tensor_get(det_db.dumps.logits_raw, last_logits.data(),
-                                    0, row_bytes);
+            const size_t row_bytes = static_cast<size_t>(vocab_size) * sizeof(float);
+            ggml_backend_tensor_get(det_db.dumps.logits_raw, last_logits.data(), 0, row_bytes);
 
-            float best = -INFINITY;
-            int best_index = -1;
+            float best       = -INFINITY;
+            int   best_index = -1;
             for (size_t i = 0; i < cm->lang_token_ids.size(); ++i) {
                 const int32_t id = cm->lang_token_ids[i];
                 if (id >= 0 && id < static_cast<int>(vocab_size)) {
                     const float v = last_logits[static_cast<size_t>(id)];
                     if (v > best) {
-                        best = v;
+                        best       = v;
                         lang_token = id;
                         best_index = static_cast<int>(i);
                     }
@@ -1807,16 +1672,14 @@ transcribe_status whisper_run(
             }
             // Publish the detected ISO code only here, not in the user-hint
             // branch: the field means "what the model picked", not the hint.
-            if (best_index >= 0 &&
-                static_cast<size_t>(best_index) < cm->lang_codes.size())
-            {
+            if (best_index >= 0 && static_cast<size_t>(best_index) < cm->lang_codes.size()) {
                 cc->detected_language = cm->lang_codes[static_cast<size_t>(best_index)];
             }
         }
         if (is_multilingual && lang_token < 0) {
             log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "whisper run: could not resolve a decoder language "
-                         "token");
+                    "whisper run: could not resolve a decoder language "
+                    "token");
             return TRANSCRIBE_ERR_GGUF;
         }
 
@@ -1831,16 +1694,10 @@ transcribe_status whisper_run(
         // We diverge from HF for FIRST_SEGMENT (the default): prime only the
         // first window, matching whisper.cpp / OpenAI.
         std::vector<int32_t> prev_tokens;
-        if (do_condition_on_prev_tokens && !prev_history_segments.empty() &&
-            prev_sot_id >= 0)
-        {
+        if (do_condition_on_prev_tokens && !prev_history_segments.empty() && prev_sot_id >= 0) {
             prev_tokens.push_back(prev_sot_id);
-            if (wp->prompt_condition == TRANSCRIBE_WHISPER_PROMPT_ALL_SEGMENTS &&
-                !prompt_text_ids.empty())
-            {
-                prev_tokens.insert(prev_tokens.end(),
-                                   prompt_text_ids.begin(),
-                                   prompt_text_ids.end());
+            if (wp->prompt_condition == TRANSCRIBE_WHISPER_PROMPT_ALL_SEGMENTS && !prompt_text_ids.empty()) {
+                prev_tokens.insert(prev_tokens.end(), prompt_text_ids.begin(), prompt_text_ids.end());
             }
             std::vector<int32_t> hist;
             for (const auto & seg : prev_history_segments) {
@@ -1852,18 +1709,13 @@ transcribe_status whisper_run(
                 }
                 hist.insert(hist.end(), seg.begin(), seg.begin() + n);
             }
-            const int cap = std::min<int>(static_cast<int>(hist.size()),
-                                          max_prev_cap);
-            prev_tokens.insert(prev_tokens.end(),
-                               hist.end() - cap, hist.end());
+            const int cap = std::min<int>(static_cast<int>(hist.size()), max_prev_cap);
+            prev_tokens.insert(prev_tokens.end(), hist.end() - cap, hist.end());
         } else if (!prompt_text_ids.empty() && prev_sot_id >= 0 &&
-                   (is_first_chunk ||
-                    wp->prompt_condition == TRANSCRIBE_WHISPER_PROMPT_ALL_SEGMENTS)) {
+                   (is_first_chunk || wp->prompt_condition == TRANSCRIBE_WHISPER_PROMPT_ALL_SEGMENTS)) {
             // FIRST_SEGMENT primes the initial prompt on the first window
             prev_tokens.push_back(prev_sot_id);
-            prev_tokens.insert(prev_tokens.end(),
-                               prompt_text_ids.begin(),
-                               prompt_text_ids.end());
+            prev_tokens.insert(prev_tokens.end(), prompt_text_ids.begin(), prompt_text_ids.end());
         }
 
         // Prefix for this chunk:
@@ -1873,8 +1725,7 @@ transcribe_status whisper_run(
         // on a garbage id.
         std::vector<int32_t> prompt_ids;
         prompt_ids.reserve(prev_tokens.size() + 4);
-        prompt_ids.insert(prompt_ids.end(),
-                          prev_tokens.begin(), prev_tokens.end());
+        prompt_ids.insert(prompt_ids.end(), prev_tokens.begin(), prev_tokens.end());
         prompt_ids.push_back(cm->hparams.decoder_start_token_id);
         if (is_multilingual) {
             prompt_ids.push_back(lang_token);
@@ -1894,9 +1745,9 @@ transcribe_status whisper_run(
         // window (only a pathological prompt_tokens > 444 trips this).
         if (seq_len + 1 > static_cast<int>(n_ctx_decoder)) {
             log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "whisper run: prefix length %d exceeds decoder "
-                         "context %lld",
-                         seq_len, static_cast<long long>(n_ctx_decoder));
+                    "whisper run: prefix length %d exceeds decoder "
+                    "context %lld",
+                    seq_len, static_cast<long long>(n_ctx_decoder));
             return TRANSCRIBE_ERR_INVALID_ARG;
         }
 
@@ -1918,11 +1769,9 @@ transcribe_status whisper_run(
         // token only. Default 1.0s / 20ms-per-token = index 50, so the opening
         // cut lands at most 1.0s in. Negative/non-finite disables the cap.
         const int max_initial_timestamp_index =
-            (std::isfinite(wp->max_initial_timestamp) &&
-             wp->max_initial_timestamp >= 0.0f)
-                ? static_cast<int>(std::floor(
-                      static_cast<double>(wp->max_initial_timestamp) / 0.02))
-                : -1;
+            (std::isfinite(wp->max_initial_timestamp) && wp->max_initial_timestamp >= 0.0f) ?
+                static_cast<int>(std::floor(static_cast<double>(wp->max_initial_timestamp) / 0.02)) :
+                -1;
 
         // Mirrors transformers' WhisperTimeStampLogitsProcessor
         // (generation/logits_process.py). Five rules, in order:
@@ -1938,10 +1787,9 @@ transcribe_status whisper_run(
         //      timestamp_begin + max_initial_timestamp_index (HF
         //      logits_process.py:2040-2042).
         auto apply_timestamp_rules = [&](std::vector<float> & logits) {
-            apply_whisper_timestamp_rules(
-                logits, generated_ids, want_segment_timestamps,
-                cm->hparams.no_timestamps_token_id, timestamp_begin,
-                vocab_size, eos_id, max_initial_timestamp_index);
+            apply_whisper_timestamp_rules(logits, generated_ids, want_segment_timestamps,
+                                          cm->hparams.no_timestamps_token_id, timestamp_begin, vocab_size, eos_id,
+                                          max_initial_timestamp_index);
         };
 
         int next_id = 0;
@@ -1953,10 +1801,7 @@ transcribe_status whisper_run(
         std::vector<float> temperatures;
         temperatures.push_back(wp->temperature);
         if (wp->temperature_inc > 0.0f) {
-            for (float T = wp->temperature + wp->temperature_inc;
-                 T <= 1.0f + 1e-4f;
-                 T += wp->temperature_inc)
-            {
+            for (float T = wp->temperature + wp->temperature_inc; T <= 1.0f + 1e-4f; T += wp->temperature_inc) {
                 temperatures.push_back(T);
             }
         }
@@ -1965,10 +1810,10 @@ transcribe_status whisper_run(
         // is returned when no tier passes thresholds).
         std::vector<int32_t> accepted_generated_ids;
         std::vector<int32_t> accepted_generated_text_ids;
-        float accepted_T             = 0.0f;
-        float accepted_compression   = 0.0f;
-        float accepted_avg_logprob   = 0.0f;
-        int   accepted_n_fallbacks   = 0;
+        float                accepted_T           = 0.0f;
+        float                accepted_compression = 0.0f;
+        float                accepted_avg_logprob = 0.0f;
+        int                  accepted_n_fallbacks = 0;
 
         // No-speech: probability captured from the SOT-position row of the
         // prompt-pass logits (tier 0 only), matching HF WhisperNoSpeechDetection
@@ -1976,11 +1821,10 @@ transcribe_status whisper_run(
         // id is positional: no_speech = notimestamps - 1 (multilingual 50362,
         // .en 50361). When the no-speech skip fires, the chunk's output is
         // discarded and seek advances a full window (no fallback attempted).
-        const int no_speech_token_id =
-            cm->hparams.no_timestamps_token_id - 1;
-        float no_speech_prob = 0.0f;
-        bool  no_speech_prob_captured  = false;
-        bool  no_speech_fired_this_chunk = false;
+        const int no_speech_token_id         = cm->hparams.no_timestamps_token_id - 1;
+        float     no_speech_prob             = 0.0f;
+        bool      no_speech_prob_captured    = false;
+        bool      no_speech_fired_this_chunk = false;
 
         // HF _retrieve_compression_ratio convention: the ratio is computed over
         // the full generated tail including timestamps, specials, and EOS when
@@ -1992,12 +1836,9 @@ transcribe_status whisper_run(
         // KV cache allocation is tier-independent — done once per chunk
         // out here, then self-attention state (n, head) is reset per
         // tier below.
-        const int n_layers = cm->hparams.dec_n_layers;
-        const bool need_init =
-            cc->kv_cache.ctx == nullptr ||
-            cc->kv_cache.n_batch != 1 ||
-            cc->kv_cache.n_ctx != n_ctx_decoder ||
-            cc->kv_cache.T_enc != T_enc_local;
+        const int  n_layers  = cm->hparams.dec_n_layers;
+        const bool need_init = cc->kv_cache.ctx == nullptr || cc->kv_cache.n_batch != 1 ||
+                               cc->kv_cache.n_ctx != n_ctx_decoder || cc->kv_cache.T_enc != T_enc_local;
         if (need_init) {
             cc->kv_cache.free();
             // AUTO: match cache dtype to the weight dtype (F32 GGUF -> F32
@@ -2009,16 +1850,11 @@ transcribe_status whisper_run(
                 kv_type_g = GGML_TYPE_F16;
             } else {
                 const ggml_tensor * probe =
-                    !cm->weights.dec_blocks.empty()
-                        ? cm->weights.dec_blocks[0].self_q_w
-                        : nullptr;
-                kv_type_g = (probe != nullptr && probe->type == GGML_TYPE_F32)
-                                ? GGML_TYPE_F32 : GGML_TYPE_F16;
-            }
-            if (!kv_cache_init(cc->kv_cache, cm->plan.primary,
-                               static_cast<int>(n_ctx_decoder), T_enc_local,
-                               cm->hparams.dec_d_model, n_layers, kv_type_g))
-            {
+                    !cm->weights.dec_blocks.empty() ? cm->weights.dec_blocks[0].self_q_w : nullptr;
+                kv_type_g = (probe != nullptr && probe->type == GGML_TYPE_F32) ? GGML_TYPE_F32 : GGML_TYPE_F16;
+            }
+            if (!kv_cache_init(cc->kv_cache, cm->plan.primary, static_cast<int>(n_ctx_decoder), T_enc_local,
+                               cm->hparams.dec_d_model, n_layers, kv_type_g)) {
                 log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "whisper run: KV cache init failed");
                 return TRANSCRIBE_ERR_BACKEND;
             }
@@ -2031,13 +1867,11 @@ transcribe_status whisper_run(
         {
             const int64_t t_cross_build_start = ggml_time_us();
             if (!new_compute_ctx(8 * 1024 * 1024)) {
-                log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                             "whisper run: ggml_init for cross_kv failed");
+                log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "whisper run: ggml_init for cross_kv failed");
                 return TRANSCRIBE_ERR_GGUF;
             }
-            DecoderBuild cross_db = build_cross_kv_graph(
-                cc->compute_ctx, cm->weights, cm->hparams,
-                cc->kv_cache, cc->enc_out.tensor, T_enc_local);
+            DecoderBuild cross_db = build_cross_kv_graph(cc->compute_ctx, cm->weights, cm->hparams, cc->kv_cache,
+                                                         cc->enc_out.tensor, T_enc_local);
             if (cross_db.graph == nullptr) {
                 return TRANSCRIBE_ERR_GGUF;
             }
@@ -2046,8 +1880,7 @@ transcribe_status whisper_run(
             const int64_t t_cross_alloc_start = ggml_time_us();
             ggml_backend_sched_reset(cc->sched);
             if (!ggml_backend_sched_alloc_graph(cc->sched, cross_db.graph)) {
-                log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                             "whisper run: alloc_graph failed (cross_kv)");
+                log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "whisper run: alloc_graph failed (cross_kv)");
                 return TRANSCRIBE_ERR_GGUF;
             }
             // No tensor_set: cross-KV reads cc->enc_out.tensor via
@@ -2056,13 +1889,9 @@ transcribe_status whisper_run(
             cc->perf.cross_alloc.add(ggml_time_us() - t_cross_alloc_start);
 
             const int64_t t_cross_compute_start = ggml_time_us();
-            if (const ggml_status gs = ggml_backend_sched_graph_compute(
-                    cc->sched, cross_db.graph);
-                gs != GGML_STATUS_SUCCESS)
-            {
-                log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                             "whisper run: cross_kv compute failed (%d)",
-                             static_cast<int>(gs));
+            if (const ggml_status gs = ggml_backend_sched_graph_compute(cc->sched, cross_db.graph);
+                gs != GGML_STATUS_SUCCESS) {
+                log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "whisper run: cross_kv compute failed (%d)", static_cast<int>(gs));
                 return TRANSCRIBE_ERR_GGUF;
             }
             cc->perf.cross_compute.add(ggml_time_us() - t_cross_compute_start);
@@ -2080,16 +1909,14 @@ transcribe_status whisper_run(
             cc->kv_cache.head = 0;
             generated_ids.clear();
             generated_text_ids.clear();
-            tier_hit_eos = false;
+            tier_hit_eos             = false;
             double sum_logprob       = 0.0;
             int    n_logprob_samples = 0;
 
             // Dump gate: references were captured at T=0, so only tier 0 of the
             // first chunk emits intermediates.
             const bool emit_tier_dumps = is_first_chunk && (ti == 0);
-            auto tier_try_dump = [&](const char * name, ggml_tensor * t,
-                                     const char * stage)
-            {
+            auto       tier_try_dump   = [&](const char * name, ggml_tensor * t, const char * stage) {
                 if (t != nullptr && emit_tier_dumps) {
                     transcribe::debug::dump_tensor(name, t, stage);
                 }
@@ -2098,92 +1925,77 @@ transcribe_status whisper_run(
             // ---- Prompt pass (emit dumps, n_past=0) -------------------
             {
                 const int64_t t_prompt_build_start = ggml_time_us();
-                if (!new_compute_ctx(16 * 1024 * 1024)) return TRANSCRIBE_ERR_GGUF;
-                const int kv_pad = kv_pad_self_attn(
-                    cm->plan.primary_kind, cc->decoder_use_flash);
-                DecoderBuild db = build_decoder_graph_kv(
-                    cc->compute_ctx, cm->weights, cm->hparams,
-                    cc->kv_cache,
-                    /*n_tokens=*/seq_len, /*n_past=*/0, T_enc_local,
-                    /*kv_pad=*/kv_pad,
-                    /*skip_log_softmax=*/false, cc->decoder_use_flash);
+                if (!new_compute_ctx(16 * 1024 * 1024)) {
+                    return TRANSCRIBE_ERR_GGUF;
+                }
+                const int    kv_pad = kv_pad_self_attn(cm->plan.primary_kind, cc->decoder_use_flash);
+                DecoderBuild db     = build_decoder_graph_kv(cc->compute_ctx, cm->weights, cm->hparams, cc->kv_cache,
+                                                             /*n_tokens=*/seq_len, /*n_past=*/0, T_enc_local,
+                                                             /*kv_pad=*/kv_pad,
+                                                             /*skip_log_softmax=*/false, cc->decoder_use_flash);
                 if (db.out == nullptr || db.graph == nullptr) {
                     return TRANSCRIBE_ERR_GGUF;
                 }
-                cc->perf.prompt_build.add(
-                    ggml_time_us() - t_prompt_build_start);
+                cc->perf.prompt_build.add(ggml_time_us() - t_prompt_build_start);
 
                 const int64_t t_prompt_alloc_start = ggml_time_us();
                 ggml_backend_sched_reset(cc->sched);
                 if (!ggml_backend_sched_alloc_graph(cc->sched, db.graph)) {
-                    log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                                 "whisper run: alloc_graph failed (prompt)");
+                    log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "whisper run: alloc_graph failed (prompt)");
                     return TRANSCRIBE_ERR_GGUF;
                 }
 
-                ggml_backend_tensor_set(db.token_ids_in, prompt_ids.data(),
-                                        0, prompt_ids.size() * sizeof(int32_t));
+                ggml_backend_tensor_set(db.token_ids_in, prompt_ids.data(), 0, prompt_ids.size() * sizeof(int32_t));
                 std::vector<int32_t> pos_ids(seq_len);
-                for (int i = 0; i < seq_len; ++i) pos_ids[i] = i;
+                for (int i = 0; i < seq_len; ++i) {
+                    pos_ids[i] = i;
+                }
                 ggml_tensor * pos_in = ggml_graph_get_tensor(db.graph, "dec.pos_ids");
-                ggml_backend_tensor_set(pos_in, pos_ids.data(),
-                                        0, pos_ids.size() * sizeof(int32_t));
+                ggml_backend_tensor_set(pos_in, pos_ids.data(), 0, pos_ids.size() * sizeof(int32_t));
 
                 if (db.causal_mask_in != nullptr) {
                     // Mask shape: [n_kv, n_tokens] = [n_kv, seq_len].
                     // db.causal_mask_in carries the runtime n_kv (may
                     // be padded beyond seq_len for FA alignment).
-                    const int n_kv_mask =
-                        static_cast<int>(db.causal_mask_in->ne[0]);
-                    std::vector<float> mask(
-                        static_cast<size_t>(n_kv_mask) * seq_len);
+                    const int          n_kv_mask = static_cast<int>(db.causal_mask_in->ne[0]);
+                    std::vector<float> mask(static_cast<size_t>(n_kv_mask) * seq_len);
                     for (int q = 0; q < seq_len; ++q) {
                         for (int k = 0; k < n_kv_mask; ++k) {
                             // Causal in [0, seq_len), -inf for padded
                             // slots in [seq_len, n_kv_mask).
-                            mask[static_cast<size_t>(q) * n_kv_mask + k] =
-                                (k < seq_len && k <= q) ? 0.0f : -1e9f;
+                            mask[static_cast<size_t>(q) * n_kv_mask + k] = (k < seq_len && k <= q) ? 0.0f : -1e9f;
                         }
                     }
-                    ggml_backend_tensor_set(db.causal_mask_in, mask.data(),
-                                            0, mask.size() * sizeof(float));
+                    ggml_backend_tensor_set(db.causal_mask_in, mask.data(), 0, mask.size() * sizeof(float));
                 }
 
                 if (db.cross_mask_in != nullptr) {
                     // Cross mask shape [T_enc_pad, n_tokens]. Zero
                     // for k in [0, T_enc), -inf for trailing padded
                     // slots — same for every query row.
-                    const int n_kv_cross =
-                        static_cast<int>(db.cross_mask_in->ne[0]);
-                    std::vector<float> mask(
-                        static_cast<size_t>(n_kv_cross) * seq_len);
+                    const int          n_kv_cross = static_cast<int>(db.cross_mask_in->ne[0]);
+                    std::vector<float> mask(static_cast<size_t>(n_kv_cross) * seq_len);
                     for (int q = 0; q < seq_len; ++q) {
                         for (int k = 0; k < n_kv_cross; ++k) {
-                            mask[static_cast<size_t>(q) * n_kv_cross + k] =
-                                (k < T_enc_local) ? 0.0f : -1e9f;
+                            mask[static_cast<size_t>(q) * n_kv_cross + k] = (k < T_enc_local) ? 0.0f : -1e9f;
                         }
                     }
-                    ggml_backend_tensor_set(db.cross_mask_in, mask.data(),
-                                            0, mask.size() * sizeof(float));
+                    ggml_backend_tensor_set(db.cross_mask_in, mask.data(), 0, mask.size() * sizeof(float));
                 }
-                cc->perf.prompt_alloc.add(
-                    ggml_time_us() - t_prompt_alloc_start);
+                cc->perf.prompt_alloc.add(ggml_time_us() - t_prompt_alloc_start);
 
                 const int64_t t_prompt_compute_start = ggml_time_us();
-                if (const ggml_status gs = ggml_backend_sched_graph_compute(
-                        cc->sched, db.graph);
-                    gs != GGML_STATUS_SUCCESS)
-                {
+                if (const ggml_status gs = ggml_backend_sched_graph_compute(cc->sched, db.graph);
+                    gs != GGML_STATUS_SUCCESS) {
                     return TRANSCRIBE_ERR_GGUF;
                 }
-                cc->perf.prompt_compute.add(
-                    ggml_time_us() - t_prompt_compute_start);
+                cc->perf.prompt_compute.add(ggml_time_us() - t_prompt_compute_start);
                 cc->kv_cache.n    = seq_len;
                 cc->kv_cache.head = seq_len;
 
-                tier_try_dump("dec.token_emb",       db.dumps.token_emb,       "decoder.embedding");
-                tier_try_dump("dec.pos_emb",         db.dumps.pos_emb,         "decoder.position_embedding");
-                tier_try_dump("dec.embed_sum",       db.dumps.embed_sum,       "decoder.embed_sum");
+                tier_try_dump("dec.token_emb", db.dumps.token_emb, "decoder.embedding");
+                tier_try_dump("dec.pos_emb", db.dumps.pos_emb, "decoder.position_embedding");
+                tier_try_dump("dec.embed_sum", db.dumps.embed_sum, "decoder.embed_sum");
                 for (size_t i = 0; i < db.dumps.block_outs.size(); ++i) {
                     char bname[64], stage[64];
                     std::snprintf(bname, sizeof(bname), "dec.block.%zu.out", i);
@@ -2191,8 +2003,8 @@ transcribe_status whisper_run(
                     tier_try_dump(bname, db.dumps.block_outs[i], stage);
                 }
                 tier_try_dump("dec.out_before_head", db.dumps.out_before_head, "decoder.output_before_head");
-                tier_try_dump("dec.logits_raw",      db.dumps.logits_raw,      "decoder.logits_raw");
-                tier_try_dump("dec.logits",          db.dumps.logits,          "decoder.logits");
+                tier_try_dump("dec.logits_raw", db.dumps.logits_raw, "decoder.logits_raw");
+                tier_try_dump("dec.logits", db.dumps.logits, "decoder.logits");
 
                 const size_t row_bytes = static_cast<size_t>(vocab_size) * sizeof(float);
 
@@ -2203,22 +2015,18 @@ transcribe_status whisper_run(
                 // len(prev_tokens), 0 with no prev tokens). Tier 0 only. Read
                 // into a temp buffer so the suppress / timestamp rules applied
                 // to last_logits below don't contaminate the measurement.
-                if (ti == 0 && !no_speech_prob_captured &&
-                    no_speech_token_id >= 0 &&
-                    no_speech_token_id < static_cast<int>(vocab_size))
-                {
-                    std::vector<float> sot_logits(
-                        static_cast<size_t>(vocab_size));
-                    const int64_t t_prompt_tget_sot = ggml_time_us();
-                    ggml_backend_tensor_get(
-                        db.dumps.logits_raw, sot_logits.data(),
-                        row_bytes * static_cast<size_t>(sot_index),
-                        row_bytes);
-                    cc->perf.prompt_tensor_get.add(
-                        ggml_time_us() - t_prompt_tget_sot);
+                if (ti == 0 && !no_speech_prob_captured && no_speech_token_id >= 0 &&
+                    no_speech_token_id < static_cast<int>(vocab_size)) {
+                    std::vector<float> sot_logits(static_cast<size_t>(vocab_size));
+                    const int64_t      t_prompt_tget_sot = ggml_time_us();
+                    ggml_backend_tensor_get(db.dumps.logits_raw, sot_logits.data(),
+                                            row_bytes * static_cast<size_t>(sot_index), row_bytes);
+                    cc->perf.prompt_tensor_get.add(ggml_time_us() - t_prompt_tget_sot);
                     float max_l = -std::numeric_limits<float>::infinity();
                     for (auto l : sot_logits) {
-                        if (std::isfinite(l) && l > max_l) max_l = l;
+                        if (std::isfinite(l) && l > max_l) {
+                            max_l = l;
+                        }
                     }
                     double sum = 0.0;
                     double ns  = 0.0;
@@ -2226,31 +2034,25 @@ transcribe_status whisper_run(
                         for (size_t i = 0; i < sot_logits.size(); ++i) {
                             const float l = sot_logits[i];
                             if (std::isfinite(l)) {
-                                const double e = std::exp(
-                                    static_cast<double>(l - max_l));
+                                const double e = std::exp(static_cast<double>(l - max_l));
                                 sum += e;
-                                if (static_cast<int>(i) ==
-                                    no_speech_token_id)
-                                {
+                                if (static_cast<int>(i) == no_speech_token_id) {
                                     ns = e;
                                 }
                             }
                         }
                     }
-                    no_speech_prob = (sum > 0.0)
-                        ? static_cast<float>(ns / sum) : 0.0f;
+                    no_speech_prob          = (sum > 0.0) ? static_cast<float>(ns / sum) : 0.0f;
                     no_speech_prob_captured = true;
                 }
 
                 // Last-row logits → first generated token.
                 const int64_t t_prompt_tget_last = ggml_time_us();
                 ggml_backend_tensor_get(db.dumps.logits_raw, last_logits.data(),
-                                        row_bytes * static_cast<size_t>(seq_len - 1),
-                                        row_bytes);
-                cc->perf.prompt_tensor_get.add(
-                    ggml_time_us() - t_prompt_tget_last);
+                                        row_bytes * static_cast<size_t>(seq_len - 1), row_bytes);
+                cc->perf.prompt_tensor_get.add(ggml_time_us() - t_prompt_tget_last);
 
-                const int64_t t_prompt_cpu_start = ggml_time_us();
+                const int64_t t_prompt_cpu_start      = ggml_time_us();
                 const int64_t t_prompt_suppress_start = ggml_time_us();
                 suppress_in_place(last_logits);
                 for (int32_t id : cm->hparams.begin_suppress_tokens) {
@@ -2258,34 +2060,27 @@ transcribe_status whisper_run(
                         last_logits[static_cast<size_t>(id)] = -INFINITY;
                     }
                 }
-                cc->perf.prompt_cpu_suppress.add(
-                    ggml_time_us() - t_prompt_suppress_start);
+                cc->perf.prompt_cpu_suppress.add(ggml_time_us() - t_prompt_suppress_start);
 
                 const int64_t t_prompt_ts_start = ggml_time_us();
                 apply_timestamp_rules(last_logits);
-                cc->perf.prompt_cpu_timestamp.add(
-                    ggml_time_us() - t_prompt_ts_start);
+                cc->perf.prompt_cpu_timestamp.add(ggml_time_us() - t_prompt_ts_start);
 
                 if (tier_T <= 0.0f) {
                     // T==0: fused argmax + log-softmax (logprob computed free).
                     const int64_t t_prompt_sample_start = ggml_time_us();
-                    float lp = 0.0f;
-                    next_id = sample_argmax_and_logprob(last_logits, &lp);
+                    float         lp                    = 0.0f;
+                    next_id                             = sample_argmax_and_logprob(last_logits, &lp);
                     sum_logprob += lp;
-                    cc->perf.prompt_cpu_sample.add(
-                        ggml_time_us() - t_prompt_sample_start);
+                    cc->perf.prompt_cpu_sample.add(ggml_time_us() - t_prompt_sample_start);
                 } else {
                     const int64_t t_prompt_sample_start = ggml_time_us();
-                    next_id = sample_from_logits(
-                        last_logits, tier_T, rng, &cc->sample_scratch);
-                    cc->perf.prompt_cpu_sample.add(
-                        ggml_time_us() - t_prompt_sample_start);
+                    next_id = sample_from_logits(last_logits, tier_T, rng, &cc->sample_scratch);
+                    cc->perf.prompt_cpu_sample.add(ggml_time_us() - t_prompt_sample_start);
 
                     const int64_t t_prompt_lp_start = ggml_time_us();
-                    sum_logprob +=
-                        logprob_of_token_hf(last_logits, next_id, tier_T);
-                    cc->perf.prompt_cpu_logprob.add(
-                        ggml_time_us() - t_prompt_lp_start);
+                    sum_logprob += logprob_of_token_hf(last_logits, next_id, tier_T);
+                    cc->perf.prompt_cpu_logprob.add(ggml_time_us() - t_prompt_lp_start);
                 }
                 n_logprob_samples += 1;
                 cc->perf.prompt_cpu.add(ggml_time_us() - t_prompt_cpu_start);
@@ -2297,64 +2092,62 @@ transcribe_status whisper_run(
             //     writes via ggml_set_rows at runtime kv_idx, FA reads a fixed
             //     max_n_kv window with a runtime mask).
             //   CPU/debug: per-step build_decoder_graph_kv with dynamic n_kv.
-            int n_past = seq_len;
-            const bool primary_is_gpu =
-                cm->plan.primary_kind != transcribe::BackendKind::Cpu &&
-                cm->plan.primary_kind != transcribe::BackendKind::Accel &&
-                cm->plan.primary_kind != transcribe::BackendKind::Unknown;
-            const bool use_step_graph = primary_is_gpu &&
-                                        !transcribe::debug::enabled();
+            int        n_past         = seq_len;
+            const bool primary_is_gpu = cm->plan.primary_kind != transcribe::BackendKind::Cpu &&
+                                        cm->plan.primary_kind != transcribe::BackendKind::Accel &&
+                                        cm->plan.primary_kind != transcribe::BackendKind::Unknown;
+            const bool use_step_graph = primary_is_gpu && !transcribe::debug::enabled();
 
             // Sized to fit prompt + max generated tail, padded to next pow2,
             // capped at n_ctx_decoder (448).
             int max_n_kv = 256;
-            while (max_n_kv < seq_len + k_max_new_tokens) max_n_kv *= 2;
+            while (max_n_kv < seq_len + k_max_new_tokens) {
+                max_n_kv *= 2;
+            }
             if (max_n_kv > static_cast<int>(n_ctx_decoder)) {
                 max_n_kv = static_cast<int>(n_ctx_decoder);
             }
 
             // Step graph + persistent host buffers (use_step_graph path only).
-            StepBuild sb {};
+            StepBuild                sb{};
             std::vector<ggml_fp16_t> step_mask;
             std::vector<float>       step_cross_mask;
-            const ggml_fp16_t mask_zero    = ggml_fp32_to_fp16(0.0f);
-            const ggml_fp16_t mask_neg_inf = ggml_fp32_to_fp16(-INFINITY);
+            const ggml_fp16_t        mask_zero    = ggml_fp32_to_fp16(0.0f);
+            const ggml_fp16_t        mask_neg_inf = ggml_fp32_to_fp16(-INFINITY);
 
             if (use_step_graph) {
-                if (!new_compute_ctx(8 * 1024 * 1024)) return TRANSCRIBE_ERR_GGUF;
-                sb = build_step_graph(
-                    cc->compute_ctx, cm->weights, cm->hparams, cc->kv_cache,
-                    max_n_kv, T_enc_local, cc->decoder_use_flash);
+                if (!new_compute_ctx(8 * 1024 * 1024)) {
+                    return TRANSCRIBE_ERR_GGUF;
+                }
+                sb = build_step_graph(cc->compute_ctx, cm->weights, cm->hparams, cc->kv_cache, max_n_kv, T_enc_local,
+                                      cc->decoder_use_flash);
                 if (sb.graph == nullptr || sb.logits_out == nullptr) {
-                    log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                                 "whisper run: build_step_graph failed");
+                    log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "whisper run: build_step_graph failed");
                     return TRANSCRIBE_ERR_GGUF;
                 }
                 ggml_backend_sched_reset(cc->sched);
                 if (!ggml_backend_sched_alloc_graph(cc->sched, sb.graph)) {
-                    log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                                 "whisper run: sched_alloc_graph failed (step)");
+                    log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "whisper run: sched_alloc_graph failed (step)");
                     return TRANSCRIBE_ERR_GGUF;
                 }
 
                 // Self-attn mask: [0, seq_len) populated by prompt pass
                 // are attendable; [seq_len, max_n_kv) start as -inf.
                 step_mask.assign(max_n_kv, mask_neg_inf);
-                for (int p = 0; p < seq_len; ++p) step_mask[p] = mask_zero;
+                for (int p = 0; p < seq_len; ++p) {
+                    step_mask[p] = mask_zero;
+                }
 
                 // Cross mask is invariant across steps within a chunk —
                 // upload once and reuse.
                 if (sb.cross_mask_in != nullptr) {
-                    const int n_kv_cross =
-                        static_cast<int>(sb.cross_mask_in->ne[0]);
-                    step_cross_mask.assign(
-                        static_cast<size_t>(n_kv_cross), 0.0f);
+                    const int n_kv_cross = static_cast<int>(sb.cross_mask_in->ne[0]);
+                    step_cross_mask.assign(static_cast<size_t>(n_kv_cross), 0.0f);
                     for (int k = T_enc_local; k < n_kv_cross; ++k) {
                         step_cross_mask[static_cast<size_t>(k)] = -1e9f;
                     }
-                    ggml_backend_tensor_set(
-                        sb.cross_mask_in, step_cross_mask.data(),
-                        0, step_cross_mask.size() * sizeof(float));
+                    ggml_backend_tensor_set(sb.cross_mask_in, step_cross_mask.data(), 0,
+                                            step_cross_mask.size() * sizeof(float));
                 }
             }
 
@@ -2369,11 +2162,11 @@ transcribe_status whisper_run(
                 }
                 consume_generated_token(next_id);
 
-                if (n_past + 1 > static_cast<int>(n_ctx_decoder)) break;
+                if (n_past + 1 > static_cast<int>(n_ctx_decoder)) {
+                    break;
+                }
                 if (use_step_graph && n_past + 1 > max_n_kv) {
-                    log_msg(TRANSCRIBE_LOG_LEVEL_INFO,
-                                 "whisper run: hit max_n_kv=%d at n_past=%d",
-                                 max_n_kv, n_past);
+                    log_msg(TRANSCRIBE_LOG_LEVEL_INFO, "whisper run: hit max_n_kv=%d at n_past=%d", max_n_kv, n_past);
                     break;
                 }
 
@@ -2381,50 +2174,46 @@ transcribe_status whisper_run(
 
                 if (use_step_graph) {
                     const int64_t t_step_alloc_start = ggml_time_us();
-                    int32_t tok      = next_id;
-                    int32_t pos_val  = n_past;
-                    int64_t kv_val   = n_past;
-                    ggml_backend_tensor_set(sb.token_id_in, &tok,     0, sizeof(int32_t));
-                    ggml_backend_tensor_set(sb.pos_id_in,   &pos_val, 0, sizeof(int32_t));
-                    ggml_backend_tensor_set(sb.kv_idx_in,   &kv_val,  0, sizeof(int64_t));
+                    int32_t       tok                = next_id;
+                    int32_t       pos_val            = n_past;
+                    int64_t       kv_val             = n_past;
+                    ggml_backend_tensor_set(sb.token_id_in, &tok, 0, sizeof(int32_t));
+                    ggml_backend_tensor_set(sb.pos_id_in, &pos_val, 0, sizeof(int32_t));
+                    ggml_backend_tensor_set(sb.kv_idx_in, &kv_val, 0, sizeof(int64_t));
 
                     step_mask[n_past] = mask_zero;
-                    ggml_backend_tensor_set(
-                        sb.mask_in, step_mask.data(),
-                        0, static_cast<size_t>(max_n_kv) * sizeof(ggml_fp16_t));
-                    cc->perf.step_alloc.add(
-                        ggml_time_us() - t_step_alloc_start);
+                    ggml_backend_tensor_set(sb.mask_in, step_mask.data(), 0,
+                                            static_cast<size_t>(max_n_kv) * sizeof(ggml_fp16_t));
+                    cc->perf.step_alloc.add(ggml_time_us() - t_step_alloc_start);
 
                     const int64_t t_step_compute_start = ggml_time_us();
-                    if (const ggml_status gs = ggml_backend_sched_graph_compute(
-                            cc->sched, sb.graph);
-                        gs != GGML_STATUS_SUCCESS)
-                    {
+                    if (const ggml_status gs = ggml_backend_sched_graph_compute(cc->sched, sb.graph);
+                        gs != GGML_STATUS_SUCCESS) {
                         return TRANSCRIBE_ERR_GGUF;
                     }
-                    cc->perf.step_compute.add(
-                        ggml_time_us() - t_step_compute_start);
+                    cc->perf.step_compute.add(ggml_time_us() - t_step_compute_start);
 
                     n_past += 1;
                     cc->kv_cache.n    = n_past;
                     cc->kv_cache.head = n_past;
 
                     const int64_t t_step_tget_start = ggml_time_us();
-                    ggml_backend_tensor_get(sb.logits_out, last_logits.data(),
-                                            0, row_bytes);
-                    cc->perf.step_tensor_get.add(
-                        ggml_time_us() - t_step_tget_start);
+                    ggml_backend_tensor_get(sb.logits_out, last_logits.data(), 0, row_bytes);
+                    cc->perf.step_tensor_get.add(ggml_time_us() - t_step_tget_start);
                 } else {
                     const int64_t t_step_build_start = ggml_time_us();
-                    if (!new_compute_ctx(4 * 1024 * 1024)) return TRANSCRIBE_ERR_GGUF;
-                    const int kv_pad = kv_pad_self_attn(
-                        cm->plan.primary_kind, cc->decoder_use_flash);
-                    DecoderBuild step_db = build_decoder_graph_kv(
-                        cc->compute_ctx, cm->weights, cm->hparams, cc->kv_cache,
-                        /*n_tokens=*/1, /*n_past=*/n_past, T_enc_local,
-                        /*kv_pad=*/kv_pad,
-                        /*skip_log_softmax=*/true, cc->decoder_use_flash);
-                    if (step_db.out == nullptr) return TRANSCRIBE_ERR_GGUF;
+                    if (!new_compute_ctx(4 * 1024 * 1024)) {
+                        return TRANSCRIBE_ERR_GGUF;
+                    }
+                    const int    kv_pad = kv_pad_self_attn(cm->plan.primary_kind, cc->decoder_use_flash);
+                    DecoderBuild step_db =
+                        build_decoder_graph_kv(cc->compute_ctx, cm->weights, cm->hparams, cc->kv_cache,
+                                               /*n_tokens=*/1, /*n_past=*/n_past, T_enc_local,
+                                               /*kv_pad=*/kv_pad,
+                                               /*skip_log_softmax=*/true, cc->decoder_use_flash);
+                    if (step_db.out == nullptr) {
+                        return TRANSCRIBE_ERR_GGUF;
+                    }
                     cc->perf.step_build.add(ggml_time_us() - t_step_build_start);
 
                     const int64_t t_step_alloc_start = ggml_time_us();
@@ -2442,38 +2231,28 @@ transcribe_status whisper_run(
                     // Padded step: [0, n_past+1) is 0, trailing slots -inf so
                     // FA ignores stale K/V from previous tiers/chunks.
                     if (step_db.causal_mask_in != nullptr) {
-                        const int n_kv_mask =
-                            static_cast<int>(step_db.causal_mask_in->ne[0]);
-                        std::vector<float> mask(
-                            static_cast<size_t>(n_kv_mask), 0.0f);
-                        const int n_valid = n_past + 1;
+                        const int          n_kv_mask = static_cast<int>(step_db.causal_mask_in->ne[0]);
+                        std::vector<float> mask(static_cast<size_t>(n_kv_mask), 0.0f);
+                        const int          n_valid = n_past + 1;
                         for (int k = n_valid; k < n_kv_mask; ++k) {
                             mask[static_cast<size_t>(k)] = -1e9f;
                         }
-                        ggml_backend_tensor_set(
-                            step_db.causal_mask_in, mask.data(),
-                            0, mask.size() * sizeof(float));
+                        ggml_backend_tensor_set(step_db.causal_mask_in, mask.data(), 0, mask.size() * sizeof(float));
                     }
 
                     if (step_db.cross_mask_in != nullptr) {
-                        const int n_kv_cross =
-                            static_cast<int>(step_db.cross_mask_in->ne[0]);
-                        std::vector<float> mask(
-                            static_cast<size_t>(n_kv_cross), 0.0f);
+                        const int          n_kv_cross = static_cast<int>(step_db.cross_mask_in->ne[0]);
+                        std::vector<float> mask(static_cast<size_t>(n_kv_cross), 0.0f);
                         for (int k = T_enc_local; k < n_kv_cross; ++k) {
                             mask[static_cast<size_t>(k)] = -1e9f;
                         }
-                        ggml_backend_tensor_set(
-                            step_db.cross_mask_in, mask.data(),
-                            0, mask.size() * sizeof(float));
+                        ggml_backend_tensor_set(step_db.cross_mask_in, mask.data(), 0, mask.size() * sizeof(float));
                     }
                     cc->perf.step_alloc.add(ggml_time_us() - t_step_alloc_start);
 
                     const int64_t t_step_compute_start = ggml_time_us();
-                    if (const ggml_status gs = ggml_backend_sched_graph_compute(
-                            cc->sched, step_db.graph);
-                        gs != GGML_STATUS_SUCCESS)
-                    {
+                    if (const ggml_status gs = ggml_backend_sched_graph_compute(cc->sched, step_db.graph);
+                        gs != GGML_STATUS_SUCCESS) {
                         return TRANSCRIBE_ERR_GGUF;
                     }
                     cc->perf.step_compute.add(ggml_time_us() - t_step_compute_start);
@@ -2487,8 +2266,7 @@ transcribe_status whisper_run(
                     // cannot reach. Captured on tier 0 of the first chunk
                     // only (tolerance references were generated at T=0).
                     if (step == 19) {
-                        tier_try_dump("dec.logits_raw.gen20", step_db.out,
-                                      "decoder.logits_raw.gen20");
+                        tier_try_dump("dec.logits_raw.gen20", step_db.out, "decoder.logits_raw.gen20");
                     }
 
                     const int64_t t_step_tget_start = ggml_time_us();
@@ -2496,36 +2274,29 @@ transcribe_status whisper_run(
                     cc->perf.step_tensor_get.add(ggml_time_us() - t_step_tget_start);
                 }
 
-                const int64_t t_step_cpu_start = ggml_time_us();
+                const int64_t t_step_cpu_start      = ggml_time_us();
                 const int64_t t_step_suppress_start = ggml_time_us();
                 suppress_in_place(last_logits);
-                cc->perf.step_cpu_suppress.add(
-                    ggml_time_us() - t_step_suppress_start);
+                cc->perf.step_cpu_suppress.add(ggml_time_us() - t_step_suppress_start);
 
                 const int64_t t_step_ts_start = ggml_time_us();
                 apply_timestamp_rules(last_logits);
-                cc->perf.step_cpu_timestamp.add(
-                    ggml_time_us() - t_step_ts_start);
+                cc->perf.step_cpu_timestamp.add(ggml_time_us() - t_step_ts_start);
 
                 if (tier_T <= 0.0f) {
                     const int64_t t_step_sample_start = ggml_time_us();
-                    float lp = 0.0f;
-                    next_id = sample_argmax_and_logprob(last_logits, &lp);
+                    float         lp                  = 0.0f;
+                    next_id                           = sample_argmax_and_logprob(last_logits, &lp);
                     sum_logprob += lp;
-                    cc->perf.step_cpu_sample.add(
-                        ggml_time_us() - t_step_sample_start);
+                    cc->perf.step_cpu_sample.add(ggml_time_us() - t_step_sample_start);
                 } else {
                     const int64_t t_step_sample_start = ggml_time_us();
-                    next_id = sample_from_logits(
-                        last_logits, tier_T, rng, &cc->sample_scratch);
-                    cc->perf.step_cpu_sample.add(
-                        ggml_time_us() - t_step_sample_start);
+                    next_id = sample_from_logits(last_logits, tier_T, rng, &cc->sample_scratch);
+                    cc->perf.step_cpu_sample.add(ggml_time_us() - t_step_sample_start);
 
                     const int64_t t_step_lp_start = ggml_time_us();
-                    sum_logprob +=
-                        logprob_of_token_hf(last_logits, next_id, tier_T);
-                    cc->perf.step_cpu_logprob.add(
-                        ggml_time_us() - t_step_lp_start);
+                    sum_logprob += logprob_of_token_hf(last_logits, next_id, tier_T);
+                    cc->perf.step_cpu_logprob.add(ggml_time_us() - t_step_lp_start);
                 }
                 n_logprob_samples += 1;
                 cc->perf.step_cpu.add(ggml_time_us() - t_step_cpu_start);
@@ -2539,26 +2310,20 @@ transcribe_status whisper_run(
             // accept/escalate boundary.
             std::vector<int32_t> comp_tail;
             comp_tail.reserve(generated_ids.size() + 1);
-            comp_tail.insert(comp_tail.end(),
-                             generated_ids.begin(), generated_ids.end());
+            comp_tail.insert(comp_tail.end(), generated_ids.begin(), generated_ids.end());
             if (tier_hit_eos) {
                 comp_tail.push_back(static_cast<int32_t>(eos_id));
             }
-            const float tier_comp_ratio =
-                compute_compression_ratio_hf(comp_tail, vocab_size);
-            const float tier_avg_logprob =
-                n_logprob_samples > 0
-                    ? static_cast<float>(sum_logprob / n_logprob_samples)
-                    : -std::numeric_limits<float>::infinity();
+            const float tier_comp_ratio  = compute_compression_ratio_hf(comp_tail, vocab_size);
+            const float tier_avg_logprob = n_logprob_samples > 0 ? static_cast<float>(sum_logprob / n_logprob_samples) :
+                                                                   -std::numeric_limits<float>::infinity();
 
             // Thresholds. HF _need_fallback falls back strictly on
             // `comp_ratio > thold` or `avg_logprob < thold`; equality does NOT
             // trigger, so a tier is accepted under `<= / >=`. INF sentinels work
             // (<= +INF and >= -INF are always true: disabled thresholds pass).
-            const bool comp_ok =
-                tier_comp_ratio <= wp->compression_ratio_thold;
-            const bool lp_ok =
-                tier_avg_logprob >= wp->logprob_thold;
+            const bool comp_ok = tier_comp_ratio <= wp->compression_ratio_thold;
+            const bool lp_ok   = tier_avg_logprob >= wp->logprob_thold;
 
             // HF _need_fallback sets should_skip (and halts fallback) when BOTH
             // no_speech_prob > no_speech_thold AND avg_logprob < logprob_thold.
@@ -2566,8 +2331,7 @@ transcribe_status whisper_run(
             // logprob is per-tier. Sentinels: no_speech_thold=+INF or
             // logprob_thold=-INF disables the skip.
             const bool no_speech_should_skip =
-                no_speech_prob > wp->no_speech_thold &&
-                tier_avg_logprob < wp->logprob_thold;
+                no_speech_prob > wp->no_speech_thold && tier_avg_logprob < wp->logprob_thold;
 
             // Commit the tier's output unconditionally so the last-tried tier
             // wins when no tier passes (matches HF generate_with_fallback). A
@@ -2600,10 +2364,10 @@ transcribe_status whisper_run(
         // Commit per-chunk trace over [time_offset_ms, +seek_num_frames*10ms):
         // what the fallback loop decided and what the no-speech gate saw.
         {
-            transcribe_whisper_chunk_trace trace; transcribe_whisper_chunk_trace_init(&trace);
+            transcribe_whisper_chunk_trace trace;
+            transcribe_whisper_chunk_trace_init(&trace);
             trace.t0_ms               = time_offset_ms;
-            trace.t1_ms               = time_offset_ms +
-                                        static_cast<int64_t>(seek_num_frames) * 10;
+            trace.t1_ms               = time_offset_ms + static_cast<int64_t>(seek_num_frames) * 10;
             trace.temperature_used    = accepted_T;
             trace.compression_ratio   = accepted_compression;
             trace.avg_logprob         = accepted_avg_logprob;
@@ -2617,8 +2381,7 @@ transcribe_status whisper_run(
         // the accepted temperature was hot (>= 0.5, presumed hallucinated) to
         // avoid propagating into the next chunk. History is updated after
         // _retrieve_segment (HF carries only the surviving segment tokens).
-        do_condition_on_prev_tokens =
-            wp->condition_on_prev_tokens && (accepted_T < 0.5f);
+        do_condition_on_prev_tokens = wp->condition_on_prev_tokens && (accepted_T < 0.5f);
 
         // _retrieve_segment (port of HF). Splits generated_ids on consecutive-
         // timestamp pairs (one SegmentEntry per pair) and returns
@@ -2630,28 +2393,23 @@ transcribe_status whisper_run(
         //   - no pairs: emit one full-chunk segment, advance seek_num_frames.
         // TIMESTAMPS_NONE includes <|notimestamps|>, so no ts tokens -> "no
         // pairs" branch, full-chunk advance, no per-chunk segment emission.
-        WhisperSegmentResult seg_res = whisper_retrieve_segment(
-            generated_ids, cm->tok, time_offset_ms, seek_num_frames,
-            want_segment_timestamps, timestamp_begin, vocab_size);
+        WhisperSegmentResult seg_res = whisper_retrieve_segment(generated_ids, cm->tok, time_offset_ms, seek_num_frames,
+                                                                want_segment_timestamps, timestamp_begin, vocab_size);
         for (auto & seg : seg_res.segments) {
             cc->segments.push_back(std::move(seg));
         }
-        int segment_offset_frames = seg_res.segment_offset_frames;
-        std::vector<std::vector<int32_t>> & prev_chunk_segments =
-            seg_res.prev_chunk_segments;
+        int                                 segment_offset_frames = seg_res.segment_offset_frames;
+        std::vector<std::vector<int32_t>> & prev_chunk_segments   = seg_res.prev_chunk_segments;
 
         // Update prev-context history from the _retrieve_segment slices, not
         // accepted_generated_ids directly: the closed-pair branch discards the
         // unfinished tail, and carrying it would leak into the next prompt.
         if (!no_speech_fired_this_chunk && !prev_chunk_segments.empty()) {
-            prev_history_segments.insert(prev_history_segments.end(),
-                                         prev_chunk_segments.begin(),
+            prev_history_segments.insert(prev_history_segments.end(), prev_chunk_segments.begin(),
                                          prev_chunk_segments.end());
         }
 
-        all_text_ids.insert(all_text_ids.end(),
-                            generated_text_ids.begin(),
-                            generated_text_ids.end());
+        all_text_ids.insert(all_text_ids.end(), generated_text_ids.begin(), generated_text_ids.end());
 
         // Seek advance.
         //   Short-form: full-chunk advance. PCM is padded to exactly
@@ -2694,36 +2452,34 @@ transcribe_status whisper_run(
 // result, so batch_parity holds; anything that would diverge runs serially.
 
 // Serial fallback: run each utterance through whisper_run and snapshot it.
-transcribe_status whisper_run_batch_serial(
-    WhisperSession *              cc,
-    const float * const *         pcm,
-    const int *                   n_samples,
-    int                           n,
-    const transcribe_run_params * params)
-{
+transcribe_status whisper_run_batch_serial(WhisperSession *              cc,
+                                           const float * const *         pcm,
+                                           const int *                   n_samples,
+                                           int                           n,
+                                           const transcribe_run_params * params) {
     for (int i = 0; i < n; ++i) {
-        if (cc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
-        const transcribe_status st =
-            (pcm[i] == nullptr || n_samples[i] <= 0)
-                ? TRANSCRIBE_ERR_INVALID_ARG
-                : whisper_run(cc, pcm[i], n_samples[i], params);
+        if (cc->poll_abort()) {
+            return TRANSCRIBE_ERR_ABORTED;
+        }
+        const transcribe_status st = (pcm[i] == nullptr || n_samples[i] <= 0) ?
+                                         TRANSCRIBE_ERR_INVALID_ARG :
+                                         whisper_run(cc, pcm[i], n_samples[i], params);
         if (st == TRANSCRIBE_OK) {
             cc->batch_results.push_back(cc->capture_result(st));
         } else {
-            transcribe_session::ResultSet rs; rs.status = st;
+            transcribe_session::ResultSet rs;
+            rs.status = st;
             cc->batch_results.push_back(std::move(rs));
         }
     }
     return TRANSCRIBE_OK;
 }
 
-transcribe_status whisper_run_batch(
-    transcribe_session *          session,
-    const float * const *         pcm,
-    const int *                   n_samples,
-    int                           n,
-    const transcribe_run_params * params)
-{
+transcribe_status whisper_run_batch(transcribe_session *          session,
+                                    const float * const *         pcm,
+                                    const int *                   n_samples,
+                                    int                           n,
+                                    const transcribe_run_params * params) {
     if (session == nullptr || pcm == nullptr || n_samples == nullptr || n <= 0) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
@@ -2734,67 +2490,57 @@ transcribe_status whisper_run_batch(
     }
 
     // Resolve the whisper run-ext (NULL → shipping defaults).
-    if (const transcribe_status st = transcribe_ext_check(
-            params != nullptr ? params->family : nullptr,
-            TRANSCRIBE_EXT_KIND_WHISPER_RUN,
-            sizeof(struct transcribe_whisper_run_ext));
-        st != TRANSCRIBE_OK)
-    {
+    if (const transcribe_status st =
+            transcribe_ext_check(params != nullptr ? params->family : nullptr, TRANSCRIBE_EXT_KIND_WHISPER_RUN,
+                                 sizeof(struct transcribe_whisper_run_ext));
+        st != TRANSCRIBE_OK) {
         return st;
     }
-    transcribe_whisper_run_ext default_wp; transcribe_whisper_run_ext_init(&default_wp);
-    const transcribe_whisper_run_ext * wp =
-        (params != nullptr && params->family != nullptr)
-            ? reinterpret_cast<const transcribe_whisper_run_ext *>(params->family)
-            : &default_wp;
+    transcribe_whisper_run_ext default_wp;
+    transcribe_whisper_run_ext_init(&default_wp);
+    const transcribe_whisper_run_ext * wp = (params != nullptr && params->family != nullptr) ?
+                                                reinterpret_cast<const transcribe_whisper_run_ext *>(params->family) :
+                                                &default_wp;
 
     // ---- Global gates: only what the batched graph genuinely can't do. ----
     // Segment timestamps, temperature>0 fallback, and initial_prompt are now
     // all handled in-batch; what still peels the WHOLE call to serial is the
     // device/topology constraints + word timestamps (unsupported) + the
     // ALL_SEGMENTS-without-condition error (let serial surface it).
-    const bool primary_is_gpu =
-        cm->plan.primary_kind != transcribe::BackendKind::Cpu &&
-        cm->plan.primary_kind != transcribe::BackendKind::Accel &&
-        cm->plan.primary_kind != transcribe::BackendKind::Unknown;
-    const transcribe_timestamp_kind req_ts =
-        params != nullptr ? params->timestamps : TRANSCRIBE_TIMESTAMPS_NONE;
-    const bool want_ts =
-        req_ts == TRANSCRIBE_TIMESTAMPS_AUTO ||
-        req_ts == TRANSCRIBE_TIMESTAMPS_SEGMENT;
-    if (n == 1 || !cc->decoder_use_flash || !primary_is_gpu ||
-        transcribe::debug::enabled() || req_ts == TRANSCRIBE_TIMESTAMPS_WORD ||
-        (wp->prompt_condition == TRANSCRIBE_WHISPER_PROMPT_ALL_SEGMENTS &&
-         !wp->condition_on_prev_tokens))
-    {
+    const bool                      primary_is_gpu = cm->plan.primary_kind != transcribe::BackendKind::Cpu &&
+                                                     cm->plan.primary_kind != transcribe::BackendKind::Accel &&
+                                                     cm->plan.primary_kind != transcribe::BackendKind::Unknown;
+    const transcribe_timestamp_kind req_ts = params != nullptr ? params->timestamps : TRANSCRIBE_TIMESTAMPS_NONE;
+    const bool want_ts = req_ts == TRANSCRIBE_TIMESTAMPS_AUTO || req_ts == TRANSCRIBE_TIMESTAMPS_SEGMENT;
+    if (n == 1 || !cc->decoder_use_flash || !primary_is_gpu || transcribe::debug::enabled() ||
+        req_ts == TRANSCRIBE_TIMESTAMPS_WORD ||
+        (wp->prompt_condition == TRANSCRIBE_WHISPER_PROMPT_ALL_SEGMENTS && !wp->condition_on_prev_tokens)) {
         return whisper_run_batch_serial(cc, pcm, n_samples, n, params);
     }
 
     transcribe::debug::init();
-    const auto & hp = cm->hparams;
-    const int     d_model     = hp.dec_d_model;
-    const int     n_layer     = hp.dec_n_layers;
-    const int64_t vocab_size  = hp.dec_vocab_size;
-    const int     eos_id      = cm->tok.eos_id() >= 0 ? cm->tok.eos_id() : 50257;
-    const int     timestamp_begin   = hp.no_timestamps_token_id + 1;
-    const int     no_speech_token_id = hp.no_timestamps_token_id - 1;
-    const int     n_ctx_decoder = hp.dec_max_target_positions;
-    const int     n_mels        = hp.enc_num_mel_bins;
-    const int     n_mel_frames_per_chunk =
-        hp.fe_nb_max_frames > 0 ? hp.fe_nb_max_frames : 3000;
-    const int     n_samples_per_chunk =
-        hp.fe_n_samples > 0 ? hp.fe_n_samples : 480000;
-    const bool    is_multilingual = cm->caps.supports_language_detect;
-    constexpr int k_max_new = 256;
+    const auto &  hp                     = cm->hparams;
+    const int     d_model                = hp.dec_d_model;
+    const int     n_layer                = hp.dec_n_layers;
+    const int64_t vocab_size             = hp.dec_vocab_size;
+    const int     eos_id                 = cm->tok.eos_id() >= 0 ? cm->tok.eos_id() : 50257;
+    const int     timestamp_begin        = hp.no_timestamps_token_id + 1;
+    const int     no_speech_token_id     = hp.no_timestamps_token_id - 1;
+    const int     n_ctx_decoder          = hp.dec_max_target_positions;
+    const int     n_mels                 = hp.enc_num_mel_bins;
+    const int     n_mel_frames_per_chunk = hp.fe_nb_max_frames > 0 ? hp.fe_nb_max_frames : 3000;
+    const int     n_samples_per_chunk    = hp.fe_n_samples > 0 ? hp.fe_n_samples : 480000;
+    const bool    is_multilingual        = cm->caps.supports_language_detect;
+    constexpr int k_max_new              = 256;
     // Short-form: PCM padded to one 30s window, so the whole chunk is one
     // seek of n_mel_frames_per_chunk frames at time offset 0.
-    const int     seek_num_frames = n_mel_frames_per_chunk;
+    const int     seek_num_frames        = n_mel_frames_per_chunk;
 
     // Task token (multilingual only). Non-resolvable → whole-batch serial.
     int32_t task_token = -1;
     if (is_multilingual) {
-        task_token = (params != nullptr && params->task == TRANSCRIBE_TASK_TRANSLATE)
-                         ? hp.translate_token_id : hp.transcribe_token_id;
+        task_token = (params != nullptr && params->task == TRANSCRIBE_TASK_TRANSLATE) ? hp.translate_token_id :
+                                                                                        hp.transcribe_token_id;
         if (task_token < 0) {
             return whisper_run_batch_serial(cc, pcm, n_samples, n, params);
         }
@@ -2804,18 +2550,22 @@ transcribe_status whisper_run_batch(
 
     // Optional language hint (uniform). Unresolvable → serial.
     int32_t lang_hint = -1;
-    if (params != nullptr && params->language != nullptr &&
-        params->language[0] != '\0')
-    {
+    if (params != nullptr && params->language != nullptr && params->language[0] != '\0') {
         const std::string lang_code = params->language;
         if (!is_multilingual) {
-            if (lang_code != "en")
+            if (lang_code != "en") {
                 return whisper_run_batch_serial(cc, pcm, n_samples, n, params);
+            }
         } else {
-            for (size_t i = 0; i < cm->lang_codes.size(); ++i)
-                if (cm->lang_codes[i] == lang_code) { lang_hint = cm->lang_token_ids[i]; break; }
-            if (lang_hint < 0)
+            for (size_t i = 0; i < cm->lang_codes.size(); ++i) {
+                if (cm->lang_codes[i] == lang_code) {
+                    lang_hint = cm->lang_token_ids[i];
+                    break;
+                }
+            }
+            if (lang_hint < 0) {
                 return whisper_run_batch_serial(cc, pcm, n_samples, n, params);
+            }
         }
     }
 
@@ -2823,51 +2573,66 @@ transcribe_status whisper_run_batch(
     // Uniform across the batch (one run_params). Happy-path only: any malformed
     // prompt routes the whole call to serial, which surfaces the exact error.
     int32_t prev_sot_id = hp.prev_sot_token_id;
-    if (prev_sot_id < 0) prev_sot_id = cm->tok.find("<|startofprev|>");
-    const bool prompt_requested =
-        (wp->prompt_tokens != nullptr && wp->n_prompt_tokens > 0) ||
-        (wp->initial_prompt != nullptr && wp->initial_prompt[0] != '\0');
+    if (prev_sot_id < 0) {
+        prev_sot_id = cm->tok.find("<|startofprev|>");
+    }
+    const bool           prompt_requested = (wp->prompt_tokens != nullptr && wp->n_prompt_tokens > 0) ||
+                                            (wp->initial_prompt != nullptr && wp->initial_prompt[0] != '\0');
     std::vector<int32_t> prev_tokens;
     if (prompt_requested) {
-        if (prev_sot_id < 0)
+        if (prev_sot_id < 0) {
             return whisper_run_batch_serial(cc, pcm, n_samples, n, params);
-        const int max_prev_cap = wp->max_prev_context_tokens > 0
-                                     ? wp->max_prev_context_tokens
-                                     : (hp.dec_max_target_positions / 2 - 1);
+        }
+        const int max_prev_cap =
+            wp->max_prev_context_tokens > 0 ? wp->max_prev_context_tokens : (hp.dec_max_target_positions / 2 - 1);
         std::vector<int32_t> ptext;
         if (wp->prompt_tokens != nullptr && wp->n_prompt_tokens > 0) {
-            if (wp->prompt_tokens[0] == prev_sot_id)
+            if (wp->prompt_tokens[0] == prev_sot_id) {
                 return whisper_run_batch_serial(cc, pcm, n_samples, n, params);
+            }
             ptext.assign(wp->prompt_tokens, wp->prompt_tokens + wp->n_prompt_tokens);
         } else {
             std::string s(wp->initial_prompt);
-            auto issp = [](char c){ return c==' '||c=='\t'||c=='\n'||c=='\r'; };
+            auto        issp = [](char c) {
+                return c == ' ' || c == '\t' || c == '\n' || c == '\r';
+            };
             size_t a = 0, b = s.size();
-            while (a < b && issp(s[a])) ++a;
-            while (b > a && issp(s[b-1])) --b;
+            while (a < b && issp(s[a])) {
+                ++a;
+            }
+            while (b > a && issp(s[b - 1])) {
+                --b;
+            }
             if (b > a) {
-                std::string text(" "); text.append(s.data() + a, b - a);
-                for (size_t i = 0; i + 1 < text.size(); ) {
-                    if (text[i] == '<' && text[i+1] == '|') {
+                std::string text(" ");
+                text.append(s.data() + a, b - a);
+                for (size_t i = 0; i + 1 < text.size();) {
+                    if (text[i] == '<' && text[i + 1] == '|') {
                         const size_t end = text.find("|>", i + 2);
                         if (end != std::string::npos) {
                             std::string piece = text.substr(i, end + 2 - i);
-                            if (cm->tok.find(piece) >= eos_id)
+                            if (cm->tok.find(piece) >= eos_id) {
                                 return whisper_run_batch_serial(cc, pcm, n_samples, n, params);
-                            i = end + 2; continue;
+                            }
+                            i = end + 2;
+                            continue;
                         }
                     }
                     ++i;
                 }
-                if (cm->tok.encode(text, ptext) != TRANSCRIBE_OK)
+                if (cm->tok.encode(text, ptext) != TRANSCRIBE_OK) {
                     return whisper_run_batch_serial(cc, pcm, n_samples, n, params);
-                for (int32_t id : ptext)
-                    if (id >= eos_id)
+                }
+                for (int32_t id : ptext) {
+                    if (id >= eos_id) {
                         return whisper_run_batch_serial(cc, pcm, n_samples, n, params);
+                    }
+                }
             }
         }
-        if (static_cast<int>(ptext.size()) > max_prev_cap)
+        if (static_cast<int>(ptext.size()) > max_prev_cap) {
             ptext.erase(ptext.begin(), ptext.end() - max_prev_cap);
+        }
         if (!ptext.empty()) {
             prev_tokens.push_back(prev_sot_id);
             prev_tokens.insert(prev_tokens.end(), ptext.begin(), ptext.end());
@@ -2879,142 +2644,189 @@ transcribe_status whisper_run_batch(
     std::vector<float> temperatures;
     temperatures.push_back(wp->temperature);
     if (wp->temperature_inc > 0.0f) {
-        for (float T = wp->temperature + wp->temperature_inc;
-             T <= 1.0f + 1e-4f; T += wp->temperature_inc)
+        for (float T = wp->temperature + wp->temperature_inc; T <= 1.0f + 1e-4f; T += wp->temperature_inc) {
             temperatures.push_back(T);
+        }
     }
     const int max_initial_timestamp_index =
-        (std::isfinite(wp->max_initial_timestamp) && wp->max_initial_timestamp >= 0.0f)
-            ? static_cast<int>(std::floor(
-                  static_cast<double>(wp->max_initial_timestamp) / 0.02))
-            : -1;
+        (std::isfinite(wp->max_initial_timestamp) && wp->max_initial_timestamp >= 0.0f) ?
+            static_cast<int>(std::floor(static_cast<double>(wp->max_initial_timestamp) / 0.02)) :
+            -1;
 
     // Per-utterance result slots, filled in input order, pushed at the end.
     std::vector<transcribe_session::ResultSet> results(static_cast<size_t>(n));
-    std::vector<char> have_result(static_cast<size_t>(n), 0);
-    std::vector<char> needs_serial(static_cast<size_t>(n), 0);
+    std::vector<char>                          have_result(static_cast<size_t>(n), 0);
+    std::vector<char>                          needs_serial(static_cast<size_t>(n), 0);
 
     // ---- Pass 0: classify + parallel mel for batchable (short-form) inputs. ----
-    std::vector<char> valid(static_cast<size_t>(n), 0);
+    std::vector<char>               valid(static_cast<size_t>(n), 0);
     std::vector<std::vector<float>> mel_chunks(static_cast<size_t>(n));  // [frames, n_mels]
     for (int b = 0; b < n; ++b) {
         if (pcm[b] == nullptr || n_samples[b] <= 0) {
-            results[b].status = TRANSCRIBE_ERR_INVALID_ARG; have_result[b] = 1; continue;
+            results[b].status = TRANSCRIBE_ERR_INVALID_ARG;
+            have_result[b]    = 1;
+            continue;
+        }
+        if (n_samples[b] > n_samples_per_chunk) {
+            needs_serial[b] = 1;
+            continue;
         }
-        if (n_samples[b] > n_samples_per_chunk) { needs_serial[b] = 1; continue; }
         valid[b] = 1;
     }
     int n_threads = cc->n_threads;
-    if (n_threads <= 0) n_threads = transcribe::default_n_threads();
-    int64_t mel_us = 0, enc_us = 0, dec_us = 0;
+    if (n_threads <= 0) {
+        n_threads = transcribe::default_n_threads();
+    }
+    int64_t       mel_us = 0, enc_us = 0, dec_us = 0;
     const int64_t t_mel0 = ggml_time_us();
     transcribe::parallel_for_all(n, n_threads, [&](int b) {
-        if (!valid[b]) return true;
+        if (!valid[b]) {
+            return true;
+        }
         std::vector<float> pcm_work(static_cast<size_t>(n_samples_per_chunk), 0.0f);
-        const int n_copy = std::min(n_samples[b], n_samples_per_chunk);
+        const int          n_copy = std::min(n_samples[b], n_samples_per_chunk);
         std::memcpy(pcm_work.data(), pcm[b], static_cast<size_t>(n_copy) * sizeof(float));
-        std::vector<float> mel_mn; int nm = 0, nf = 0;
+        std::vector<float> mel_mn;
+        int                nm = 0, nf = 0;
         if (cm->mel->compute(pcm_work.data(), pcm_work.size(), mel_mn, nm, nf,
-                             /*n_threads=*/1) != TRANSCRIBE_OK || nm != n_mels || nf <= 0)
-        { valid[b] = 0; return true; }
+                             /*n_threads=*/1) != TRANSCRIBE_OK ||
+            nm != n_mels || nf <= 0) {
+            valid[b] = 0;
+            return true;
+        }
         std::vector<float> & chunk = mel_chunks[b];
         chunk.assign(static_cast<size_t>(nm) * nf, 0.0f);
-        for (int t = 0; t < nf; ++t)
-            for (int m = 0; m < nm; ++m)
+        for (int t = 0; t < nf; ++t) {
+            for (int m = 0; m < nm; ++m) {
                 chunk[static_cast<size_t>(t) * nm + m] = mel_mn[static_cast<size_t>(m) * nf + t];
+            }
+        }
         return true;
     });
     mel_us += ggml_time_us() - t_mel0;
-    for (int b = 0; b < n; ++b)
-        if (!needs_serial[b] && !have_result[b] && !valid[b]) needs_serial[b] = 1;
+    for (int b = 0; b < n; ++b) {
+        if (!needs_serial[b] && !have_result[b] && !valid[b]) {
+            needs_serial[b] = 1;
+        }
+    }
 
     // ---- Pass 1: serial per-utterance encoder + (optional) lang detect + prompt. ----
-    std::vector<std::vector<float>> enc_hosts(static_cast<size_t>(n));
-    std::vector<int> T_enc(static_cast<size_t>(n), 0);
+    std::vector<std::vector<float>>   enc_hosts(static_cast<size_t>(n));
+    std::vector<int>                  T_enc(static_cast<size_t>(n), 0);
     std::vector<std::vector<int32_t>> prompts(static_cast<size_t>(n));
-    std::vector<std::string> det_lang(static_cast<size_t>(n));
-    int T_enc_max = 0;
+    std::vector<std::string>          det_lang(static_cast<size_t>(n));
+    int                               T_enc_max = 0;
     for (int b = 0; b < n; ++b) {
-        if (!valid[b]) continue;
-        if (cc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
-        int T_enc_local = 0;
-        const int64_t t_e0 = ggml_time_us();
-        if (run_whisper_encoder_on_window(cc, cm, mel_chunks[b].data(), n_mels,
-                                          n_mel_frames_per_chunk,
-                                          /*allow_dumps=*/false, T_enc_local) != TRANSCRIBE_OK
-            || T_enc_local <= 0)
-        { valid[b] = 0; needs_serial[b] = 1; continue; }
+        if (!valid[b]) {
+            continue;
+        }
+        if (cc->poll_abort()) {
+            return TRANSCRIBE_ERR_ABORTED;
+        }
+        int           T_enc_local = 0;
+        const int64_t t_e0        = ggml_time_us();
+        if (run_whisper_encoder_on_window(cc, cm, mel_chunks[b].data(), n_mels, n_mel_frames_per_chunk,
+                                          /*allow_dumps=*/false, T_enc_local) != TRANSCRIBE_OK ||
+            T_enc_local <= 0) {
+            valid[b]        = 0;
+            needs_serial[b] = 1;
+            continue;
+        }
         enc_us += ggml_time_us() - t_e0;
 
         const int d_enc = cc->enc_out.d_model;
         enc_hosts[b].resize(static_cast<size_t>(d_enc) * T_enc_local);
-        ggml_backend_tensor_get(cc->enc_out.tensor, enc_hosts[b].data(), 0,
-                                enc_hosts[b].size() * sizeof(float));
-        T_enc[b] = T_enc_local;
+        ggml_backend_tensor_get(cc->enc_out.tensor, enc_hosts[b].data(), 0, enc_hosts[b].size() * sizeof(float));
+        T_enc[b]  = T_enc_local;
         T_enc_max = std::max(T_enc_max, T_enc_local);
 
         int32_t lang_token = lang_hint;
         if (is_multilingual && lang_token < 0 && !cm->lang_token_ids.empty()) {
             cc->enc_host.resize(enc_hosts[b].size());
-            std::memcpy(cc->enc_host.data(), enc_hosts[b].data(),
-                        enc_hosts[b].size() * sizeof(float));
-            if (!ensure_compute_ctx(cc, 16 * 1024 * 1024)) return TRANSCRIBE_ERR_GGUF;
-            DecoderBuild det = build_decoder_prefill_graph(
-                cc->compute_ctx, cm->weights, hp, /*seq_len=*/1, T_enc_local,
-                cc->decoder_use_flash);
-            if (det.out == nullptr || det.graph == nullptr) return TRANSCRIBE_ERR_GGUF;
+            std::memcpy(cc->enc_host.data(), enc_hosts[b].data(), enc_hosts[b].size() * sizeof(float));
+            if (!ensure_compute_ctx(cc, 16 * 1024 * 1024)) {
+                return TRANSCRIBE_ERR_GGUF;
+            }
+            DecoderBuild det = build_decoder_prefill_graph(cc->compute_ctx, cm->weights, hp, /*seq_len=*/1, T_enc_local,
+                                                           cc->decoder_use_flash);
+            if (det.out == nullptr || det.graph == nullptr) {
+                return TRANSCRIBE_ERR_GGUF;
+            }
             ggml_backend_sched_reset(cc->sched);
-            if (!ggml_backend_sched_alloc_graph(cc->sched, det.graph)) return TRANSCRIBE_ERR_GGUF;
+            if (!ggml_backend_sched_alloc_graph(cc->sched, det.graph)) {
+                return TRANSCRIBE_ERR_GGUF;
+            }
             const int32_t sot = hp.decoder_start_token_id;
             ggml_backend_tensor_set(det.token_ids_in, &sot, 0, sizeof(int32_t));
-            ggml_backend_tensor_set(det.encoder_out_in, cc->enc_host.data(), 0,
-                                    cc->enc_host.size() * sizeof(float));
+            ggml_backend_tensor_set(det.encoder_out_in, cc->enc_host.data(), 0, cc->enc_host.size() * sizeof(float));
             if (det.causal_mask_in != nullptr) {
                 const float zero = 0.0f;
                 ggml_backend_tensor_set(det.causal_mask_in, &zero, 0, sizeof(float));
             }
-            if (ggml_backend_sched_graph_compute(cc->sched, det.graph) != GGML_STATUS_SUCCESS)
+            if (ggml_backend_sched_graph_compute(cc->sched, det.graph) != GGML_STATUS_SUCCESS) {
                 return TRANSCRIBE_ERR_GGUF;
+            }
             std::vector<float> ll(static_cast<size_t>(vocab_size));
             ggml_backend_tensor_get(det.dumps.logits_raw, ll.data(), 0,
                                     static_cast<size_t>(vocab_size) * sizeof(float));
-            float best = -INFINITY; int best_idx = -1;
+            float best     = -INFINITY;
+            int   best_idx = -1;
             for (size_t i = 0; i < cm->lang_token_ids.size(); ++i) {
                 const int32_t id = cm->lang_token_ids[i];
-                if (id >= 0 && id < static_cast<int>(vocab_size) &&
-                    ll[static_cast<size_t>(id)] > best)
-                { best = ll[static_cast<size_t>(id)]; lang_token = id; best_idx = static_cast<int>(i); }
+                if (id >= 0 && id < static_cast<int>(vocab_size) && ll[static_cast<size_t>(id)] > best) {
+                    best       = ll[static_cast<size_t>(id)];
+                    lang_token = id;
+                    best_idx   = static_cast<int>(i);
+                }
             }
-            if (best_idx >= 0 && static_cast<size_t>(best_idx) < cm->lang_codes.size())
+            if (best_idx >= 0 && static_cast<size_t>(best_idx) < cm->lang_codes.size()) {
                 det_lang[b] = cm->lang_codes[static_cast<size_t>(best_idx)];
+            }
+        }
+        if (is_multilingual && lang_token < 0) {
+            valid[b]        = 0;
+            needs_serial[b] = 1;
+            continue;
         }
-        if (is_multilingual && lang_token < 0) { valid[b] = 0; needs_serial[b] = 1; continue; }
 
         // Per-utterance prompt: prev_tokens + SOT [lang task] [notimestamps?].
         std::vector<int32_t> & pr = prompts[b];
-        pr = prev_tokens;
+        pr                        = prev_tokens;
         pr.push_back(hp.decoder_start_token_id);
-        if (is_multilingual) { pr.push_back(lang_token); pr.push_back(task_token); }
-        if (!want_ts) pr.push_back(hp.no_timestamps_token_id);
+        if (is_multilingual) {
+            pr.push_back(lang_token);
+            pr.push_back(task_token);
+        }
+        if (!want_ts) {
+            pr.push_back(hp.no_timestamps_token_id);
+        }
     }
 
     int prompt_len = -1, n_batch_active = 0;
     for (int b = 0; b < n; ++b) {
-        if (!valid[b]) continue;
-        if (prompt_len < 0) prompt_len = static_cast<int>(prompts[b].size());
+        if (!valid[b]) {
+            continue;
+        }
+        if (prompt_len < 0) {
+            prompt_len = static_cast<int>(prompts[b].size());
+        }
         ++n_batch_active;
     }
     if (n_batch_active == 0 || T_enc_max <= 0) {
         for (int b = 0; b < n; ++b) {
-            if (have_result[b]) continue;
-            const transcribe_status st =
-                (pcm[b] == nullptr || n_samples[b] <= 0) ? TRANSCRIBE_ERR_INVALID_ARG
-                                                         : whisper_run(cc, pcm[b], n_samples[b], params);
-            results[b] = (st == TRANSCRIBE_OK) ? cc->capture_result(st)
-                                               : transcribe_session::ResultSet{};
-            results[b].status = st; have_result[b] = 1;
-        }
-        for (int b = 0; b < n; ++b) cc->batch_results.push_back(std::move(results[b]));
+            if (have_result[b]) {
+                continue;
+            }
+            const transcribe_status st = (pcm[b] == nullptr || n_samples[b] <= 0) ?
+                                             TRANSCRIBE_ERR_INVALID_ARG :
+                                             whisper_run(cc, pcm[b], n_samples[b], params);
+            results[b]        = (st == TRANSCRIBE_OK) ? cc->capture_result(st) : transcribe_session::ResultSet{};
+            results[b].status = st;
+            have_result[b]    = 1;
+        }
+        for (int b = 0; b < n; ++b) {
+            cc->batch_results.push_back(std::move(results[b]));
+        }
         return TRANSCRIBE_OK;
     }
 
@@ -3022,38 +2834,53 @@ transcribe_status whisper_run_batch(
 
     // ---- Allocate the batched KV cache. ----
     int max_n_kv = 256;
-    while (max_n_kv < prompt_len + k_max_new) max_n_kv *= 2;
-    if (max_n_kv > n_ctx_decoder) max_n_kv = n_ctx_decoder;
+    while (max_n_kv < prompt_len + k_max_new) {
+        max_n_kv *= 2;
+    }
+    if (max_n_kv > n_ctx_decoder) {
+        max_n_kv = n_ctx_decoder;
+    }
 
     ggml_type kv_type_g;
-    if (cc->kv_type == TRANSCRIBE_KV_TYPE_F32) kv_type_g = GGML_TYPE_F32;
-    else if (cc->kv_type == TRANSCRIBE_KV_TYPE_F16) kv_type_g = GGML_TYPE_F16;
-    else {
-        const ggml_tensor * probe = !cm->weights.dec_blocks.empty()
-            ? cm->weights.dec_blocks[0].self_q_w : nullptr;
-        kv_type_g = (probe != nullptr && probe->type == GGML_TYPE_F32)
-                        ? GGML_TYPE_F32 : GGML_TYPE_F16;
+    if (cc->kv_type == TRANSCRIBE_KV_TYPE_F32) {
+        kv_type_g = GGML_TYPE_F32;
+    } else if (cc->kv_type == TRANSCRIBE_KV_TYPE_F16) {
+        kv_type_g = GGML_TYPE_F16;
+    } else {
+        const ggml_tensor * probe = !cm->weights.dec_blocks.empty() ? cm->weights.dec_blocks[0].self_q_w : nullptr;
+        kv_type_g                 = (probe != nullptr && probe->type == GGML_TYPE_F32) ? GGML_TYPE_F32 : GGML_TYPE_F16;
     }
     if (cc->kv_cache.buffer != nullptr &&
-        (cc->kv_cache.n_batch != B || cc->kv_cache.T_enc != T_enc_max ||
-         cc->kv_cache.n_ctx != max_n_kv))
+        (cc->kv_cache.n_batch != B || cc->kv_cache.T_enc != T_enc_max || cc->kv_cache.n_ctx != max_n_kv)) {
         cc->kv_cache.free();
+    }
     if (cc->kv_cache.buffer == nullptr) {
-        if (!kv_cache_init_batched(cc->kv_cache, cm->plan.primary, max_n_kv,
-                                   T_enc_max, d_model, n_layer, B, kv_type_g))
-        { log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "whisper run_batch: kv_cache_init_batched failed");
-          return TRANSCRIBE_ERR_BACKEND; }
+        if (!kv_cache_init_batched(cc->kv_cache, cm->plan.primary, max_n_kv, T_enc_max, d_model, n_layer, B,
+                                   kv_type_g)) {
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "whisper run_batch: kv_cache_init_batched failed");
+            return TRANSCRIBE_ERR_BACKEND;
+        }
     } else {
         ggml_backend_buffer_clear(cc->kv_cache.buffer, 0);
-        cc->kv_cache.n = 0; cc->kv_cache.head = 0; cc->kv_cache.cross_populated = false;
+        cc->kv_cache.n               = 0;
+        cc->kv_cache.head            = 0;
+        cc->kv_cache.cross_populated = false;
     }
 
     auto new_compute_ctx = [&](size_t mem) -> bool {
-        if (cc->compute_ctx != nullptr) { ggml_free(cc->compute_ctx); cc->compute_ctx = nullptr; }
+        if (cc->compute_ctx != nullptr) {
+            ggml_free(cc->compute_ctx);
+            cc->compute_ctx = nullptr;
+        }
         cc->compute_ctx_size = 0;
-        ggml_init_params ip {}; ip.mem_size = mem; ip.mem_buffer = nullptr; ip.no_alloc = true;
+        ggml_init_params ip{};
+        ip.mem_size     = mem;
+        ip.mem_buffer   = nullptr;
+        ip.no_alloc     = true;
         cc->compute_ctx = ggml_init(ip);
-        if (cc->compute_ctx != nullptr) cc->compute_ctx_size = mem;
+        if (cc->compute_ctx != nullptr) {
+            cc->compute_ctx_size = mem;
+        }
         return cc->compute_ctx != nullptr;
     };
 
@@ -3061,23 +2888,29 @@ transcribe_status whisper_run_batch(
 
     // ---- Batched cross-attention K/V (tier-invariant; computed once). ----
     {
-        if (!new_compute_ctx(16 * 1024 * 1024)) return TRANSCRIBE_ERR_GGUF;
-        DecoderBuild cross = build_cross_kv_graph_batched(
-            cc->compute_ctx, cm->weights, hp, cc->kv_cache, T_enc_max, B);
-        if (cross.graph == nullptr) return TRANSCRIBE_ERR_GGUF;
+        if (!new_compute_ctx(16 * 1024 * 1024)) {
+            return TRANSCRIBE_ERR_GGUF;
+        }
+        DecoderBuild cross = build_cross_kv_graph_batched(cc->compute_ctx, cm->weights, hp, cc->kv_cache, T_enc_max, B);
+        if (cross.graph == nullptr) {
+            return TRANSCRIBE_ERR_GGUF;
+        }
         ggml_backend_sched_reset(cc->sched);
-        if (!ggml_backend_sched_alloc_graph(cc->sched, cross.graph)) return TRANSCRIBE_ERR_GGUF;
+        if (!ggml_backend_sched_alloc_graph(cc->sched, cross.graph)) {
+            return TRANSCRIBE_ERR_GGUF;
+        }
         std::vector<float> packed(static_cast<size_t>(d_model) * T_enc_max * B, 0.0f);
         for (int b = 0; b < n; ++b) {
-            if (!valid[b]) continue;
-            std::memcpy(packed.data() + static_cast<size_t>(b) * T_enc_max * d_model,
-                        enc_hosts[b].data(),
+            if (!valid[b]) {
+                continue;
+            }
+            std::memcpy(packed.data() + static_cast<size_t>(b) * T_enc_max * d_model, enc_hosts[b].data(),
                         static_cast<size_t>(d_model) * T_enc[b] * sizeof(float));
         }
-        ggml_backend_tensor_set(cross.encoder_out_in, packed.data(), 0,
-                                packed.size() * sizeof(float));
-        if (ggml_backend_sched_graph_compute(cc->sched, cross.graph) != GGML_STATUS_SUCCESS)
+        ggml_backend_tensor_set(cross.encoder_out_in, packed.data(), 0, packed.size() * sizeof(float));
+        if (ggml_backend_sched_graph_compute(cc->sched, cross.graph) != GGML_STATUS_SUCCESS) {
             return TRANSCRIBE_ERR_GGUF;
+        }
         cc->kv_cache.cross_populated = true;
     }
 
@@ -3087,46 +2920,58 @@ transcribe_status whisper_run_batch(
 
     std::vector<ggml_fp16_t> cmask(static_cast<size_t>(T_enc_max) * B, f16_ninf);
     for (int b = 0; b < n; ++b) {
-        const int real = valid[b] ? T_enc[b] : 1;
+        const int     real = valid[b] ? T_enc[b] : 1;
         ggml_fp16_t * base = cmask.data() + static_cast<size_t>(b) * T_enc_max;
         std::fill(base, base + std::min(real, T_enc_max), f16_zero);
     }
 
     int kv_window = 64;
-    while (kv_window > max_n_kv) kv_window /= 2;
-    if (kv_window < 1) kv_window = max_n_kv;
-
-    StepBuildBatched sb {};
-    auto rebuild_step = [&](int win) -> bool {
-        if (!new_compute_ctx(32 * 1024 * 1024)) return false;
-        sb = build_step_graph_batched(cc->compute_ctx, cm->weights, hp,
-                                      cc->kv_cache, win, T_enc_max, B, cc->decoder_use_flash);
-        if (sb.graph == nullptr || sb.logits_out == nullptr) return false;
+    while (kv_window > max_n_kv) {
+        kv_window /= 2;
+    }
+    if (kv_window < 1) {
+        kv_window = max_n_kv;
+    }
+
+    StepBuildBatched sb{};
+    auto             rebuild_step = [&](int win) -> bool {
+        if (!new_compute_ctx(32 * 1024 * 1024)) {
+            return false;
+        }
+        sb = build_step_graph_batched(cc->compute_ctx, cm->weights, hp, cc->kv_cache, win, T_enc_max, B,
+                                      cc->decoder_use_flash);
+        if (sb.graph == nullptr || sb.logits_out == nullptr) {
+            return false;
+        }
         ggml_backend_sched_reset(cc->sched);
-        if (!ggml_backend_sched_alloc_graph(cc->sched, sb.graph)) return false;
-        ggml_backend_tensor_set(sb.cross_mask_in, cmask.data(), 0,
-                                cmask.size() * sizeof(ggml_fp16_t));
+        if (!ggml_backend_sched_alloc_graph(cc->sched, sb.graph)) {
+            return false;
+        }
+        ggml_backend_tensor_set(sb.cross_mask_in, cmask.data(), 0, cmask.size() * sizeof(ggml_fp16_t));
         return true;
     };
-    if (!rebuild_step(kv_window)) return TRANSCRIBE_ERR_GGUF;
+    if (!rebuild_step(kv_window)) {
+        return TRANSCRIBE_ERR_GGUF;
+    }
 
     std::vector<ggml_fp16_t> smask(static_cast<size_t>(kv_window) * B, f16_ninf);
-    std::vector<int32_t> tok_buf(B, 0), pos_buf(B, 0);
-    std::vector<int64_t> kvidx_buf(B, 0);
-    std::vector<float>   logits_host(static_cast<size_t>(vocab_size) * B);
+    std::vector<int32_t>     tok_buf(B, 0), pos_buf(B, 0);
+    std::vector<int64_t>     kvidx_buf(B, 0);
+    std::vector<float>       logits_host(static_cast<size_t>(vocab_size) * B);
 
     auto run_step = [&](int posv) -> transcribe_status {
         for (int b = 0; b < n; ++b) {
-            pos_buf[b] = posv; kvidx_buf[b] = posv;
+            pos_buf[b]                                       = posv;
+            kvidx_buf[b]                                     = posv;
             smask[static_cast<size_t>(b) * kv_window + posv] = f16_zero;
         }
         ggml_backend_tensor_set(sb.token_ids_in, tok_buf.data(), 0, B * sizeof(int32_t));
-        ggml_backend_tensor_set(sb.pos_ids_in,  pos_buf.data(), 0, B * sizeof(int32_t));
-        ggml_backend_tensor_set(sb.kv_idx_in,   kvidx_buf.data(), 0, B * sizeof(int64_t));
-        ggml_backend_tensor_set(sb.self_mask_in, smask.data(), 0,
-                                smask.size() * sizeof(ggml_fp16_t));
-        if (ggml_backend_sched_graph_compute(cc->sched, sb.graph) != GGML_STATUS_SUCCESS)
+        ggml_backend_tensor_set(sb.pos_ids_in, pos_buf.data(), 0, B * sizeof(int32_t));
+        ggml_backend_tensor_set(sb.kv_idx_in, kvidx_buf.data(), 0, B * sizeof(int64_t));
+        ggml_backend_tensor_set(sb.self_mask_in, smask.data(), 0, smask.size() * sizeof(ggml_fp16_t));
+        if (ggml_backend_sched_graph_compute(cc->sched, sb.graph) != GGML_STATUS_SUCCESS) {
             return TRANSCRIBE_ERR_GGUF;
+        }
         return TRANSCRIBE_OK;
     };
     auto read_logits = [&]() {
@@ -3134,27 +2979,43 @@ transcribe_status whisper_run_batch(
                                 static_cast<size_t>(vocab_size) * B * sizeof(float));
     };
     auto ensure_window = [&](int posv) -> bool {
-        if (posv + 1 <= kv_window) return true;
+        if (posv + 1 <= kv_window) {
+            return true;
+        }
         int win = kv_window;
-        while (win < posv + 1 && win < max_n_kv) win *= 2;
-        if (win > max_n_kv) win = max_n_kv;
-        if (win == kv_window) return true;
+        while (win < posv + 1 && win < max_n_kv) {
+            win *= 2;
+        }
+        if (win > max_n_kv) {
+            win = max_n_kv;
+        }
+        if (win == kv_window) {
+            return true;
+        }
         std::vector<ggml_fp16_t> wider(static_cast<size_t>(win) * B, f16_ninf);
-        for (int b = 0; b < n; ++b)
-            std::fill(wider.data() + static_cast<size_t>(b) * win,
-                      wider.data() + static_cast<size_t>(b) * win + posv, f16_zero);
+        for (int b = 0; b < n; ++b) {
+            std::fill(wider.data() + static_cast<size_t>(b) * win, wider.data() + static_cast<size_t>(b) * win + posv,
+                      f16_zero);
+        }
         smask.swap(wider);
         kv_window = win;
         return rebuild_step(kv_window);
     };
 
     std::vector<float> lb(static_cast<size_t>(vocab_size));
-    auto suppress_row = [&](std::vector<float> & lg, bool begin) {
-        for (int32_t id : hp.suppress_tokens)
-            if (id >= 0 && id < vocab_size) lg[static_cast<size_t>(id)] = -INFINITY;
-        if (begin)
-            for (int32_t id : hp.begin_suppress_tokens)
-                if (id >= 0 && id < vocab_size) lg[static_cast<size_t>(id)] = -INFINITY;
+    auto               suppress_row = [&](std::vector<float> & lg, bool begin) {
+        for (int32_t id : hp.suppress_tokens) {
+            if (id >= 0 && id < vocab_size) {
+                lg[static_cast<size_t>(id)] = -INFINITY;
+            }
+        }
+        if (begin) {
+            for (int32_t id : hp.begin_suppress_tokens) {
+                if (id >= 0 && id < vocab_size) {
+                    lg[static_cast<size_t>(id)] = -INFINITY;
+                }
+            }
+        }
     };
     auto token_is_timestamp = [&](int id) {
         return id >= timestamp_begin && id < static_cast<int>(vocab_size);
@@ -3162,36 +3023,38 @@ transcribe_status whisper_run_batch(
 
     // Per-utterance working + accepted state.
     std::vector<std::vector<int32_t>> gen(static_cast<size_t>(n)), gen_text(static_cast<size_t>(n));
-    std::vector<double> sumlp(static_cast<size_t>(n), 0.0);
-    std::vector<int>    nlp(static_cast<size_t>(n), 0);
-    std::vector<char>   fin(static_cast<size_t>(n), 0), hit_eos(static_cast<size_t>(n), 0);
-    std::vector<int32_t> next_tok(static_cast<size_t>(n), 0);
-    std::vector<float>  ns_prob(static_cast<size_t>(n), 0.0f);
+    std::vector<double>               sumlp(static_cast<size_t>(n), 0.0);
+    std::vector<int>                  nlp(static_cast<size_t>(n), 0);
+    std::vector<char>                 fin(static_cast<size_t>(n), 0), hit_eos(static_cast<size_t>(n), 0);
+    std::vector<int32_t>              next_tok(static_cast<size_t>(n), 0);
+    std::vector<float>                ns_prob(static_cast<size_t>(n), 0.0f);
     std::vector<std::vector<int32_t>> acc_gen(static_cast<size_t>(n)), acc_gen_text(static_cast<size_t>(n));
-    std::vector<char>   acc_hit_eos(static_cast<size_t>(n), 0);
-    std::vector<char>   accepted_done(static_cast<size_t>(n), 0);
-    std::vector<std::mt19937> rng(static_cast<size_t>(n));
+    std::vector<char>                 acc_hit_eos(static_cast<size_t>(n), 0);
+    std::vector<char>                 accepted_done(static_cast<size_t>(n), 0);
+    std::vector<std::mt19937>         rng(static_cast<size_t>(n));
     {
         const uint32_t base_seed = wp->seed != 0 ? wp->seed : 0x5733B17Eu;
-        for (int b = 0; b < n; ++b)
+        for (int b = 0; b < n; ++b) {
             rng[b].seed(base_seed + static_cast<uint32_t>(b));
+        }
     }
 
     auto sample_one = [&](int b, float T, bool begin) -> int {
         const float * row = logits_host.data() + static_cast<size_t>(b) * vocab_size;
         std::memcpy(lb.data(), row, static_cast<size_t>(vocab_size) * sizeof(float));
         suppress_row(lb, begin);
-        apply_whisper_timestamp_rules(lb, gen[b], want_ts, hp.no_timestamps_token_id,
-                                      timestamp_begin, vocab_size, eos_id,
-                                      max_initial_timestamp_index);
-        float lp = 0.0f; int id;
+        apply_whisper_timestamp_rules(lb, gen[b], want_ts, hp.no_timestamps_token_id, timestamp_begin, vocab_size,
+                                      eos_id, max_initial_timestamp_index);
+        float lp = 0.0f;
+        int   id;
         if (T <= 0.0f) {
             id = sample_argmax_and_logprob(lb, &lp);
         } else {
             id = sample_from_logits(lb, T, rng[b], &cc->sample_scratch);
             lp = logprob_of_token_hf(lb, id, T);
         }
-        sumlp[b] += lp; nlp[b] += 1;
+        sumlp[b] += lp;
+        nlp[b] += 1;
         return id;
     };
 
@@ -3200,62 +3063,114 @@ transcribe_status whisper_run_batch(
     auto decode_tier = [&](float T, size_t ti) -> transcribe_status {
         std::fill(smask.begin(), smask.end(), f16_ninf);
         for (int b = 0; b < n; ++b) {
-            gen[b].clear(); gen_text[b].clear();
-            sumlp[b] = 0.0; nlp[b] = 0; hit_eos[b] = 0;
-            fin[b] = !valid[b]; next_tok[b] = 0;
+            gen[b].clear();
+            gen_text[b].clear();
+            sumlp[b]    = 0.0;
+            nlp[b]      = 0;
+            hit_eos[b]  = 0;
+            fin[b]      = !valid[b];
+            next_tok[b] = 0;
         }
         int pos = 0;
         for (; pos < prompt_len; ++pos) {
-            if (cc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
-            if (!ensure_window(pos)) return TRANSCRIBE_ERR_GGUF;
-            for (int b = 0; b < n; ++b) tok_buf[b] = valid[b] ? prompts[b][pos] : eos_id;
-            if (run_step(pos) != TRANSCRIBE_OK) return TRANSCRIBE_ERR_GGUF;
+            if (cc->poll_abort()) {
+                return TRANSCRIBE_ERR_ABORTED;
+            }
+            if (!ensure_window(pos)) {
+                return TRANSCRIBE_ERR_GGUF;
+            }
+            for (int b = 0; b < n; ++b) {
+                tok_buf[b] = valid[b] ? prompts[b][pos] : eos_id;
+            }
+            if (run_step(pos) != TRANSCRIBE_OK) {
+                return TRANSCRIBE_ERR_GGUF;
+            }
             if (ti == 0 && pos == sot_index && no_speech_token_id >= 0 &&
-                no_speech_token_id < static_cast<int>(vocab_size))
-            {
+                no_speech_token_id < static_cast<int>(vocab_size)) {
                 read_logits();
                 for (int b = 0; b < n; ++b) {
-                    if (!valid[b]) continue;
-                    const float * row = logits_host.data() + static_cast<size_t>(b) * vocab_size;
-                    float max_l = -INFINITY;
-                    for (int i = 0; i < vocab_size; ++i)
-                        if (std::isfinite(row[i]) && row[i] > max_l) max_l = row[i];
+                    if (!valid[b]) {
+                        continue;
+                    }
+                    const float * row   = logits_host.data() + static_cast<size_t>(b) * vocab_size;
+                    float         max_l = -INFINITY;
+                    for (int i = 0; i < vocab_size; ++i) {
+                        if (std::isfinite(row[i]) && row[i] > max_l) {
+                            max_l = row[i];
+                        }
+                    }
                     double sum = 0.0, ns = 0.0;
-                    if (std::isfinite(max_l))
-                        for (int i = 0; i < vocab_size; ++i)
+                    if (std::isfinite(max_l)) {
+                        for (int i = 0; i < vocab_size; ++i) {
                             if (std::isfinite(row[i])) {
                                 const double e = std::exp(static_cast<double>(row[i] - max_l));
-                                sum += e; if (i == no_speech_token_id) ns = e;
+                                sum += e;
+                                if (i == no_speech_token_id) {
+                                    ns = e;
+                                }
                             }
+                        }
+                    }
                     ns_prob[b] = (sum > 0.0) ? static_cast<float>(ns / sum) : 0.0f;
                 }
             }
         }
         read_logits();
         for (int b = 0; b < n; ++b) {
-            if (!valid[b]) continue;
+            if (!valid[b]) {
+                continue;
+            }
             const int id = sample_one(b, T, /*begin=*/true);
-            next_tok[b] = id;
-            if (id == eos_id) { fin[b] = 1; hit_eos[b] = 1; }
-            else { gen[b].push_back(id);
-                   if (!token_is_timestamp(id) && id >= 0 && id < 50257) gen_text[b].push_back(id); }
+            next_tok[b]  = id;
+            if (id == eos_id) {
+                fin[b]     = 1;
+                hit_eos[b] = 1;
+            } else {
+                gen[b].push_back(id);
+                if (!token_is_timestamp(id) && id >= 0 && id < 50257) {
+                    gen_text[b].push_back(id);
+                }
+            }
         }
         for (int produced = 1; produced < k_max_new; ++produced, ++pos) {
-            if (cc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
+            if (cc->poll_abort()) {
+                return TRANSCRIBE_ERR_ABORTED;
+            }
             bool all_done = true;
-            for (int b = 0; b < n; ++b) if (!fin[b]) { all_done = false; break; }
-            if (all_done || pos + 1 > max_n_kv) break;
-            if (!ensure_window(pos)) return TRANSCRIBE_ERR_GGUF;
-            for (int b = 0; b < n; ++b) tok_buf[b] = fin[b] ? eos_id : next_tok[b];
-            if (run_step(pos) != TRANSCRIBE_OK) return TRANSCRIBE_ERR_GGUF;
+            for (int b = 0; b < n; ++b) {
+                if (!fin[b]) {
+                    all_done = false;
+                    break;
+                }
+            }
+            if (all_done || pos + 1 > max_n_kv) {
+                break;
+            }
+            if (!ensure_window(pos)) {
+                return TRANSCRIBE_ERR_GGUF;
+            }
+            for (int b = 0; b < n; ++b) {
+                tok_buf[b] = fin[b] ? eos_id : next_tok[b];
+            }
+            if (run_step(pos) != TRANSCRIBE_OK) {
+                return TRANSCRIBE_ERR_GGUF;
+            }
             read_logits();
             for (int b = 0; b < n; ++b) {
-                if (fin[b]) continue;
+                if (fin[b]) {
+                    continue;
+                }
                 const int id = sample_one(b, T, /*begin=*/false);
-                next_tok[b] = id;
-                if (id == eos_id) { fin[b] = 1; hit_eos[b] = 1; }
-                else { gen[b].push_back(id);
-                       if (!token_is_timestamp(id) && id >= 0 && id < 50257) gen_text[b].push_back(id); }
+                next_tok[b]  = id;
+                if (id == eos_id) {
+                    fin[b]     = 1;
+                    hit_eos[b] = 1;
+                } else {
+                    gen[b].push_back(id);
+                    if (!token_is_timestamp(id) && id >= 0 && id < 50257) {
+                        gen_text[b].push_back(id);
+                    }
+                }
             }
         }
         return TRANSCRIBE_OK;
@@ -3263,56 +3178,80 @@ transcribe_status whisper_run_batch(
 
     // ---- Tier loop with batched fallback ladder. ----
     const int valid_count = std::max(1, n_batch_active);
-    auto trim_ws = [](std::string s) {
+    auto      trim_ws     = [](std::string s) {
         size_t a = 0, b = s.size();
-        auto sp = [](char c){ return c==' '||c=='\t'||c=='\n'||c=='\r'; };
-        while (a < b && sp(s[a])) ++a;
-        while (b > a && sp(s[b-1])) --b;
+        auto   sp = [](char c) {
+            return c == ' ' || c == '\t' || c == '\n' || c == '\r';
+        };
+        while (a < b && sp(s[a])) {
+            ++a;
+        }
+        while (b > a && sp(s[b - 1])) {
+            --b;
+        }
         return s.substr(a, b - a);
     };
-    auto finalize = [&](int b, const std::vector<int32_t> & g,
-                        const std::vector<int32_t> & gt) {
+    auto finalize = [&](int b, const std::vector<int32_t> & g, const std::vector<int32_t> & gt) {
         transcribe_session::ResultSet rs;
-        std::vector<int> tids(gt.begin(), gt.end());
-        std::string text = tids.empty() ? std::string()
-            : trim_ws(cm->tok.decode(tids.data(), static_cast<int>(tids.size())));
+        std::vector<int>              tids(gt.begin(), gt.end());
+        std::string                   text =
+            tids.empty() ? std::string() : trim_ws(cm->tok.decode(tids.data(), static_cast<int>(tids.size())));
         if (want_ts) {
-            WhisperSegmentResult sr = whisper_retrieve_segment(
-                g, cm->tok, /*time_offset_ms=*/0, seek_num_frames,
-                /*want_segment_timestamps=*/true, timestamp_begin, vocab_size);
-            rs.segments = std::move(sr.segments);
+            WhisperSegmentResult sr =
+                whisper_retrieve_segment(g, cm->tok, /*time_offset_ms=*/0, seek_num_frames,
+                                         /*want_segment_timestamps=*/true, timestamp_begin, vocab_size);
+            rs.segments    = std::move(sr.segments);
             rs.result_kind = TRANSCRIBE_TIMESTAMPS_SEGMENT;
         } else {
-            transcribe_session::SegmentEntry seg {}; seg.text = text;
+            transcribe_session::SegmentEntry seg{};
+            seg.text = text;
             rs.segments.push_back(std::move(seg));
             rs.result_kind = TRANSCRIBE_TIMESTAMPS_NONE;
         }
-        rs.full_text = text;
+        rs.full_text         = text;
         rs.detected_language = det_lang[b];
-        rs.has_result = true; rs.status = TRANSCRIBE_OK;
-        rs.t_mel_us = mel_us / valid_count;
-        rs.t_encode_us = enc_us / valid_count;
-        rs.t_decode_us = dec_us / valid_count;
-        results[b] = std::move(rs); have_result[b] = 1; accepted_done[b] = 1;
+        rs.has_result        = true;
+        rs.status            = TRANSCRIBE_OK;
+        rs.t_mel_us          = mel_us / valid_count;
+        rs.t_encode_us       = enc_us / valid_count;
+        rs.t_decode_us       = dec_us / valid_count;
+        results[b]           = std::move(rs);
+        have_result[b]       = 1;
+        accepted_done[b]     = 1;
     };
 
     for (size_t ti = 0; ti < temperatures.size(); ++ti) {
         bool any_active = false;
-        for (int b = 0; b < n; ++b) if (valid[b] && !accepted_done[b]) { any_active = true; break; }
-        if (!any_active) break;
+        for (int b = 0; b < n; ++b) {
+            if (valid[b] && !accepted_done[b]) {
+                any_active = true;
+                break;
+            }
+        }
+        if (!any_active) {
+            break;
+        }
 
         const transcribe_status st = decode_tier(temperatures[ti], ti);
-        if (st != TRANSCRIBE_OK) return st;
+        if (st != TRANSCRIBE_OK) {
+            return st;
+        }
 
         for (int b = 0; b < n; ++b) {
-            if (!valid[b] || accepted_done[b]) continue;
+            if (!valid[b] || accepted_done[b]) {
+                continue;
+            }
             std::vector<int32_t> comp_tail = gen[b];
-            if (hit_eos[b]) comp_tail.push_back(static_cast<int32_t>(eos_id));
+            if (hit_eos[b]) {
+                comp_tail.push_back(static_cast<int32_t>(eos_id));
+            }
             const float comp_ratio = compute_compression_ratio_hf(comp_tail, vocab_size);
-            const float avg_lp = nlp[b] > 0 ? static_cast<float>(sumlp[b] / nlp[b])
-                                            : -std::numeric_limits<float>::infinity();
+            const float avg_lp =
+                nlp[b] > 0 ? static_cast<float>(sumlp[b] / nlp[b]) : -std::numeric_limits<float>::infinity();
             // Record this tier's output (last tier wins if none accepts).
-            acc_gen[b] = gen[b]; acc_gen_text[b] = gen_text[b]; acc_hit_eos[b] = hit_eos[b];
+            acc_gen[b]      = gen[b];
+            acc_gen_text[b] = gen_text[b];
+            acc_hit_eos[b]  = hit_eos[b];
 
             const bool comp_ok = comp_ratio <= wp->compression_ratio_thold;
             const bool lp_ok   = avg_lp >= wp->logprob_thold;
@@ -3327,38 +3266,55 @@ transcribe_status whisper_run_batch(
     }
     // Tiers exhausted: keep the last-tier output for anyone still unaccepted.
     for (int b = 0; b < n; ++b) {
-        if (!valid[b] || accepted_done[b]) continue;
+        if (!valid[b] || accepted_done[b]) {
+            continue;
+        }
         finalize(b, acc_gen[b], acc_gen_text[b]);
     }
     dec_us += ggml_time_us() - t_dec0;
     // Patch decode timings now that dec_us is known (finalize ran earlier).
-    for (int b = 0; b < n; ++b)
-        if (valid[b]) results[b].t_decode_us = dec_us / valid_count;
+    for (int b = 0; b < n; ++b) {
+        if (valid[b]) {
+            results[b].t_decode_us = dec_us / valid_count;
+        }
+    }
 
     // ---- Serial fallback for long-form / mel-failed / invalid-encode. ----
     for (int b = 0; b < n; ++b) {
-        if (have_result[b] || !needs_serial[b]) continue;
-        if (cc->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
-        const transcribe_status st =
-            (pcm[b] == nullptr || n_samples[b] <= 0) ? TRANSCRIBE_ERR_INVALID_ARG
-                                                     : whisper_run(cc, pcm[b], n_samples[b], params);
-        if (st == TRANSCRIBE_OK) results[b] = cc->capture_result(st);
-        else { results[b] = transcribe_session::ResultSet{}; results[b].status = st; }
+        if (have_result[b] || !needs_serial[b]) {
+            continue;
+        }
+        if (cc->poll_abort()) {
+            return TRANSCRIBE_ERR_ABORTED;
+        }
+        const transcribe_status st = (pcm[b] == nullptr || n_samples[b] <= 0) ?
+                                         TRANSCRIBE_ERR_INVALID_ARG :
+                                         whisper_run(cc, pcm[b], n_samples[b], params);
+        if (st == TRANSCRIBE_OK) {
+            results[b] = cc->capture_result(st);
+        } else {
+            results[b]        = transcribe_session::ResultSet{};
+            results[b].status = st;
+        }
         have_result[b] = 1;
     }
 
     if (transcribe::env::flag("TRANSCRIBE_PERF_DEBUG")) {
-        int n_serial = 0; for (int b = 0; b < n; ++b) n_serial += needs_serial[b] ? 1 : 0;
+        int n_serial = 0;
+        for (int b = 0; b < n; ++b) {
+            n_serial += needs_serial[b] ? 1 : 0;
+        }
         log_msg(TRANSCRIBE_LOG_LEVEL_DEBUG,
-            "whisper run_batch: n=%d batched=%d serial=%d tiers=%d want_ts=%d "
-            "T_enc_max=%d kv_window=%d (cap %d) prompt=%d\n"
-            "  mel=%.1fms (parallel)  enc=%.1fms (serial x%d)  decode=%.1fms (batched)",
-            n, n_batch_active, n_serial, static_cast<int>(temperatures.size()),
-            want_ts ? 1 : 0, T_enc_max, kv_window, max_n_kv, prompt_len,
-            mel_us / 1000.0, enc_us / 1000.0, n_batch_active, dec_us / 1000.0);
+                "whisper run_batch: n=%d batched=%d serial=%d tiers=%d want_ts=%d "
+                "T_enc_max=%d kv_window=%d (cap %d) prompt=%d\n"
+                "  mel=%.1fms (parallel)  enc=%.1fms (serial x%d)  decode=%.1fms (batched)",
+                n, n_batch_active, n_serial, static_cast<int>(temperatures.size()), want_ts ? 1 : 0, T_enc_max,
+                kv_window, max_n_kv, prompt_len, mel_us / 1000.0, enc_us / 1000.0, n_batch_active, dec_us / 1000.0);
     }
 
-    for (int b = 0; b < n; ++b) cc->batch_results.push_back(std::move(results[b]));
+    for (int b = 0; b < n; ++b) {
+        cc->batch_results.push_back(std::move(results[b]));
+    }
     return TRANSCRIBE_OK;
 }
 
@@ -3366,13 +3322,11 @@ transcribe_status whisper_run_batch(
 // has no streaming surface, so the _STREAM slot is always false and the
 // _RUN slot accepts only WHISPER_RUN. There is currently no whisper
 // variant that ships without the run-ext surface.
-static bool whisper_accepts_ext_kind(
-    const transcribe_model * model,
-    transcribe_ext_slot      slot,
-    uint32_t                 kind)
-{
+static bool whisper_accepts_ext_kind(const transcribe_model * model, transcribe_ext_slot slot, uint32_t kind) {
     (void) model;
-    if (slot != TRANSCRIBE_EXT_SLOT_RUN) return false;
+    if (slot != TRANSCRIBE_EXT_SLOT_RUN) {
+        return false;
+    }
     return kind == TRANSCRIBE_EXT_KIND_WHISPER_RUN;
 }
 
@@ -3387,18 +3341,13 @@ static bool whisper_accepts_ext_kind(
 // disallowed specials in initial_prompt) live in whisper_run() and reject after
 // the snapshot is cleared — an accepted gap, since run() is one-shot with no
 // accumulating transcript to protect.
-static transcribe_status whisper_run_validate(
-    const transcribe_session *   ctx,
-    const transcribe_run_params * params)
-{
+static transcribe_status whisper_run_validate(const transcribe_session * ctx, const transcribe_run_params * params) {
     (void) ctx;
-    return transcribe_ext_check(
-        params != nullptr ? params->family : nullptr,
-        TRANSCRIBE_EXT_KIND_WHISPER_RUN,
-        sizeof(struct transcribe_whisper_run_ext));
+    return transcribe_ext_check(params != nullptr ? params->family : nullptr, TRANSCRIBE_EXT_KIND_WHISPER_RUN,
+                                sizeof(struct transcribe_whisper_run_ext));
 }
 
-} // namespace
+}  // namespace
 
 extern const Arch arch = {
     /* .name             = */ "whisper",
@@ -3415,4 +3364,4 @@ extern const Arch arch = {
     /* .run_validate     = */ whisper_run_validate,
 };
 
-} // namespace transcribe::whisper
+}  // namespace transcribe::whisper
diff --git a/src/arch/whisper/public.cpp b/src/arch/whisper/public.cpp
index 36d71ce6..505fd03d 100644
--- a/src/arch/whisper/public.cpp
+++ b/src/arch/whisper/public.cpp
@@ -5,11 +5,10 @@
 // agnostic (matching parakeet/moonshine). Public ABI from
 // include/transcribe/whisper.h.
 
-#include "whisper.h"            // WhisperSession (+ transcribe/whisper.h, transcribe-session.h)
-
-#include "transcribe-abi.h"     // check_struct_size, copy_out_prefix
-#include "transcribe-arch.h"    // Arch (session->model->arch)
-#include "transcribe-model.h"   // transcribe_model (session->model)
+#include "transcribe-abi.h"    // check_struct_size, copy_out_prefix
+#include "transcribe-arch.h"   // Arch (session->model->arch)
+#include "transcribe-model.h"  // transcribe_model (session->model)
+#include "whisper.h"           // WhisperSession (+ transcribe/whisper.h, transcribe-session.h)
 
 #include <cstddef>
 #include <cstring>
@@ -21,20 +20,23 @@ namespace {
 
 // The library relies on the prefix up to and including n_fallbacks (the
 // last field). Matches the central dispatcher's TRANSCRIBE_FIELD_END rule.
-constexpr size_t k_min_whisper_chunk_trace_size =
-    offsetof(struct transcribe_whisper_chunk_trace, n_fallbacks) +
-    sizeof(((struct transcribe_whisper_chunk_trace *) 0)->n_fallbacks);
+constexpr size_t k_min_whisper_chunk_trace_size = offsetof(struct transcribe_whisper_chunk_trace, n_fallbacks) +
+                                                  sizeof(((struct transcribe_whisper_chunk_trace *) 0)->n_fallbacks);
 
 // Whisper-specific decoding trace storage lives on WhisperSession; we
 // downcast via the model's arch name rather than RTTI so non-RTTI builds
 // keep working. Non-Whisper sessions and out-of-range indices are defined
 // as zeroed/empty returns.
-const transcribe::whisper::WhisperSession *
-maybe_whisper_context(const struct transcribe_session * session)
-{
-    if (session == nullptr) return nullptr;
-    if (session->model == nullptr) return nullptr;
-    if (session->model->arch == nullptr) return nullptr;
+const transcribe::whisper::WhisperSession * maybe_whisper_context(const struct transcribe_session * session) {
+    if (session == nullptr) {
+        return nullptr;
+    }
+    if (session->model == nullptr) {
+        return nullptr;
+    }
+    if (session->model->arch == nullptr) {
+        return nullptr;
+    }
     const char * name = session->model->arch->name;
     if (name == nullptr || std::strcmp(name, "whisper") != 0) {
         return nullptr;
@@ -42,20 +44,24 @@ maybe_whisper_context(const struct transcribe_session * session)
     return static_cast<const transcribe::whisper::WhisperSession *>(session);
 }
 
-} // namespace
+}  // namespace
 
 // Init functions (single source of truth for Whisper struct defaults).
 extern "C" void transcribe_whisper_chunk_trace_init(struct transcribe_whisper_chunk_trace * p) {
-    if (p == nullptr) { return; }
+    if (p == nullptr) {
+        return;
+    }
     std::memset(p, 0, sizeof(*p));
     p->struct_size = sizeof(*p);
 }
 
 extern "C" void transcribe_whisper_run_ext_init(struct transcribe_whisper_run_ext * p) {
-    if (p == nullptr) { return; }
+    if (p == nullptr) {
+        return;
+    }
     std::memset(p, 0, sizeof(*p));
-    p->ext.size = sizeof(*p);
-    p->ext.kind = TRANSCRIBE_EXT_KIND_WHISPER_RUN;
+    p->ext.size                = sizeof(*p);
+    p->ext.kind                = TRANSCRIBE_EXT_KIND_WHISPER_RUN;
     // Non-zero recipe defaults (zero-valued fields covered by memset:
     // initial_prompt/prompt_tokens NULL, n_prompt_tokens 0,
     // condition_on_prev_tokens false, temperature 0.0, seed 0).
@@ -69,28 +75,25 @@ extern "C" void transcribe_whisper_run_ext_init(struct transcribe_whisper_run_ex
 }
 
 // Chunk-trace accessors.
-extern "C" int transcribe_get_whisper_chunk_count(
-    const struct transcribe_session * session)
-{
+extern "C" int transcribe_get_whisper_chunk_count(const struct transcribe_session * session) {
     const auto * wc = maybe_whisper_context(session);
-    if (wc == nullptr) return 0;
+    if (wc == nullptr) {
+        return 0;
+    }
     return static_cast<int>(wc->chunk_traces.size());
 }
 
-extern "C" transcribe_status transcribe_get_whisper_chunk_trace(
-    const struct transcribe_session *       session,
-    int                                     i,
-    struct transcribe_whisper_chunk_trace * out_trace)
-{
+extern "C" transcribe_status transcribe_get_whisper_chunk_trace(const struct transcribe_session *       session,
+                                                                int                                     i,
+                                                                struct transcribe_whisper_chunk_trace * out_trace) {
     if (out_trace == nullptr) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
     if (const auto st = check_struct_size(out_trace->struct_size, k_min_whisper_chunk_trace_size);
-        st != TRANSCRIBE_OK)
-    {
+        st != TRANSCRIBE_OK) {
         return st;
     }
-    const uint64_t caller_size = out_trace->struct_size;
+    const uint64_t                 caller_size = out_trace->struct_size;
     transcribe_whisper_chunk_trace zero{};
     zero.struct_size = caller_size;
     copy_out_prefix(out_trace, &zero, caller_size, sizeof(zero));
@@ -102,7 +105,7 @@ extern "C" transcribe_status transcribe_get_whisper_chunk_trace(
         return TRANSCRIBE_OK;
     }
     transcribe_whisper_chunk_trace staged = wc->chunk_traces[static_cast<size_t>(i)];
-    staged.struct_size = caller_size;
+    staged.struct_size                    = caller_size;
     copy_out_prefix(out_trace, &staged, caller_size, sizeof(staged));
     return TRANSCRIBE_OK;
 }
diff --git a/src/arch/whisper/weights.cpp b/src/arch/whisper/weights.cpp
index 36d8de50..3f712357 100644
--- a/src/arch/whisper/weights.cpp
+++ b/src/arch/whisper/weights.cpp
@@ -10,12 +10,11 @@
 
 #include "weights.h"
 
-#include "transcribe-meta.h"
-#include "transcribe-weights-util.h"
-#include "transcribe-log.h"
-
 #include "ggml.h"
 #include "gguf.h"
+#include "transcribe-log.h"
+#include "transcribe-meta.h"
+#include "transcribe-weights-util.h"
 
 #include <cstdio>
 #include <cstring>
@@ -31,10 +30,9 @@ constexpr const char * kFamilyTag = "whisper";
 transcribe_status read_optional_u32_kv(const gguf_context * gguf,
                                        const char *         key,
                                        const char *         error_tag,
-                                       int32_t &            out)
-{
-    uint32_t value = 0;
-    const auto st = transcribe::read_uint32_kv(gguf, key, value);
+                                       int32_t &            out) {
+    uint32_t   value = 0;
+    const auto st    = transcribe::read_uint32_kv(gguf, key, value);
     if (st == transcribe::KvResult::Ok) {
         out = static_cast<int32_t>(value);
         return TRANSCRIBE_OK;
@@ -47,13 +45,12 @@ transcribe_status read_optional_u32_kv(const gguf_context * gguf,
 }
 
 // Optional int32 array KV. Absent leaves `out` untouched.
-transcribe_status read_optional_i32_array_kv(const gguf_context * gguf,
-                                             const char *         key,
-                                             const char *         error_tag,
-                                             std::vector<int32_t> & out)
-{
+transcribe_status read_optional_i32_array_kv(const gguf_context *   gguf,
+                                             const char *           key,
+                                             const char *           error_tag,
+                                             std::vector<int32_t> & out) {
     std::vector<int32_t> tmp;
-    const auto st = transcribe::read_int32_array_kv(gguf, key, tmp);
+    const auto           st = transcribe::read_int32_array_kv(gguf, key, tmp);
     if (st == transcribe::KvResult::Ok) {
         out = std::move(tmp);
         return TRANSCRIBE_OK;
@@ -61,8 +58,7 @@ transcribe_status read_optional_i32_array_kv(const gguf_context * gguf,
     if (st == transcribe::KvResult::Absent) {
         return TRANSCRIBE_OK;
     }
-    log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: KV %s has wrong type (expected int32 array)",
-                 error_tag, key);
+    log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: KV %s has wrong type (expected int32 array)", error_tag, key);
     return TRANSCRIBE_ERR_GGUF;
 }
 
@@ -71,10 +67,9 @@ transcribe_status read_optional_f32_kv(const gguf_context * gguf,
                                        const char *         key,
                                        const char *         error_tag,
                                        float                default_value,
-                                       float &              out)
-{
-    float value = default_value;
-    const auto st = transcribe::read_float32_kv(gguf, key, value);
+                                       float &              out) {
+    float      value = default_value;
+    const auto st    = transcribe::read_float32_kv(gguf, key, value);
     if (st == transcribe::KvResult::Ok) {
         out = value;
         return TRANSCRIBE_OK;
@@ -87,42 +82,112 @@ transcribe_status read_optional_f32_kv(const gguf_context * gguf,
     return TRANSCRIBE_ERR_GGUF;
 }
 
-} // namespace
+}  // namespace
 
-transcribe_status read_whisper_hparams(const gguf_context * gguf,
-                                       WhisperHParams &     hp)
-{
+transcribe_status read_whisper_hparams(const gguf_context * gguf, WhisperHParams & hp) {
     if (gguf == nullptr) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
 
     // Encoder.
-    if (auto st = read_required_u32_kv(gguf, "stt.whisper.encoder.n_layers",             kFamilyTag, hp.enc_n_layers);             st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.whisper.encoder.d_model",              kFamilyTag, hp.enc_d_model);              st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.whisper.encoder.n_heads",              kFamilyTag, hp.enc_n_heads);              st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.whisper.encoder.ffn_dim",              kFamilyTag, hp.enc_ffn_dim);              st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.whisper.encoder.num_mel_bins",         kFamilyTag, hp.enc_num_mel_bins);         st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.whisper.encoder.max_source_positions", kFamilyTag, hp.enc_max_source_positions); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.whisper.encoder.activation",        kFamilyTag, hp.enc_activation);           st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_u32_kv(gguf, "stt.whisper.encoder.n_layers", kFamilyTag, hp.enc_n_layers);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.whisper.encoder.d_model", kFamilyTag, hp.enc_d_model);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.whisper.encoder.n_heads", kFamilyTag, hp.enc_n_heads);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.whisper.encoder.ffn_dim", kFamilyTag, hp.enc_ffn_dim);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.whisper.encoder.num_mel_bins", kFamilyTag, hp.enc_num_mel_bins);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.whisper.encoder.max_source_positions", kFamilyTag,
+                                       hp.enc_max_source_positions);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_string_kv(gguf, "stt.whisper.encoder.activation", kFamilyTag, hp.enc_activation);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Decoder.
-    if (auto st = read_required_u32_kv(gguf, "stt.whisper.decoder.n_layers",             kFamilyTag, hp.dec_n_layers);             st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.whisper.decoder.d_model",              kFamilyTag, hp.dec_d_model);              st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.whisper.decoder.n_heads",              kFamilyTag, hp.dec_n_heads);              st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.whisper.decoder.ffn_dim",              kFamilyTag, hp.dec_ffn_dim);              st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.whisper.decoder.max_target_positions", kFamilyTag, hp.dec_max_target_positions); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.whisper.decoder.vocab_size",           kFamilyTag, hp.dec_vocab_size);           st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.whisper.decoder.activation",        kFamilyTag, hp.dec_activation);           st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_bool_kv(gguf, "stt.whisper.decoder.tie_word_embeddings", kFamilyTag, true, hp.dec_tie_word_embeddings); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_bool_kv(gguf, "stt.whisper.decoder.scale_embedding",     kFamilyTag, false, hp.dec_scale_embedding);   st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_u32_kv(gguf, "stt.whisper.decoder.n_layers", kFamilyTag, hp.dec_n_layers);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.whisper.decoder.d_model", kFamilyTag, hp.dec_d_model);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.whisper.decoder.n_heads", kFamilyTag, hp.dec_n_heads);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.whisper.decoder.ffn_dim", kFamilyTag, hp.dec_ffn_dim);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.whisper.decoder.max_target_positions", kFamilyTag,
+                                       hp.dec_max_target_positions);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.whisper.decoder.vocab_size", kFamilyTag, hp.dec_vocab_size);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_string_kv(gguf, "stt.whisper.decoder.activation", kFamilyTag, hp.dec_activation);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_bool_kv(gguf, "stt.whisper.decoder.tie_word_embeddings", kFamilyTag, true,
+                                        hp.dec_tie_word_embeddings);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_bool_kv(gguf, "stt.whisper.decoder.scale_embedding", kFamilyTag, false,
+                                        hp.dec_scale_embedding);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Whisper generation contract.
-    if (auto st = read_required_u32_kv(gguf, "stt.whisper.decoder_start_token_id", kFamilyTag, hp.decoder_start_token_id); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv(gguf, "stt.whisper.no_timestamps_token_id", kFamilyTag, hp.no_timestamps_token_id); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_u32_kv(gguf, "stt.whisper.sot_token_id",        kFamilyTag, hp.sot_token_id);        st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_u32_kv(gguf, "stt.whisper.transcribe_token_id", kFamilyTag, hp.transcribe_token_id); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_u32_kv(gguf, "stt.whisper.translate_token_id",  kFamilyTag, hp.translate_token_id);  st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_u32_kv(gguf, "stt.whisper.prev_sot_token_id",   kFamilyTag, hp.prev_sot_token_id);   st != TRANSCRIBE_OK) return st;
+    if (auto st =
+            read_required_u32_kv(gguf, "stt.whisper.decoder_start_token_id", kFamilyTag, hp.decoder_start_token_id);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st =
+            read_required_u32_kv(gguf, "stt.whisper.no_timestamps_token_id", kFamilyTag, hp.no_timestamps_token_id);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_u32_kv(gguf, "stt.whisper.sot_token_id", kFamilyTag, hp.sot_token_id);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_u32_kv(gguf, "stt.whisper.transcribe_token_id", kFamilyTag, hp.transcribe_token_id);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_u32_kv(gguf, "stt.whisper.translate_token_id", kFamilyTag, hp.translate_token_id);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_u32_kv(gguf, "stt.whisper.prev_sot_token_id", kFamilyTag, hp.prev_sot_token_id);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // sot falls back to decoder_start when unspecified — whisper-multilingual
     // uses the same id for both.
@@ -130,79 +195,140 @@ transcribe_status read_whisper_hparams(const gguf_context * gguf,
         hp.sot_token_id = hp.decoder_start_token_id;
     }
 
-    if (auto st = read_optional_i32_array_kv(gguf, "stt.whisper.suppress_tokens",       kFamilyTag, hp.suppress_tokens);       st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_i32_array_kv(gguf, "stt.whisper.begin_suppress_tokens", kFamilyTag, hp.begin_suppress_tokens); st != TRANSCRIBE_OK) return st;
+    if (auto st = read_optional_i32_array_kv(gguf, "stt.whisper.suppress_tokens", kFamilyTag, hp.suppress_tokens);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st =
+            read_optional_i32_array_kv(gguf, "stt.whisper.begin_suppress_tokens", kFamilyTag, hp.begin_suppress_tokens);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Frontend.
-    if (auto st = read_required_string_kv(gguf, "stt.frontend.type",        kFamilyTag, hp.fe_type);        st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv   (gguf, "stt.frontend.num_mels",    kFamilyTag, hp.fe_num_mels);    st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv   (gguf, "stt.frontend.sample_rate", kFamilyTag, hp.fe_sample_rate); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv   (gguf, "stt.frontend.n_fft",       kFamilyTag, hp.fe_n_fft);       st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv   (gguf, "stt.frontend.win_length",  kFamilyTag, hp.fe_win_length);  st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_u32_kv   (gguf, "stt.frontend.hop_length",  kFamilyTag, hp.fe_hop_length);  st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.frontend.window",      kFamilyTag, hp.fe_window);      st != TRANSCRIBE_OK) return st;
-    if (auto st = read_required_string_kv(gguf, "stt.frontend.normalize",   kFamilyTag, hp.fe_normalize);   st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_f32_kv   (gguf, "stt.frontend.dither",       kFamilyTag, 0.0f, hp.fe_dither);       st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_f32_kv   (gguf, "stt.frontend.pre_emphasis", kFamilyTag, 0.0f, hp.fe_pre_emphasis); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_f32_kv   (gguf, "stt.frontend.f_min",        kFamilyTag, 0.0f, hp.fe_f_min);        st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_f32_kv   (gguf, "stt.frontend.f_max",        kFamilyTag, 8000.0f, hp.fe_f_max);     st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_string_kv(gguf, "stt.frontend.pad_mode",     kFamilyTag, "reflect", hp.fe_pad_mode); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_bool_kv  (gguf, "stt.frontend.center",       kFamilyTag, true, hp.fe_center);        st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_string_kv(gguf, "stt.frontend.mel_norm",     kFamilyTag, "slaney", hp.fe_mel_norm);  st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_u32_kv   (gguf, "stt.frontend.chunk_length", kFamilyTag, hp.fe_chunk_length);        st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_u32_kv   (gguf, "stt.frontend.n_samples",    kFamilyTag, hp.fe_n_samples);           st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_u32_kv   (gguf, "stt.frontend.nb_max_frames", kFamilyTag, hp.fe_nb_max_frames);      st != TRANSCRIBE_OK) return st;
+    if (auto st = read_required_string_kv(gguf, "stt.frontend.type", kFamilyTag, hp.fe_type); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.num_mels", kFamilyTag, hp.fe_num_mels);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.sample_rate", kFamilyTag, hp.fe_sample_rate);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.n_fft", kFamilyTag, hp.fe_n_fft); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.win_length", kFamilyTag, hp.fe_win_length);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_u32_kv(gguf, "stt.frontend.hop_length", kFamilyTag, hp.fe_hop_length);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_string_kv(gguf, "stt.frontend.window", kFamilyTag, hp.fe_window); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_required_string_kv(gguf, "stt.frontend.normalize", kFamilyTag, hp.fe_normalize);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_f32_kv(gguf, "stt.frontend.dither", kFamilyTag, 0.0f, hp.fe_dither);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_f32_kv(gguf, "stt.frontend.pre_emphasis", kFamilyTag, 0.0f, hp.fe_pre_emphasis);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_f32_kv(gguf, "stt.frontend.f_min", kFamilyTag, 0.0f, hp.fe_f_min);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_f32_kv(gguf, "stt.frontend.f_max", kFamilyTag, 8000.0f, hp.fe_f_max);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_string_kv(gguf, "stt.frontend.pad_mode", kFamilyTag, "reflect", hp.fe_pad_mode);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_bool_kv(gguf, "stt.frontend.center", kFamilyTag, true, hp.fe_center);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_string_kv(gguf, "stt.frontend.mel_norm", kFamilyTag, "slaney", hp.fe_mel_norm);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_u32_kv(gguf, "stt.frontend.chunk_length", kFamilyTag, hp.fe_chunk_length);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_u32_kv(gguf, "stt.frontend.n_samples", kFamilyTag, hp.fe_n_samples);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_u32_kv(gguf, "stt.frontend.nb_max_frames", kFamilyTag, hp.fe_nb_max_frames);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Capability flags. stt.capability.* is ecosystem-wide; the shared
     // read_capability_kv() (called later in the load path) re-reads
     // these into the public transcribe_capabilities struct, but we also
     // cache them here for easy access in decoder logic (supports_translate
     // gates the <|translate|> token availability etc).
-    if (auto st = read_optional_bool_kv(gguf, "stt.capability.lang_detect", kFamilyTag, false, hp.cap_lang_detect); st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_bool_kv(gguf, "stt.capability.translate",   kFamilyTag, false, hp.cap_translate);   st != TRANSCRIBE_OK) return st;
-    if (auto st = read_optional_bool_kv(gguf, "stt.capability.timestamps",  kFamilyTag, false, hp.cap_timestamps);  st != TRANSCRIBE_OK) return st;
+    if (auto st = read_optional_bool_kv(gguf, "stt.capability.lang_detect", kFamilyTag, false, hp.cap_lang_detect);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_bool_kv(gguf, "stt.capability.translate", kFamilyTag, false, hp.cap_translate);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_optional_bool_kv(gguf, "stt.capability.timestamps", kFamilyTag, false, hp.cap_timestamps);
+        st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     // Cross-field invariants.
-    if (hp.enc_n_layers <= 0 || hp.enc_d_model <= 0 || hp.enc_n_heads <= 0 ||
-        hp.enc_ffn_dim <= 0 || hp.enc_num_mel_bins <= 0 ||
-        hp.enc_max_source_positions <= 0)
-    {
+    if (hp.enc_n_layers <= 0 || hp.enc_d_model <= 0 || hp.enc_n_heads <= 0 || hp.enc_ffn_dim <= 0 ||
+        hp.enc_num_mel_bins <= 0 || hp.enc_max_source_positions <= 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "whisper: encoder hparams must be positive");
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.enc_d_model % hp.enc_n_heads != 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "whisper: encoder d_model (%d) not divisible by n_heads (%d)",
-                     hp.enc_d_model, hp.enc_n_heads);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "whisper: encoder d_model (%d) not divisible by n_heads (%d)",
+                hp.enc_d_model, hp.enc_n_heads);
         return TRANSCRIBE_ERR_GGUF;
     }
-    if (hp.dec_n_layers <= 0 || hp.dec_d_model <= 0 || hp.dec_n_heads <= 0 ||
-        hp.dec_ffn_dim <= 0 || hp.dec_max_target_positions <= 0 ||
-        hp.dec_vocab_size <= 0)
-    {
+    if (hp.dec_n_layers <= 0 || hp.dec_d_model <= 0 || hp.dec_n_heads <= 0 || hp.dec_ffn_dim <= 0 ||
+        hp.dec_max_target_positions <= 0 || hp.dec_vocab_size <= 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "whisper: decoder hparams must be positive");
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.dec_d_model % hp.dec_n_heads != 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "whisper: decoder d_model (%d) not divisible by n_heads (%d)",
-                     hp.dec_d_model, hp.dec_n_heads);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "whisper: decoder d_model (%d) not divisible by n_heads (%d)",
+                hp.dec_d_model, hp.dec_n_heads);
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.enc_d_model != hp.dec_d_model) {
         // Upstream whisper always uses d_model=d_model; a mismatch would
         // break the cross-attention K/V dim contract.
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "whisper: encoder d_model (%d) != decoder d_model (%d); "
-                     "cross-attention would mismatch",
-                     hp.enc_d_model, hp.dec_d_model);
+                "whisper: encoder d_model (%d) != decoder d_model (%d); "
+                "cross-attention would mismatch",
+                hp.enc_d_model, hp.dec_d_model);
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.enc_activation != "gelu" || hp.dec_activation != "gelu") {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "whisper: only \"gelu\" activation is supported "
-                     "(enc=\"%s\", dec=\"%s\")",
-                     hp.enc_activation.c_str(), hp.dec_activation.c_str());
+                "whisper: only \"gelu\" activation is supported "
+                "(enc=\"%s\", dec=\"%s\")",
+                hp.enc_activation.c_str(), hp.dec_activation.c_str());
         return TRANSCRIBE_ERR_GGUF;
     }
     if (!hp.dec_tie_word_embeddings) {
@@ -210,9 +336,9 @@ transcribe_status read_whisper_hparams(const gguf_context * gguf,
         // would mean the converter shipped a separate head tensor we
         // don't currently load.
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "whisper: stt.whisper.decoder.tie_word_embeddings=false "
-                     "is not supported (no separate lm_head tensor in the "
-                     "catalog)");
+                "whisper: stt.whisper.decoder.tie_word_embeddings=false "
+                "is not supported (no separate lm_head tensor in the "
+                "catalog)");
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.dec_scale_embedding) {
@@ -221,20 +347,19 @@ transcribe_status read_whisper_hparams(const gguf_context * gguf,
         // if this ever flips we need to add the scale to the decoder graph
         // (both prefill and KV paths, after get_rows(token_embd, ...)).
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "whisper: stt.whisper.decoder.scale_embedding=true is "
-                     "not supported (decoder graph does not apply the "
-                     "sqrt(d_model) embed scale)");
+                "whisper: stt.whisper.decoder.scale_embedding=true is "
+                "not supported (decoder graph does not apply the "
+                "sqrt(d_model) embed scale)");
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.decoder_start_token_id < 0 || hp.no_timestamps_token_id < 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "whisper: decoder_start_token_id / no_timestamps_token_id "
-                     "must be set");
+                "whisper: decoder_start_token_id / no_timestamps_token_id "
+                "must be set");
         return TRANSCRIBE_ERR_GGUF;
     }
-    if (hp.fe_num_mels <= 0 || hp.fe_sample_rate <= 0 ||
-        hp.fe_n_fft <= 0 || hp.fe_win_length <= 0 || hp.fe_hop_length <= 0)
-    {
+    if (hp.fe_num_mels <= 0 || hp.fe_sample_rate <= 0 || hp.fe_n_fft <= 0 || hp.fe_win_length <= 0 ||
+        hp.fe_hop_length <= 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "whisper: frontend dimensions must be positive");
         return TRANSCRIBE_ERR_GGUF;
     }
@@ -243,54 +368,51 @@ transcribe_status read_whisper_hparams(const gguf_context * gguf,
         // A mismatch would require a windowed-shorter-than-FFT code path
         // that we don't implement.
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "whisper: frontend win_length (%d) != n_fft (%d); "
-                     "only full-length window is supported",
-                     hp.fe_win_length, hp.fe_n_fft);
+                "whisper: frontend win_length (%d) != n_fft (%d); "
+                "only full-length window is supported",
+                hp.fe_win_length, hp.fe_n_fft);
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.fe_num_mels != hp.enc_num_mel_bins) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "whisper: frontend num_mels (%d) != encoder num_mel_bins (%d)",
-                     hp.fe_num_mels, hp.enc_num_mel_bins);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "whisper: frontend num_mels (%d) != encoder num_mel_bins (%d)",
+                hp.fe_num_mels, hp.enc_num_mel_bins);
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.fe_type != "mel") {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "whisper: unsupported frontend type \"%s\" (only \"mel\")",
-                     hp.fe_type.c_str());
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "whisper: unsupported frontend type \"%s\" (only \"mel\")",
+                hp.fe_type.c_str());
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.fe_window != "hann" && hp.fe_window != "hann_periodic") {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "whisper: unsupported frontend window \"%s\" "
-                     "(only \"hann\"/\"hann_periodic\" is supported)",
-                     hp.fe_window.c_str());
+                "whisper: unsupported frontend window \"%s\" "
+                "(only \"hann\"/\"hann_periodic\" is supported)",
+                hp.fe_window.c_str());
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.fe_normalize != "whisper_logmel") {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "whisper: unsupported frontend normalize \"%s\" "
-                     "(only \"whisper_logmel\" is supported)",
-                     hp.fe_normalize.c_str());
+                "whisper: unsupported frontend normalize \"%s\" "
+                "(only \"whisper_logmel\" is supported)",
+                hp.fe_normalize.c_str());
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.fe_mel_norm != "slaney") {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "whisper: unsupported frontend mel_norm \"%s\" "
-                     "(only \"slaney\" is supported)",
-                     hp.fe_mel_norm.c_str());
+                "whisper: unsupported frontend mel_norm \"%s\" "
+                "(only \"slaney\" is supported)",
+                hp.fe_mel_norm.c_str());
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.fe_pad_mode != "reflect") {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "whisper: unsupported frontend pad_mode \"%s\" "
-                     "(only \"reflect\" is supported)",
-                     hp.fe_pad_mode.c_str());
+                "whisper: unsupported frontend pad_mode \"%s\" "
+                "(only \"reflect\" is supported)",
+                hp.fe_pad_mode.c_str());
         return TRANSCRIBE_ERR_GGUF;
     }
     if (!hp.fe_center) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "whisper: non-centered STFT is not supported");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "whisper: non-centered STFT is not supported");
         return TRANSCRIBE_ERR_GGUF;
     }
     if (hp.fe_dither != 0.0f) {
@@ -300,9 +422,9 @@ transcribe_status read_whisper_hparams(const gguf_context * gguf,
         // reject it at load time rather than producing a silently-wrong
         // spectrogram.
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "whisper: stt.frontend.dither=%g is not supported "
-                     "(frontend is deterministic; expected 0.0)",
-                     hp.fe_dither);
+                "whisper: stt.frontend.dither=%g is not supported "
+                "(frontend is deterministic; expected 0.0)",
+                hp.fe_dither);
         return TRANSCRIBE_ERR_GGUF;
     }
 
@@ -310,13 +432,11 @@ transcribe_status read_whisper_hparams(const gguf_context * gguf,
 }
 
 // Frontend (mel filterbank + Hann window install)
-transcribe_status install_mel_from_buffers(
-    const WhisperHParams &                   hp,
-    std::vector<float>                       filterbank,
-    std::vector<float>                       window,
-    std::optional<transcribe::MelFrontend> & out_mel)
-{
-    transcribe::MelConfig cfg {};
+transcribe_status install_mel_from_buffers(const WhisperHParams &                   hp,
+                                           std::vector<float>                       filterbank,
+                                           std::vector<float>                       window,
+                                           std::optional<transcribe::MelFrontend> & out_mel) {
+    transcribe::MelConfig cfg{};
     cfg.sample_rate  = hp.fe_sample_rate;
     cfg.num_mels     = hp.fe_num_mels;
     cfg.n_fft        = hp.fe_n_fft;
@@ -325,21 +445,17 @@ transcribe_status install_mel_from_buffers(
     cfg.pre_emphasis = hp.fe_pre_emphasis;
     cfg.f_min        = hp.fe_f_min;
     cfg.f_max        = hp.fe_f_max;
-    cfg.pad_mode     = hp.fe_pad_mode;        // "reflect"
-    cfg.window_type  = hp.fe_window;          // "hann_periodic"
+    cfg.pad_mode     = hp.fe_pad_mode;  // "reflect"
+    cfg.window_type  = hp.fe_window;    // "hann_periodic"
 
     // Map whisper's "whisper_logmel" tag to MelFrontend's
     // "per_utterance" mode, which implements exactly the
     // log10 → clamp(max-8) → (+4)/4 sequence. Other normalize
     // strings would be a converter bug — guard at load.
-    if (hp.fe_normalize == "whisper_logmel" ||
-        hp.fe_normalize == "per_utterance")
-    {
+    if (hp.fe_normalize == "whisper_logmel" || hp.fe_normalize == "per_utterance") {
         cfg.normalize = "per_utterance";
     } else {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "whisper: unsupported fe_normalize='%s'",
-                     hp.fe_normalize.c_str());
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "whisper: unsupported fe_normalize='%s'", hp.fe_normalize.c_str());
         return TRANSCRIBE_ERR_GGUF;
     }
 
@@ -357,72 +473,67 @@ using transcribe::weights::lname;
 
 constexpr const char * kTag = kFamilyTag;
 
-#define GET_F32(slot, name, ...) \
-    do { \
-        ggml_tensor * _t = transcribe::weights::find_tensor( \
-            ctx_meta, (name), \
-            {GGML_TYPE_F32}, {__VA_ARGS__}, kTag); \
-        if (_t == nullptr) return TRANSCRIBE_ERR_GGUF; \
-        (slot) = _t; \
+#define GET_F32(slot, name, ...)                                                                          \
+    do {                                                                                                  \
+        ggml_tensor * _t =                                                                                \
+            transcribe::weights::find_tensor(ctx_meta, (name), { GGML_TYPE_F32 }, { __VA_ARGS__ }, kTag); \
+        if (_t == nullptr)                                                                                \
+            return TRANSCRIBE_ERR_GGUF;                                                                   \
+        (slot) = _t;                                                                                      \
     } while (0)
 
-#define GET_CONV(slot, name, ...) \
-    do { \
-        ggml_tensor * _t = transcribe::weights::find_tensor( \
-            ctx_meta, (name), \
-            {TRANSCRIBE_QUANT_CONV_TYPES}, \
-            {__VA_ARGS__}, kTag); \
-        if (_t == nullptr) return TRANSCRIBE_ERR_GGUF; \
-        (slot) = _t; \
+#define GET_CONV(slot, name, ...)                                                                              \
+    do {                                                                                                       \
+        ggml_tensor * _t = transcribe::weights::find_tensor(ctx_meta, (name), { TRANSCRIBE_QUANT_CONV_TYPES }, \
+                                                            { __VA_ARGS__ }, kTag);                            \
+        if (_t == nullptr)                                                                                     \
+            return TRANSCRIBE_ERR_GGUF;                                                                        \
+        (slot) = _t;                                                                                           \
     } while (0)
 
-#define GET_LIN(slot, name, ...) \
-    do { \
-        ggml_tensor * _t = transcribe::weights::find_tensor( \
-            ctx_meta, (name), \
-            {TRANSCRIBE_QUANT_LINEAR_TYPES}, \
-            {__VA_ARGS__}, kTag); \
-        if (_t == nullptr) return TRANSCRIBE_ERR_GGUF; \
-        (slot) = _t; \
+#define GET_LIN(slot, name, ...)                                                                                 \
+    do {                                                                                                         \
+        ggml_tensor * _t = transcribe::weights::find_tensor(ctx_meta, (name), { TRANSCRIBE_QUANT_LINEAR_TYPES }, \
+                                                            { __VA_ARGS__ }, kTag);                              \
+        if (_t == nullptr)                                                                                       \
+            return TRANSCRIBE_ERR_GGUF;                                                                          \
+        (slot) = _t;                                                                                             \
     } while (0)
 
-} // namespace
+}  // namespace
 
-transcribe_status build_whisper_weights(ggml_context *          ctx_meta,
-                                        const WhisperHParams &  hp,
-                                        WhisperWeights &        weights)
-{
+transcribe_status build_whisper_weights(ggml_context * ctx_meta, const WhisperHParams & hp, WhisperWeights & weights) {
     if (ctx_meta == nullptr) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
 
-    const int64_t d_model     = hp.enc_d_model;
-    const int64_t n_mel       = hp.enc_num_mel_bins;
-    const int64_t enc_ff      = hp.enc_ffn_dim;
-    const int64_t src_pos     = hp.enc_max_source_positions;
-    const int64_t dec_h       = hp.dec_d_model;
-    const int64_t dec_ff      = hp.dec_ffn_dim;
-    const int64_t tgt_pos     = hp.dec_max_target_positions;
-    const int64_t vocab_size  = hp.dec_vocab_size;
-    const int64_t n_fft_half  = hp.fe_n_fft / 2 + 1;
+    const int64_t d_model    = hp.enc_d_model;
+    const int64_t n_mel      = hp.enc_num_mel_bins;
+    const int64_t enc_ff     = hp.enc_ffn_dim;
+    const int64_t src_pos    = hp.enc_max_source_positions;
+    const int64_t dec_h      = hp.dec_d_model;
+    const int64_t dec_ff     = hp.dec_ffn_dim;
+    const int64_t tgt_pos    = hp.dec_max_target_positions;
+    const int64_t vocab_size = hp.dec_vocab_size;
+    const int64_t n_fft_half = hp.fe_n_fft / 2 + 1;
 
     // ----- frontend (mel filterbank + hann window) -----
     GET_F32(weights.frontend.mel_filterbank, "frontend.mel_filterbank", n_fft_half, n_mel);
-    GET_F32(weights.frontend.window,         "frontend.window",         hp.fe_n_fft);
+    GET_F32(weights.frontend.window, "frontend.window", hp.fe_n_fft);
 
     // ----- encoder conv stem -----
     // Conv1d kernels: PyTorch [out, in, K] -> ggml ne=[K, in, out].
-    GET_CONV(weights.enc_stem.conv0_w, "enc.conv.0.weight", 3, n_mel,   d_model);
-    GET_F32 (weights.enc_stem.conv0_b, "enc.conv.0.bias",   d_model);
+    GET_CONV(weights.enc_stem.conv0_w, "enc.conv.0.weight", 3, n_mel, d_model);
+    GET_F32(weights.enc_stem.conv0_b, "enc.conv.0.bias", d_model);
     GET_CONV(weights.enc_stem.conv1_w, "enc.conv.1.weight", 3, d_model, d_model);
-    GET_F32 (weights.enc_stem.conv1_b, "enc.conv.1.bias",   d_model);
+    GET_F32(weights.enc_stem.conv1_b, "enc.conv.1.bias", d_model);
 
     // ----- encoder top (pos emb + final LN) -----
     // pos_emb is nn.Embedding weight [max_source_positions, d_model] ->
     // ggml ne = [d_model, max_source_positions].
-    GET_F32(weights.enc_top.pos_emb_w,    "enc.pos_emb.weight",    d_model, src_pos);
+    GET_F32(weights.enc_top.pos_emb_w, "enc.pos_emb.weight", d_model, src_pos);
     GET_F32(weights.enc_top.final_norm_w, "enc.final_norm.weight", d_model);
-    GET_F32(weights.enc_top.final_norm_b, "enc.final_norm.bias",   d_model);
+    GET_F32(weights.enc_top.final_norm_b, "enc.final_norm.bias", d_model);
 
     // ----- encoder blocks -----
     weights.enc_blocks.assign(hp.enc_n_layers, WhisperEncBlock{});
@@ -430,22 +541,22 @@ transcribe_status build_whisper_weights(ggml_context *          ctx_meta,
         auto & b = weights.enc_blocks[i];
 
         GET_F32(b.norm_attn_w, lname("enc.blocks.%d.norm_attn.weight", i), d_model);
-        GET_F32(b.norm_attn_b, lname("enc.blocks.%d.norm_attn.bias",   i), d_model);
-
-        GET_LIN(b.attn_q_w,    lname("enc.blocks.%d.attn.q.weight",   i), d_model, d_model);
-        GET_F32(b.attn_q_b,    lname("enc.blocks.%d.attn.q.bias",     i), d_model);
-        GET_LIN(b.attn_k_w,    lname("enc.blocks.%d.attn.k.weight",   i), d_model, d_model);  // no bias
-        GET_LIN(b.attn_v_w,    lname("enc.blocks.%d.attn.v.weight",   i), d_model, d_model);
-        GET_F32(b.attn_v_b,    lname("enc.blocks.%d.attn.v.bias",     i), d_model);
-        GET_LIN(b.attn_out_w,  lname("enc.blocks.%d.attn.out.weight", i), d_model, d_model);
-        GET_F32(b.attn_out_b,  lname("enc.blocks.%d.attn.out.bias",   i), d_model);
-
-        GET_F32(b.norm_ffn_w,  lname("enc.blocks.%d.norm_ffn.weight", i), d_model);
-        GET_F32(b.norm_ffn_b,  lname("enc.blocks.%d.norm_ffn.bias",   i), d_model);
-        GET_LIN(b.ffn_fc1_w,   lname("enc.blocks.%d.ffn.fc1.weight",  i), d_model, enc_ff);
-        GET_F32(b.ffn_fc1_b,   lname("enc.blocks.%d.ffn.fc1.bias",    i), enc_ff);
-        GET_LIN(b.ffn_fc2_w,   lname("enc.blocks.%d.ffn.fc2.weight",  i), enc_ff,  d_model);
-        GET_F32(b.ffn_fc2_b,   lname("enc.blocks.%d.ffn.fc2.bias",    i), d_model);
+        GET_F32(b.norm_attn_b, lname("enc.blocks.%d.norm_attn.bias", i), d_model);
+
+        GET_LIN(b.attn_q_w, lname("enc.blocks.%d.attn.q.weight", i), d_model, d_model);
+        GET_F32(b.attn_q_b, lname("enc.blocks.%d.attn.q.bias", i), d_model);
+        GET_LIN(b.attn_k_w, lname("enc.blocks.%d.attn.k.weight", i), d_model, d_model);  // no bias
+        GET_LIN(b.attn_v_w, lname("enc.blocks.%d.attn.v.weight", i), d_model, d_model);
+        GET_F32(b.attn_v_b, lname("enc.blocks.%d.attn.v.bias", i), d_model);
+        GET_LIN(b.attn_out_w, lname("enc.blocks.%d.attn.out.weight", i), d_model, d_model);
+        GET_F32(b.attn_out_b, lname("enc.blocks.%d.attn.out.bias", i), d_model);
+
+        GET_F32(b.norm_ffn_w, lname("enc.blocks.%d.norm_ffn.weight", i), d_model);
+        GET_F32(b.norm_ffn_b, lname("enc.blocks.%d.norm_ffn.bias", i), d_model);
+        GET_LIN(b.ffn_fc1_w, lname("enc.blocks.%d.ffn.fc1.weight", i), d_model, enc_ff);
+        GET_F32(b.ffn_fc1_b, lname("enc.blocks.%d.ffn.fc1.bias", i), enc_ff);
+        GET_LIN(b.ffn_fc2_w, lname("enc.blocks.%d.ffn.fc2.weight", i), enc_ff, d_model);
+        GET_F32(b.ffn_fc2_b, lname("enc.blocks.%d.ffn.fc2.bias", i), d_model);
     }
 
     // ----- decoder top -----
@@ -453,9 +564,9 @@ transcribe_status build_whisper_weights(ggml_context *          ctx_meta,
     // Doubles as the tied lm_head weight, so it accepts the full quant
     // allowlist (GET_LIN, not GET_F32).
     GET_LIN(weights.dec_top.token_embd_w, "dec.token_embd.weight", dec_h, vocab_size);
-    GET_F32(weights.dec_top.pos_emb_w,    "dec.pos_emb.weight",    dec_h, tgt_pos);
+    GET_F32(weights.dec_top.pos_emb_w, "dec.pos_emb.weight", dec_h, tgt_pos);
     GET_F32(weights.dec_top.final_norm_w, "dec.final_norm.weight", dec_h);
-    GET_F32(weights.dec_top.final_norm_b, "dec.final_norm.bias",   dec_h);
+    GET_F32(weights.dec_top.final_norm_b, "dec.final_norm.bias", dec_h);
 
     // ----- decoder blocks -----
     weights.dec_blocks.assign(hp.dec_n_layers, WhisperDecBlock{});
@@ -463,34 +574,34 @@ transcribe_status build_whisper_weights(ggml_context *          ctx_meta,
         auto & b = weights.dec_blocks[i];
 
         // Self-attention.
-        GET_F32(b.norm_self_w,  lname("dec.blocks.%d.norm_self.weight",    i), dec_h);
-        GET_F32(b.norm_self_b,  lname("dec.blocks.%d.norm_self.bias",      i), dec_h);
-        GET_LIN(b.self_q_w,     lname("dec.blocks.%d.self_attn.q.weight",  i), dec_h, dec_h);
-        GET_F32(b.self_q_b,     lname("dec.blocks.%d.self_attn.q.bias",    i), dec_h);
-        GET_LIN(b.self_k_w,     lname("dec.blocks.%d.self_attn.k.weight",  i), dec_h, dec_h);  // no bias
-        GET_LIN(b.self_v_w,     lname("dec.blocks.%d.self_attn.v.weight",  i), dec_h, dec_h);
-        GET_F32(b.self_v_b,     lname("dec.blocks.%d.self_attn.v.bias",    i), dec_h);
-        GET_LIN(b.self_out_w,   lname("dec.blocks.%d.self_attn.out.weight",i), dec_h, dec_h);
-        GET_F32(b.self_out_b,   lname("dec.blocks.%d.self_attn.out.bias",  i), dec_h);
+        GET_F32(b.norm_self_w, lname("dec.blocks.%d.norm_self.weight", i), dec_h);
+        GET_F32(b.norm_self_b, lname("dec.blocks.%d.norm_self.bias", i), dec_h);
+        GET_LIN(b.self_q_w, lname("dec.blocks.%d.self_attn.q.weight", i), dec_h, dec_h);
+        GET_F32(b.self_q_b, lname("dec.blocks.%d.self_attn.q.bias", i), dec_h);
+        GET_LIN(b.self_k_w, lname("dec.blocks.%d.self_attn.k.weight", i), dec_h, dec_h);  // no bias
+        GET_LIN(b.self_v_w, lname("dec.blocks.%d.self_attn.v.weight", i), dec_h, dec_h);
+        GET_F32(b.self_v_b, lname("dec.blocks.%d.self_attn.v.bias", i), dec_h);
+        GET_LIN(b.self_out_w, lname("dec.blocks.%d.self_attn.out.weight", i), dec_h, dec_h);
+        GET_F32(b.self_out_b, lname("dec.blocks.%d.self_attn.out.bias", i), dec_h);
 
         // Cross-attention.
-        GET_F32(b.norm_cross_w, lname("dec.blocks.%d.norm_cross.weight",    i), dec_h);
-        GET_F32(b.norm_cross_b, lname("dec.blocks.%d.norm_cross.bias",      i), dec_h);
-        GET_LIN(b.cross_q_w,    lname("dec.blocks.%d.cross_attn.q.weight",  i), dec_h, dec_h);
-        GET_F32(b.cross_q_b,    lname("dec.blocks.%d.cross_attn.q.bias",    i), dec_h);
-        GET_LIN(b.cross_k_w,    lname("dec.blocks.%d.cross_attn.k.weight",  i), dec_h, dec_h);  // no bias
-        GET_LIN(b.cross_v_w,    lname("dec.blocks.%d.cross_attn.v.weight",  i), dec_h, dec_h);
-        GET_F32(b.cross_v_b,    lname("dec.blocks.%d.cross_attn.v.bias",    i), dec_h);
-        GET_LIN(b.cross_out_w,  lname("dec.blocks.%d.cross_attn.out.weight",i), dec_h, dec_h);
-        GET_F32(b.cross_out_b,  lname("dec.blocks.%d.cross_attn.out.bias",  i), dec_h);
+        GET_F32(b.norm_cross_w, lname("dec.blocks.%d.norm_cross.weight", i), dec_h);
+        GET_F32(b.norm_cross_b, lname("dec.blocks.%d.norm_cross.bias", i), dec_h);
+        GET_LIN(b.cross_q_w, lname("dec.blocks.%d.cross_attn.q.weight", i), dec_h, dec_h);
+        GET_F32(b.cross_q_b, lname("dec.blocks.%d.cross_attn.q.bias", i), dec_h);
+        GET_LIN(b.cross_k_w, lname("dec.blocks.%d.cross_attn.k.weight", i), dec_h, dec_h);  // no bias
+        GET_LIN(b.cross_v_w, lname("dec.blocks.%d.cross_attn.v.weight", i), dec_h, dec_h);
+        GET_F32(b.cross_v_b, lname("dec.blocks.%d.cross_attn.v.bias", i), dec_h);
+        GET_LIN(b.cross_out_w, lname("dec.blocks.%d.cross_attn.out.weight", i), dec_h, dec_h);
+        GET_F32(b.cross_out_b, lname("dec.blocks.%d.cross_attn.out.bias", i), dec_h);
 
         // FFN.
-        GET_F32(b.norm_ffn_w,   lname("dec.blocks.%d.norm_ffn.weight", i), dec_h);
-        GET_F32(b.norm_ffn_b,   lname("dec.blocks.%d.norm_ffn.bias",   i), dec_h);
-        GET_LIN(b.ffn_fc1_w,    lname("dec.blocks.%d.ffn.fc1.weight",  i), dec_h,  dec_ff);
-        GET_F32(b.ffn_fc1_b,    lname("dec.blocks.%d.ffn.fc1.bias",    i), dec_ff);
-        GET_LIN(b.ffn_fc2_w,    lname("dec.blocks.%d.ffn.fc2.weight",  i), dec_ff, dec_h);
-        GET_F32(b.ffn_fc2_b,    lname("dec.blocks.%d.ffn.fc2.bias",    i), dec_h);
+        GET_F32(b.norm_ffn_w, lname("dec.blocks.%d.norm_ffn.weight", i), dec_h);
+        GET_F32(b.norm_ffn_b, lname("dec.blocks.%d.norm_ffn.bias", i), dec_h);
+        GET_LIN(b.ffn_fc1_w, lname("dec.blocks.%d.ffn.fc1.weight", i), dec_h, dec_ff);
+        GET_F32(b.ffn_fc1_b, lname("dec.blocks.%d.ffn.fc1.bias", i), dec_ff);
+        GET_LIN(b.ffn_fc2_w, lname("dec.blocks.%d.ffn.fc2.weight", i), dec_ff, dec_h);
+        GET_F32(b.ffn_fc2_b, lname("dec.blocks.%d.ffn.fc2.bias", i), dec_h);
     }
 
     return TRANSCRIBE_OK;
@@ -500,4 +611,4 @@ transcribe_status build_whisper_weights(ggml_context *          ctx_meta,
 #undef GET_CONV
 #undef GET_LIN
 
-} // namespace transcribe::whisper
+}  // namespace transcribe::whisper
diff --git a/src/arch/whisper/weights.h b/src/arch/whisper/weights.h
index 679f1523..ee7ffd80 100644
--- a/src/arch/whisper/weights.h
+++ b/src/arch/whisper/weights.h
@@ -8,8 +8,8 @@
 
 #pragma once
 
-#include "transcribe.h"
 #include "transcribe-mel.h"
+#include "transcribe.h"
 
 #include <cstdint>
 #include <optional>
@@ -24,32 +24,32 @@ namespace transcribe::whisper {
 
 struct WhisperHParams {
     // Encoder.
-    int32_t enc_n_layers            = 0;
-    int32_t enc_d_model             = 0;
-    int32_t enc_n_heads             = 0;
-    int32_t enc_ffn_dim             = 0;
-    int32_t enc_num_mel_bins        = 0;
-    int32_t enc_max_source_positions = 0;  // 1500 across variants
-    std::string enc_activation;             // always "gelu" in shipped checkpoints
+    int32_t     enc_n_layers             = 0;
+    int32_t     enc_d_model              = 0;
+    int32_t     enc_n_heads              = 0;
+    int32_t     enc_ffn_dim              = 0;
+    int32_t     enc_num_mel_bins         = 0;
+    int32_t     enc_max_source_positions = 0;  // 1500 across variants
+    std::string enc_activation;                // always "gelu" in shipped checkpoints
 
     // Decoder.
-    int32_t dec_n_layers             = 0;
-    int32_t dec_d_model              = 0;  // equal to enc_d_model in upstream; carried separately for safety
-    int32_t dec_n_heads              = 0;
-    int32_t dec_ffn_dim              = 0;
-    int32_t dec_max_target_positions = 0;
-    int32_t dec_vocab_size           = 0;
+    int32_t     dec_n_layers             = 0;
+    int32_t     dec_d_model              = 0;  // equal to enc_d_model in upstream; carried separately for safety
+    int32_t     dec_n_heads              = 0;
+    int32_t     dec_ffn_dim              = 0;
+    int32_t     dec_max_target_positions = 0;
+    int32_t     dec_vocab_size           = 0;
     std::string dec_activation;
-    bool    dec_tie_word_embeddings  = true;
-    bool    dec_scale_embedding      = false;  // HF config.scale_embedding; always false for upstream Whisper
+    bool        dec_tie_word_embeddings = true;
+    bool        dec_scale_embedding     = false;  // HF config.scale_embedding; always false for upstream Whisper
 
     // Whisper generation contract.
-    int32_t decoder_start_token_id = -1;   // <|startoftranscript|>, 50258 for multilingual
-    int32_t no_timestamps_token_id = -1;   // <|notimestamps|>, 50363
-    int32_t sot_token_id           = -1;   // alias of decoder_start_token_id; kept separate for clarity
-    int32_t transcribe_token_id    = -1;   // <|transcribe|>
-    int32_t translate_token_id     = -1;   // <|translate|>
-    int32_t prev_sot_token_id      = -1;   // <|startofprev|>
+    int32_t decoder_start_token_id = -1;  // <|startoftranscript|>, 50258 for multilingual
+    int32_t no_timestamps_token_id = -1;  // <|notimestamps|>, 50363
+    int32_t sot_token_id           = -1;  // alias of decoder_start_token_id; kept separate for clarity
+    int32_t transcribe_token_id    = -1;  // <|transcribe|>
+    int32_t translate_token_id     = -1;  // <|translate|>
+    int32_t prev_sot_token_id      = -1;  // <|startofprev|>
 
     // Suppression lists (may be empty for .en variants).
     std::vector<int32_t> suppress_tokens;        // applied every step
@@ -57,23 +57,23 @@ struct WhisperHParams {
 
     // Frontend (WhisperFeatureExtractor).
     std::string fe_type;
-    int32_t     fe_num_mels     = 0;
-    int32_t     fe_sample_rate  = 0;
-    int32_t     fe_n_fft        = 0;
-    int32_t     fe_win_length   = 0;
-    int32_t     fe_hop_length   = 0;
+    int32_t     fe_num_mels    = 0;
+    int32_t     fe_sample_rate = 0;
+    int32_t     fe_n_fft       = 0;
+    int32_t     fe_win_length  = 0;
+    int32_t     fe_hop_length  = 0;
     std::string fe_window;
     std::string fe_normalize;
     float       fe_dither       = 0.0f;
     float       fe_pre_emphasis = 0.0f;
     float       fe_f_min        = 0.0f;
     float       fe_f_max        = 0.0f;
-    std::string fe_pad_mode;      // "reflect" for whisper
-    bool        fe_center        = true;
-    std::string fe_mel_norm;      // "slaney"
-    int32_t     fe_chunk_length  = 0;   // 30 (seconds)
-    int32_t     fe_n_samples     = 0;   // 480000
-    int32_t     fe_nb_max_frames = 0;   // 3000
+    std::string fe_pad_mode;           // "reflect" for whisper
+    bool        fe_center = true;
+    std::string fe_mel_norm;           // "slaney"
+    int32_t     fe_chunk_length  = 0;  // 30 (seconds)
+    int32_t     fe_n_samples     = 0;  // 480000
+    int32_t     fe_nb_max_frames = 0;  // 3000
 
     // Capability flags read from stt.capability.*.
     bool cap_lang_detect = false;
@@ -82,11 +82,11 @@ struct WhisperHParams {
 
     // Derived helpers.
     int32_t enc_head_dim() const { return enc_n_heads > 0 ? enc_d_model / enc_n_heads : 0; }
+
     int32_t dec_head_dim() const { return dec_n_heads > 0 ? dec_d_model / dec_n_heads : 0; }
 };
 
-transcribe_status read_whisper_hparams(const gguf_context * gguf,
-                                       WhisperHParams &     hp);
+transcribe_status read_whisper_hparams(const gguf_context * gguf, WhisperHParams & hp);
 
 // Shared mel frontend buffers. preprocessor_config.json ships the
 // exact slaney filterbank and Hann window the model was trained with;
@@ -116,19 +116,19 @@ struct WhisperEncTop {
 struct WhisperEncBlock {
     ggml_tensor * norm_attn_w = nullptr;
     ggml_tensor * norm_attn_b = nullptr;
-    ggml_tensor * attn_q_w   = nullptr;
-    ggml_tensor * attn_q_b   = nullptr;
-    ggml_tensor * attn_k_w   = nullptr;  // no bias
-    ggml_tensor * attn_v_w   = nullptr;
-    ggml_tensor * attn_v_b   = nullptr;
-    ggml_tensor * attn_out_w = nullptr;
-    ggml_tensor * attn_out_b = nullptr;
-    ggml_tensor * norm_ffn_w = nullptr;
-    ggml_tensor * norm_ffn_b = nullptr;
-    ggml_tensor * ffn_fc1_w = nullptr;
-    ggml_tensor * ffn_fc1_b = nullptr;
-    ggml_tensor * ffn_fc2_w = nullptr;
-    ggml_tensor * ffn_fc2_b = nullptr;
+    ggml_tensor * attn_q_w    = nullptr;
+    ggml_tensor * attn_q_b    = nullptr;
+    ggml_tensor * attn_k_w    = nullptr;  // no bias
+    ggml_tensor * attn_v_w    = nullptr;
+    ggml_tensor * attn_v_b    = nullptr;
+    ggml_tensor * attn_out_w  = nullptr;
+    ggml_tensor * attn_out_b  = nullptr;
+    ggml_tensor * norm_ffn_w  = nullptr;
+    ggml_tensor * norm_ffn_b  = nullptr;
+    ggml_tensor * ffn_fc1_w   = nullptr;
+    ggml_tensor * ffn_fc1_b   = nullptr;
+    ggml_tensor * ffn_fc2_w   = nullptr;
+    ggml_tensor * ffn_fc2_b   = nullptr;
 };
 
 // Decoder token+position embedding and final LN.
@@ -143,45 +143,43 @@ struct WhisperDecTop {
 struct WhisperDecBlock {
     ggml_tensor * norm_self_w = nullptr;
     ggml_tensor * norm_self_b = nullptr;
-    ggml_tensor * self_q_w   = nullptr;
-    ggml_tensor * self_q_b   = nullptr;
-    ggml_tensor * self_k_w   = nullptr;  // no bias
-    ggml_tensor * self_v_w   = nullptr;
-    ggml_tensor * self_v_b   = nullptr;
-    ggml_tensor * self_out_w = nullptr;
-    ggml_tensor * self_out_b = nullptr;
+    ggml_tensor * self_q_w    = nullptr;
+    ggml_tensor * self_q_b    = nullptr;
+    ggml_tensor * self_k_w    = nullptr;  // no bias
+    ggml_tensor * self_v_w    = nullptr;
+    ggml_tensor * self_v_b    = nullptr;
+    ggml_tensor * self_out_w  = nullptr;
+    ggml_tensor * self_out_b  = nullptr;
 
     // Cross-attention queries decoder state against encoder output.
     ggml_tensor * norm_cross_w = nullptr;
     ggml_tensor * norm_cross_b = nullptr;
-    ggml_tensor * cross_q_w   = nullptr;
-    ggml_tensor * cross_q_b   = nullptr;
-    ggml_tensor * cross_k_w   = nullptr;  // no bias
-    ggml_tensor * cross_v_w   = nullptr;
-    ggml_tensor * cross_v_b   = nullptr;
-    ggml_tensor * cross_out_w = nullptr;
-    ggml_tensor * cross_out_b = nullptr;
+    ggml_tensor * cross_q_w    = nullptr;
+    ggml_tensor * cross_q_b    = nullptr;
+    ggml_tensor * cross_k_w    = nullptr;  // no bias
+    ggml_tensor * cross_v_w    = nullptr;
+    ggml_tensor * cross_v_b    = nullptr;
+    ggml_tensor * cross_out_w  = nullptr;
+    ggml_tensor * cross_out_b  = nullptr;
 
     ggml_tensor * norm_ffn_w = nullptr;
     ggml_tensor * norm_ffn_b = nullptr;
-    ggml_tensor * ffn_fc1_w = nullptr;
-    ggml_tensor * ffn_fc1_b = nullptr;
-    ggml_tensor * ffn_fc2_w = nullptr;
-    ggml_tensor * ffn_fc2_b = nullptr;
+    ggml_tensor * ffn_fc1_w  = nullptr;
+    ggml_tensor * ffn_fc1_b  = nullptr;
+    ggml_tensor * ffn_fc2_w  = nullptr;
+    ggml_tensor * ffn_fc2_b  = nullptr;
 };
 
 struct WhisperWeights {
-    WhisperFrontend                frontend;
-    WhisperEncStem                 enc_stem;
-    WhisperEncTop                  enc_top;
-    std::vector<WhisperEncBlock>   enc_blocks;
-    WhisperDecTop                  dec_top;
-    std::vector<WhisperDecBlock>   dec_blocks;
+    WhisperFrontend              frontend;
+    WhisperEncStem               enc_stem;
+    WhisperEncTop                enc_top;
+    std::vector<WhisperEncBlock> enc_blocks;
+    WhisperDecTop                dec_top;
+    std::vector<WhisperDecBlock> dec_blocks;
 };
 
-transcribe_status build_whisper_weights(ggml_context *          ctx_meta,
-                                        const WhisperHParams &  hp,
-                                        WhisperWeights &        weights);
+transcribe_status build_whisper_weights(ggml_context * ctx_meta, const WhisperHParams & hp, WhisperWeights & weights);
 
 // Build a MelConfig from `hp`, install the caller-provided
 // `filterbank` + `window` buffers (either may be empty — MelFrontend
@@ -190,10 +188,9 @@ transcribe_status build_whisper_weights(ggml_context *          ctx_meta,
 // between the GGUF load path (buffers fetched via
 // read_f32_tensor_checked) and the legacy whisper.cpp `.bin` adapter
 // (mel filterbank from the parsed file, Hann window computed in C++).
-transcribe_status install_mel_from_buffers(
-    const WhisperHParams &                   hp,
-    std::vector<float>                       filterbank,
-    std::vector<float>                       window,
-    std::optional<transcribe::MelFrontend> & out_mel);
+transcribe_status install_mel_from_buffers(const WhisperHParams &                   hp,
+                                           std::vector<float>                       filterbank,
+                                           std::vector<float>                       window,
+                                           std::optional<transcribe::MelFrontend> & out_mel);
 
-} // namespace transcribe::whisper
+}  // namespace transcribe::whisper
diff --git a/src/arch/whisper/whisper.h b/src/arch/whisper/whisper.h
index 4546fbfa..d5b9a649 100644
--- a/src/arch/whisper/whisper.h
+++ b/src/arch/whisper/whisper.h
@@ -4,17 +4,16 @@
 
 #pragma once
 
+#include "ggml-backend.h"
+#include "ggml.h"
 #include "transcribe-backend.h"
-#include "transcribe-session.h"
 #include "transcribe-mel.h"
 #include "transcribe-model.h"
+#include "transcribe-session.h"
 #include "transcribe-tokenizer.h"
 #include "transcribe/whisper.h"
 #include "weights.h"
 
-#include "ggml.h"
-#include "ggml-backend.h"
-
 #include <cstdint>
 #include <optional>
 #include <string>
@@ -95,15 +94,15 @@ struct WhisperKvCache {
             ggml_free(ctx);
             ctx = nullptr;
         }
-        self_k = nullptr;
-        self_v = nullptr;
-        cross_k = nullptr;
-        cross_v = nullptr;
-        n_batch = 1;
-        n = 0;
-        head = 0;
-        T_enc = 0;
-        T_enc_pad = 0;
+        self_k          = nullptr;
+        self_v          = nullptr;
+        cross_k         = nullptr;
+        cross_v         = nullptr;
+        n_batch         = 1;
+        n               = 0;
+        head            = 0;
+        T_enc           = 0;
+        T_enc_pad       = 0;
         cross_populated = false;
     }
 };
@@ -114,9 +113,9 @@ struct WhisperKvCache {
 // Allocated on first use, reallocated only on shape change (T_enc is fixed at
 // max_source_positions=1500 for stock variants, so effectively never).
 struct WhisperEncOut {
-    ggml_tensor *         tensor = nullptr;
-    ggml_context *        ctx    = nullptr;
-    ggml_backend_buffer_t buffer = nullptr;
+    ggml_tensor *         tensor  = nullptr;
+    ggml_context *        ctx     = nullptr;
+    ggml_backend_buffer_t buffer  = nullptr;
     int                   d_model = 0;
     int                   T_enc   = 0;
 
@@ -135,10 +134,7 @@ struct WhisperEncOut {
     }
 };
 
-bool enc_out_init(WhisperEncOut & enc_out,
-                  ggml_backend_t  backend,
-                  int             d_model,
-                  int             T_enc);
+bool enc_out_init(WhisperEncOut & enc_out, ggml_backend_t backend, int d_model, int T_enc);
 
 // Active-KV padding for the self-attention step graph (whisper.cpp's
 // whisper_kv_cache_get_padding): 32 on Metal+FA, 1 otherwise. Aligns the FA
@@ -185,8 +181,9 @@ struct WhisperPerfStage {
 
     void add(int64_t us) {
         total_us += us;
-        count    += 1;
+        count += 1;
     }
+
     void reset() {
         total_us = 0;
         count    = 0;
@@ -235,29 +232,40 @@ struct WhisperPerf {
     int chunks = 0;
 
     void reset() {
-        enc_build.reset();         enc_alloc.reset();
-        enc_compute.reset();       enc_tensor_get.reset();
-        cross_build.reset();       cross_alloc.reset();
+        enc_build.reset();
+        enc_alloc.reset();
+        enc_compute.reset();
+        enc_tensor_get.reset();
+        cross_build.reset();
+        cross_alloc.reset();
         cross_compute.reset();
-        prompt_build.reset();      prompt_alloc.reset();
-        prompt_compute.reset();    prompt_tensor_get.reset();
+        prompt_build.reset();
+        prompt_alloc.reset();
+        prompt_compute.reset();
+        prompt_tensor_get.reset();
         prompt_cpu.reset();
-        step_build.reset();        step_alloc.reset();
-        step_compute.reset();      step_tensor_get.reset();
+        step_build.reset();
+        step_alloc.reset();
+        step_compute.reset();
+        step_tensor_get.reset();
         step_cpu.reset();
-        prompt_cpu_suppress.reset();  prompt_cpu_timestamp.reset();
-        prompt_cpu_sample.reset();    prompt_cpu_logprob.reset();
-        step_cpu_suppress.reset();    step_cpu_timestamp.reset();
-        step_cpu_sample.reset();      step_cpu_logprob.reset();
+        prompt_cpu_suppress.reset();
+        prompt_cpu_timestamp.reset();
+        prompt_cpu_sample.reset();
+        prompt_cpu_logprob.reset();
+        step_cpu_suppress.reset();
+        step_cpu_timestamp.reset();
+        step_cpu_sample.reset();
+        step_cpu_logprob.reset();
         chunks = 0;
     }
 };
 
 struct WhisperModel final : public transcribe_model {
-    Tokenizer       tok;
-    WhisperHParams  hparams;
-    WhisperWeights  weights;
-    ggml_context *  ctx_meta = nullptr;
+    Tokenizer      tok;
+    WhisperHParams hparams;
+    WhisperWeights weights;
+    ggml_context * ctx_meta = nullptr;
 
     // Runtime backend plan. See transcribe-backend.h.
     transcribe::BackendPlan plan;
@@ -266,7 +274,7 @@ struct WhisperModel final : public transcribe_model {
     // Language token ids keyed by BCP-47 short code (from general.languages).
     // Resolves a params.language string to the <|lang_xx|> token id (whisper
     // packs these in tokenizer slots 50259 + lang_index).
-    std::vector<std::string> lang_codes;   // owned copy; lifetime matches the model
+    std::vector<std::string> lang_codes;  // owned copy; lifetime matches the model
     std::vector<int32_t>     lang_token_ids;
 
     // C++ mel frontend (per_utterance / hann_periodic / reflect / Slaney).
@@ -281,12 +289,12 @@ struct WhisperModel final : public transcribe_model {
 };
 
 struct WhisperSession final : public transcribe_session {
-    ggml_context *        compute_ctx      = nullptr;
+    ggml_context *       compute_ctx      = nullptr;
     // Currently-allocated capacity of compute_ctx (mem_size). Used by
     // ensure_compute_ctx to decide between ggml_reset (cheap reuse)
     // and ggml_free + ggml_init (only when more space is needed).
-    size_t                compute_ctx_size = 0;
-    ggml_backend_sched_t  sched       = nullptr;
+    size_t               compute_ctx_size = 0;
+    ggml_backend_sched_t sched            = nullptr;
 
     // Persistent backend-resident encoder output (see WhisperEncOut).
     WhisperEncOut enc_out;
@@ -324,4 +332,4 @@ struct WhisperSession final : public transcribe_session {
     ~WhisperSession() override;
 };
 
-} // namespace transcribe::whisper
+}  // namespace transcribe::whisper
diff --git a/src/causal_lm/causal_lm.cpp b/src/causal_lm/causal_lm.cpp
index b8464377..5f04ea68 100644
--- a/src/causal_lm/causal_lm.cpp
+++ b/src/causal_lm/causal_lm.cpp
@@ -2,11 +2,11 @@
 // (Llama / Qwen3 lineage). See causal_lm.h for the API contract.
 
 #include "causal_lm.h"
-#include "transcribe-session.h"
-#include "transcribe-log.h"
 
-#include "ggml.h"
 #include "ggml-backend.h"
+#include "ggml.h"
+#include "transcribe-log.h"
+#include "transcribe-session.h"
 
 #include <algorithm>
 #include <cmath>
@@ -18,9 +18,7 @@ namespace transcribe::causal_lm {
 
 namespace {
 
-ggml_tensor * rms_norm(ggml_context * ctx, ggml_tensor * x,
-                       ggml_tensor * weight, float eps)
-{
+ggml_tensor * rms_norm(ggml_context * ctx, ggml_tensor * x, ggml_tensor * weight, float eps) {
     return ggml_mul(ctx, ggml_rms_norm(ctx, x, eps), weight);
 }
 
@@ -32,8 +30,7 @@ ggml_tensor * rms_norm(ggml_context * ctx, ggml_tensor * x,
 // Gated on F16 so BF16/quantized/F32 weights are untouched (BF16 already
 // COMPUTE_32F; quantized uses MMQ) and CPU/Metal (always F32-accumulate) are
 // unaffected.
-ggml_tensor * mul_mat_f32acc(ggml_context * ctx, ggml_tensor * w, ggml_tensor * x)
-{
+ggml_tensor * mul_mat_f32acc(ggml_context * ctx, ggml_tensor * w, ggml_tensor * x) {
     ggml_tensor * y = ggml_mul_mat(ctx, w, x);
     if (w->type == GGML_TYPE_F16) {
         ggml_mul_mat_set_prec(y, GGML_PREC_F32);
@@ -41,7 +38,7 @@ ggml_tensor * mul_mat_f32acc(ggml_context * ctx, ggml_tensor * w, ggml_tensor *
     return y;
 }
 
-} // namespace
+}  // namespace
 
 void KvCache::free() {
     if (buffer != nullptr) {
@@ -54,8 +51,8 @@ void KvCache::free() {
     }
     self_k = nullptr;
     self_v = nullptr;
-    n    = 0;
-    head = 0;
+    n      = 0;
+    head   = 0;
 }
 
 bool kv_init(KvCache &      cache,
@@ -64,17 +61,14 @@ bool kv_init(KvCache &      cache,
              int            n_kv_heads,
              int            head_dim,
              int            n_layer,
-             ggml_type      kv_type)
-{
+             ggml_type      kv_type) {
     if (kv_type != GGML_TYPE_F16 && kv_type != GGML_TYPE_F32) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "causal_lm kv_init: unsupported kv_type=%d",
-                     static_cast<int>(kv_type));
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "causal_lm kv_init: unsupported kv_type=%d", static_cast<int>(kv_type));
         return false;
     }
 
-    const size_t ctx_size = 2 * ggml_tensor_overhead() + 256;
-    ggml_init_params params {};
+    const size_t     ctx_size = 2 * ggml_tensor_overhead() + 256;
+    ggml_init_params params{};
     params.mem_size   = ctx_size;
     params.mem_buffer = nullptr;
     params.no_alloc   = true;
@@ -85,10 +79,9 @@ bool kv_init(KvCache &      cache,
         return false;
     }
 
-    const int64_t elems =
-        static_cast<int64_t>(n_kv_heads) * head_dim * n_ctx * n_layer;
-    cache.self_k = ggml_new_tensor_1d(cache.ctx, kv_type, elems);
-    cache.self_v = ggml_new_tensor_1d(cache.ctx, kv_type, elems);
+    const int64_t elems = static_cast<int64_t>(n_kv_heads) * head_dim * n_ctx * n_layer;
+    cache.self_k        = ggml_new_tensor_1d(cache.ctx, kv_type, elems);
+    cache.self_v        = ggml_new_tensor_1d(cache.ctx, kv_type, elems);
     ggml_set_name(cache.self_k, "kv_self_k");
     ggml_set_name(cache.self_v, "kv_self_v");
 
@@ -115,25 +108,22 @@ bool kv_init_batched(KvCache &      cache,
                      int            head_dim,
                      int            n_layer,
                      int            n_batch,
-                     ggml_type      kv_type)
-{
+                     ggml_type      kv_type) {
     if (n_batch <= 1) {
-        if (!kv_init(cache, backend, n_ctx, n_kv_heads, head_dim, n_layer,
-                     kv_type)) {
+        if (!kv_init(cache, backend, n_ctx, n_kv_heads, head_dim, n_layer, kv_type)) {
             return false;
         }
         cache.n_batch = 1;
         return true;
     }
     if (kv_type != GGML_TYPE_F16 && kv_type != GGML_TYPE_F32) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "causal_lm kv_init_batched: unsupported kv_type=%d",
-                     static_cast<int>(kv_type));
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "causal_lm kv_init_batched: unsupported kv_type=%d",
+                static_cast<int>(kv_type));
         return false;
     }
 
-    const size_t ctx_size = 2 * ggml_tensor_overhead() + 256;
-    ggml_init_params params {};
+    const size_t     ctx_size = 2 * ggml_tensor_overhead() + 256;
+    ggml_init_params params{};
     params.mem_size   = ctx_size;
     params.mem_buffer = nullptr;
     params.no_alloc   = true;
@@ -148,17 +138,15 @@ bool kv_init_batched(KvCache &      cache,
     // per-(layer,slot) slab is [kv_dim, n_ctx] contiguous, so prefill's 1D
     // cpy and the step's batched set_rows both address it with a simple
     // (slot + n_batch*layer)*n_ctx*kv_dim offset.
-    const int64_t elems = static_cast<int64_t>(n_kv_heads) * head_dim *
-                          n_ctx * n_batch * n_layer;
-    cache.self_k = ggml_new_tensor_1d(cache.ctx, kv_type, elems);
-    cache.self_v = ggml_new_tensor_1d(cache.ctx, kv_type, elems);
+    const int64_t elems = static_cast<int64_t>(n_kv_heads) * head_dim * n_ctx * n_batch * n_layer;
+    cache.self_k        = ggml_new_tensor_1d(cache.ctx, kv_type, elems);
+    cache.self_v        = ggml_new_tensor_1d(cache.ctx, kv_type, elems);
     ggml_set_name(cache.self_k, "kv_self_k_batched");
     ggml_set_name(cache.self_v, "kv_self_v_batched");
 
     cache.buffer = ggml_backend_alloc_ctx_tensors(cache.ctx, backend);
     if (cache.buffer == nullptr) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "causal_lm kv_init_batched: buffer alloc failed");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "causal_lm kv_init_batched: buffer alloc failed");
         ggml_free(cache.ctx);
         cache.ctx = nullptr;
         return false;
@@ -173,24 +161,22 @@ bool kv_init_batched(KvCache &      cache,
 }
 
 // Block forward — prefill.
-ggml_tensor * block_prefill(
-    ggml_context *      ctx,
-    ggml_cgraph *       gf,
-    ggml_tensor *       x,
-    const BlockView &   view,
-    const BlockParams & params,
-    KvCache &           kv_cache,
-    int                 layer_idx,
-    int                 T_seq,
-    ggml_tensor *       mask,
-    ggml_tensor *       positions,
-    BlockOpts           opts)
-{
+ggml_tensor * block_prefill(ggml_context *      ctx,
+                            ggml_cgraph *       gf,
+                            ggml_tensor *       x,
+                            const BlockView &   view,
+                            const BlockParams & params,
+                            KvCache &           kv_cache,
+                            int                 layer_idx,
+                            int                 T_seq,
+                            ggml_tensor *       mask,
+                            ggml_tensor *       positions,
+                            BlockOpts           opts) {
     const int64_t n_heads    = params.n_heads;
     const int64_t n_kv_heads = params.n_kv_heads;
     const int64_t n_groups   = n_heads / n_kv_heads;
     const int64_t head_dim   = params.head_dim;
-    const int64_t q_dim      = n_heads    * head_dim;
+    const int64_t q_dim      = n_heads * head_dim;
     const int64_t kv_dim     = n_kv_heads * head_dim;
     const int     n_ctx      = kv_cache.n_ctx;
     const float   rms_eps    = params.rms_eps;
@@ -208,7 +194,7 @@ ggml_tensor * block_prefill(
     ggml_tensor * K = mul_mat_f32acc(ctx, view.attn_k_w, x_norm);
     ggml_tensor * V = mul_mat_f32acc(ctx, view.attn_v_w, x_norm);
 
-    Q = ggml_reshape_4d(ctx, Q, head_dim, n_heads,    T_seq, 1);
+    Q = ggml_reshape_4d(ctx, Q, head_dim, n_heads, T_seq, 1);
     K = ggml_reshape_4d(ctx, K, head_dim, n_kv_heads, T_seq, 1);
     V = ggml_reshape_4d(ctx, V, head_dim, n_kv_heads, T_seq, 1);
 
@@ -224,34 +210,23 @@ ggml_tensor * block_prefill(
 
     // RoPE (NeoX rotate_half) on Q and K. MRoPE collapses to NeoX for
     // text-only ASR (every position has the same (T,H,W) coordinate).
-    Q = ggml_rope_ext(ctx, Q, positions, /*c=*/nullptr,
-                      static_cast<int>(head_dim),
-                      GGML_ROPE_TYPE_NEOX,
-                      params.max_position,
-                      rope_theta,
-                      1.0f, 0.0f, 1.0f, 32.0f, 1.0f);
-    K = ggml_rope_ext(ctx, K, positions, nullptr,
-                      static_cast<int>(head_dim),
-                      GGML_ROPE_TYPE_NEOX,
-                      params.max_position,
-                      rope_theta,
-                      1.0f, 0.0f, 1.0f, 32.0f, 1.0f);
+    Q = ggml_rope_ext(ctx, Q, positions, /*c=*/nullptr, static_cast<int>(head_dim), GGML_ROPE_TYPE_NEOX,
+                      params.max_position, rope_theta, 1.0f, 0.0f, 1.0f, 32.0f, 1.0f);
+    K = ggml_rope_ext(ctx, K, positions, nullptr, static_cast<int>(head_dim), GGML_ROPE_TYPE_NEOX, params.max_position,
+                      rope_theta, 1.0f, 0.0f, 1.0f, 32.0f, 1.0f);
 
     // KV write: K, V have ne=[D, Hkv, T_seq, 1], same layout as the cache
     // (position-major within each layer), so a 1D cpy handles it. Slab
     // (layer, batch-slot) base offset in elements; defaults (kv_batch_slot=0,
     // kv_n_batch=1) collapse to layer_idx*n_ctx*kv_dim.
     const size_t slab =
-        static_cast<size_t>(opts.kv_batch_slot) +
-        static_cast<size_t>(opts.kv_n_batch) * static_cast<size_t>(layer_idx);
+        static_cast<size_t>(opts.kv_batch_slot) + static_cast<size_t>(opts.kv_n_batch) * static_cast<size_t>(layer_idx);
     const size_t slab_off = slab * n_ctx * kv_dim;
     {
         const size_t n_elem = static_cast<size_t>(T_seq) * kv_dim;
 
-        ggml_tensor * k_dst = ggml_view_1d(
-            ctx, kv_cache.self_k, n_elem, k_elem * slab_off);
-        ggml_tensor * v_dst = ggml_view_1d(
-            ctx, kv_cache.self_v, n_elem, v_elem * slab_off);
+        ggml_tensor * k_dst = ggml_view_1d(ctx, kv_cache.self_k, n_elem, k_elem * slab_off);
+        ggml_tensor * v_dst = ggml_view_1d(ctx, kv_cache.self_v, n_elem, v_elem * slab_off);
 
         ggml_build_forward_expand(gf, ggml_cpy(ctx, K, k_dst));
         ggml_build_forward_expand(gf, ggml_cpy(ctx, V, v_dst));
@@ -260,18 +235,11 @@ ggml_tensor * block_prefill(
     // Read K, V back from the cache for attention as strided
     // [D, T_seq, Hkv] views (no permute + cont needed). mul_mat and
     // flash_attn_ext both accept strided inputs.
-    ggml_tensor * K_att = ggml_view_3d(
-        ctx, kv_cache.self_k,
-        head_dim, T_seq, n_kv_heads,
-        /*nb1=*/k_elem * kv_dim,
-        /*nb2=*/k_elem * head_dim,
-        k_elem * slab_off);
-    ggml_tensor * V_att = ggml_view_3d(
-        ctx, kv_cache.self_v,
-        head_dim, T_seq, n_kv_heads,
-        v_elem * kv_dim,
-        v_elem * head_dim,
-        v_elem * slab_off);
+    ggml_tensor * K_att = ggml_view_3d(ctx, kv_cache.self_k, head_dim, T_seq, n_kv_heads,
+                                       /*nb1=*/k_elem * kv_dim,
+                                       /*nb2=*/k_elem * head_dim, k_elem * slab_off);
+    ggml_tensor * V_att = ggml_view_3d(ctx, kv_cache.self_v, head_dim, T_seq, n_kv_heads, v_elem * kv_dim,
+                                       v_elem * head_dim, v_elem * slab_off);
 
     // Permute Q for attention: [D, H, T_seq, 1] → [D, T_seq, H, 1].
     ggml_tensor * Q_att = ggml_cont(ctx, ggml_permute(ctx, Q, 0, 2, 1, 3));
@@ -282,38 +250,30 @@ ggml_tensor * block_prefill(
         // n_kv_heads along axis 2 and Q has n_heads — no
         // repeat_interleave needed. Mask is F16 (host upload avoids
         // per-layer ggml_cast).
-        o = ggml_flash_attn_ext(ctx, Q_att, K_att, V_att, mask,
-                                scale_attn, /*max_bias=*/0.0f,
+        o = ggml_flash_attn_ext(ctx, Q_att, K_att, V_att, mask, scale_attn, /*max_bias=*/0.0f,
                                 /*logit_softcap=*/0.0f);
         o = ggml_reshape_2d(ctx, o, q_dim, T_seq);
     } else {
         // Manual GQA path: emulate repeat_interleave via reshape
         // -into-(1,Hkv) → repeat → collapse. Numerics match the
         // reference's explicit repeat_kv.
-        ggml_tensor * K_att_c = ggml_cont(ctx, K_att);
-        ggml_tensor * V_att_c = ggml_cont(ctx, V_att);
-        ggml_tensor * K_4d = ggml_reshape_4d(
-            ctx, K_att_c, head_dim, T_seq, 1, n_kv_heads);
-        ggml_tensor * V_4d = ggml_reshape_4d(
-            ctx, V_att_c, head_dim, T_seq, 1, n_kv_heads);
-        ggml_tensor * K_rep_template = ggml_new_tensor_4d(
-            ctx, K_att->type, head_dim, T_seq, n_groups, n_kv_heads);
-        ggml_tensor * V_rep_template = ggml_new_tensor_4d(
-            ctx, V_att->type, head_dim, T_seq, n_groups, n_kv_heads);
-        ggml_tensor * K_rep = ggml_repeat(ctx, K_4d, K_rep_template);
-        ggml_tensor * V_rep = ggml_repeat(ctx, V_4d, V_rep_template);
-        ggml_tensor * K_full = ggml_reshape_3d(
-            ctx, K_rep, head_dim, T_seq, n_heads);
-        ggml_tensor * V_full = ggml_reshape_3d(
-            ctx, V_rep, head_dim, T_seq, n_heads);
-
-        ggml_tensor * kq = ggml_mul_mat(ctx, K_full, Q_att);
-        ggml_tensor * kq_soft = ggml_soft_max_ext(
-            ctx, kq, mask, scale_attn, /*max_bias=*/0.0f);
-        ggml_tensor * V_t = ggml_cont(ctx, ggml_permute(ctx, V_full, 1, 0, 2, 3));
-        o = ggml_mul_mat(ctx, V_t, kq_soft);
-        o = ggml_cont(ctx, ggml_permute(ctx, o, 0, 2, 1, 3));
-        o = ggml_reshape_2d(ctx, o, q_dim, T_seq);
+        ggml_tensor * K_att_c        = ggml_cont(ctx, K_att);
+        ggml_tensor * V_att_c        = ggml_cont(ctx, V_att);
+        ggml_tensor * K_4d           = ggml_reshape_4d(ctx, K_att_c, head_dim, T_seq, 1, n_kv_heads);
+        ggml_tensor * V_4d           = ggml_reshape_4d(ctx, V_att_c, head_dim, T_seq, 1, n_kv_heads);
+        ggml_tensor * K_rep_template = ggml_new_tensor_4d(ctx, K_att->type, head_dim, T_seq, n_groups, n_kv_heads);
+        ggml_tensor * V_rep_template = ggml_new_tensor_4d(ctx, V_att->type, head_dim, T_seq, n_groups, n_kv_heads);
+        ggml_tensor * K_rep          = ggml_repeat(ctx, K_4d, K_rep_template);
+        ggml_tensor * V_rep          = ggml_repeat(ctx, V_4d, V_rep_template);
+        ggml_tensor * K_full         = ggml_reshape_3d(ctx, K_rep, head_dim, T_seq, n_heads);
+        ggml_tensor * V_full         = ggml_reshape_3d(ctx, V_rep, head_dim, T_seq, n_heads);
+
+        ggml_tensor * kq      = ggml_mul_mat(ctx, K_full, Q_att);
+        ggml_tensor * kq_soft = ggml_soft_max_ext(ctx, kq, mask, scale_attn, /*max_bias=*/0.0f);
+        ggml_tensor * V_t     = ggml_cont(ctx, ggml_permute(ctx, V_full, 1, 0, 2, 3));
+        o                     = ggml_mul_mat(ctx, V_t, kq_soft);
+        o                     = ggml_cont(ctx, ggml_permute(ctx, o, 0, 2, 1, 3));
+        o                     = ggml_reshape_2d(ctx, o, q_dim, T_seq);
     }
 
     o = mul_mat_f32acc(ctx, view.attn_o_w, o);
@@ -322,42 +282,40 @@ ggml_tensor * block_prefill(
     if (opts.slice_last_before_ffn) {
         const int64_t hidden = x->ne[0];
         const size_t  elem   = ggml_element_size(x);
-        x = ggml_view_2d(ctx, x, hidden, 1,
-                         elem * hidden,
-                         elem * hidden * static_cast<size_t>(T_seq - 1));
+        x = ggml_view_2d(ctx, x, hidden, 1, elem * hidden, elem * hidden * static_cast<size_t>(T_seq - 1));
         x = ggml_cont(ctx, x);
     }
 
     ggml_tensor * ff_norm = rms_norm(ctx, x, view.norm_ffn_w, rms_eps);
-    if (view.ffn_scale != nullptr) ff_norm = ggml_mul(ctx, ff_norm, view.ffn_scale);
+    if (view.ffn_scale != nullptr) {
+        ff_norm = ggml_mul(ctx, ff_norm, view.ffn_scale);
+    }
     ggml_tensor * gate_up = mul_mat_f32acc(ctx, view.ffn_gate_up_w, ff_norm);
     ggml_tensor * ff      = ggml_swiglu(ctx, gate_up);
-    ff = mul_mat_f32acc(ctx, view.ffn_down_w, ff);
+    ff                    = mul_mat_f32acc(ctx, view.ffn_down_w, ff);
 
     x = ggml_add(ctx, x, ff);
     return x;
 }
 
 // Block forward — step.
-ggml_tensor * block_step(
-    ggml_context *      ctx,
-    ggml_cgraph *       gf,
-    ggml_tensor *       x,
-    const BlockView &   view,
-    const BlockParams & params,
-    KvCache &           kv_cache,
-    int                 layer_idx,
-    int                 max_n_kv,
-    ggml_tensor *       mask,
-    ggml_tensor *       position,
-    ggml_tensor *       kv_idx,
-    bool                use_flash)
-{
+ggml_tensor * block_step(ggml_context *      ctx,
+                         ggml_cgraph *       gf,
+                         ggml_tensor *       x,
+                         const BlockView &   view,
+                         const BlockParams & params,
+                         KvCache &           kv_cache,
+                         int                 layer_idx,
+                         int                 max_n_kv,
+                         ggml_tensor *       mask,
+                         ggml_tensor *       position,
+                         ggml_tensor *       kv_idx,
+                         bool                use_flash) {
     const int64_t n_heads    = params.n_heads;
     const int64_t n_kv_heads = params.n_kv_heads;
     const int64_t n_groups   = n_heads / n_kv_heads;
     const int64_t head_dim   = params.head_dim;
-    const int64_t q_dim      = n_heads    * head_dim;
+    const int64_t q_dim      = n_heads * head_dim;
     const int64_t kv_dim     = n_kv_heads * head_dim;
     const int     n_ctx      = kv_cache.n_ctx;
     const float   rms_eps    = params.rms_eps;
@@ -373,7 +331,7 @@ ggml_tensor * block_step(
     ggml_tensor * K = mul_mat_f32acc(ctx, view.attn_k_w, x_norm);
     ggml_tensor * V = mul_mat_f32acc(ctx, view.attn_v_w, x_norm);
 
-    Q = ggml_reshape_4d(ctx, Q, head_dim, n_heads,    1, 1);
+    Q = ggml_reshape_4d(ctx, Q, head_dim, n_heads, 1, 1);
     K = ggml_reshape_4d(ctx, K, head_dim, n_kv_heads, 1, 1);
     V = ggml_reshape_4d(ctx, V, head_dim, n_kv_heads, 1, 1);
 
@@ -384,128 +342,97 @@ ggml_tensor * block_step(
         K = ggml_mul(ctx, ggml_rms_norm(ctx, K, rms_eps), view.attn_k_norm);
     }
 
-    Q = ggml_rope_ext(ctx, Q, position, nullptr,
-                      static_cast<int>(head_dim),
-                      GGML_ROPE_TYPE_NEOX,
-                      params.max_position,
+    Q = ggml_rope_ext(ctx, Q, position, nullptr, static_cast<int>(head_dim), GGML_ROPE_TYPE_NEOX, params.max_position,
                       rope_theta, 1.0f, 0.0f, 1.0f, 32.0f, 1.0f);
-    K = ggml_rope_ext(ctx, K, position, nullptr,
-                      static_cast<int>(head_dim),
-                      GGML_ROPE_TYPE_NEOX,
-                      params.max_position,
+    K = ggml_rope_ext(ctx, K, position, nullptr, static_cast<int>(head_dim), GGML_ROPE_TYPE_NEOX, params.max_position,
                       rope_theta, 1.0f, 0.0f, 1.0f, 32.0f, 1.0f);
 
     // KV write via ggml_set_rows with a dynamic index. Static topology;
     // only `kv_idx`'s value changes per step.
     {
-        const size_t layer_off_k =
-            k_elem * static_cast<size_t>(layer_idx) * n_ctx * kv_dim;
-        const size_t layer_off_v =
-            v_elem * static_cast<size_t>(layer_idx) * n_ctx * kv_dim;
-
-        ggml_tensor * k_layer = ggml_view_2d(
-            ctx, kv_cache.self_k,
-            kv_dim, n_ctx,
-            k_elem * kv_dim, layer_off_k);
-        ggml_tensor * v_layer = ggml_view_2d(
-            ctx, kv_cache.self_v,
-            kv_dim, n_ctx,
-            v_elem * kv_dim, layer_off_v);
+        const size_t layer_off_k = k_elem * static_cast<size_t>(layer_idx) * n_ctx * kv_dim;
+        const size_t layer_off_v = v_elem * static_cast<size_t>(layer_idx) * n_ctx * kv_dim;
+
+        ggml_tensor * k_layer = ggml_view_2d(ctx, kv_cache.self_k, kv_dim, n_ctx, k_elem * kv_dim, layer_off_k);
+        ggml_tensor * v_layer = ggml_view_2d(ctx, kv_cache.self_v, kv_dim, n_ctx, v_elem * kv_dim, layer_off_v);
 
         ggml_tensor * K_row = ggml_reshape_2d(ctx, K, kv_dim, 1);
         ggml_tensor * V_row = ggml_reshape_2d(ctx, V, kv_dim, 1);
 
-        ggml_build_forward_expand(
-            gf, ggml_set_rows(ctx, k_layer, K_row, kv_idx));
-        ggml_build_forward_expand(
-            gf, ggml_set_rows(ctx, v_layer, V_row, kv_idx));
+        ggml_build_forward_expand(gf, ggml_set_rows(ctx, k_layer, K_row, kv_idx));
+        ggml_build_forward_expand(gf, ggml_set_rows(ctx, v_layer, V_row, kv_idx));
     }
 
     // Attention reads the FULL [0, max_n_kv) window. Mask zeros valid
     // positions and -inf's the rest, so softmax ignores empty slots; the
     // graph stays static (zero per-step rebuild).
-    const size_t layer_off_bytes =
-        k_elem * static_cast<size_t>(layer_idx) * n_ctx * kv_dim;
-    ggml_tensor * K_att = ggml_view_3d(
-        ctx, kv_cache.self_k,
-        head_dim, max_n_kv, n_kv_heads,
-        k_elem * kv_dim, k_elem * head_dim,
-        layer_off_bytes);
-    ggml_tensor * V_att = ggml_view_3d(
-        ctx, kv_cache.self_v,
-        head_dim, max_n_kv, n_kv_heads,
-        v_elem * kv_dim, v_elem * head_dim,
-        v_elem * static_cast<size_t>(layer_idx) * n_ctx * kv_dim);
+    const size_t  layer_off_bytes = k_elem * static_cast<size_t>(layer_idx) * n_ctx * kv_dim;
+    ggml_tensor * K_att           = ggml_view_3d(ctx, kv_cache.self_k, head_dim, max_n_kv, n_kv_heads, k_elem * kv_dim,
+                                                 k_elem * head_dim, layer_off_bytes);
+    ggml_tensor * V_att = ggml_view_3d(ctx, kv_cache.self_v, head_dim, max_n_kv, n_kv_heads, v_elem * kv_dim,
+                                       v_elem * head_dim, v_elem * static_cast<size_t>(layer_idx) * n_ctx * kv_dim);
 
     ggml_tensor * Q_att = ggml_cont(ctx, ggml_permute(ctx, Q, 0, 2, 1, 3));
 
     ggml_tensor * o;
     if (use_flash) {
-        o = ggml_flash_attn_ext(ctx, Q_att, K_att, V_att, mask,
-                                scale_attn, /*max_bias=*/0.0f,
+        o = ggml_flash_attn_ext(ctx, Q_att, K_att, V_att, mask, scale_attn, /*max_bias=*/0.0f,
                                 /*logit_softcap=*/0.0f);
         o = ggml_reshape_2d(ctx, o, q_dim, 1);
     } else {
-        ggml_tensor * K_att_c = ggml_cont(ctx, K_att);
-        ggml_tensor * V_att_c = ggml_cont(ctx, V_att);
-        ggml_tensor * K_4d = ggml_reshape_4d(
-            ctx, K_att_c, head_dim, max_n_kv, 1, n_kv_heads);
-        ggml_tensor * V_4d = ggml_reshape_4d(
-            ctx, V_att_c, head_dim, max_n_kv, 1, n_kv_heads);
-        ggml_tensor * K_rep_template = ggml_new_tensor_4d(
-            ctx, K_att->type, head_dim, max_n_kv, n_groups, n_kv_heads);
-        ggml_tensor * V_rep_template = ggml_new_tensor_4d(
-            ctx, V_att->type, head_dim, max_n_kv, n_groups, n_kv_heads);
-        ggml_tensor * K_rep = ggml_repeat(ctx, K_4d, K_rep_template);
-        ggml_tensor * V_rep = ggml_repeat(ctx, V_4d, V_rep_template);
-        ggml_tensor * K_full = ggml_reshape_3d(
-            ctx, K_rep, head_dim, max_n_kv, n_heads);
-        ggml_tensor * V_full = ggml_reshape_3d(
-            ctx, V_rep, head_dim, max_n_kv, n_heads);
-
-        ggml_tensor * kq = ggml_mul_mat(ctx, K_full, Q_att);
-        ggml_tensor * kq_soft = ggml_soft_max_ext(
-            ctx, kq, mask, scale_attn, /*max_bias=*/0.0f);
-        ggml_tensor * V_t = ggml_cont(ctx, ggml_permute(ctx, V_full, 1, 0, 2, 3));
-        o = ggml_mul_mat(ctx, V_t, kq_soft);
-        o = ggml_cont(ctx, ggml_permute(ctx, o, 0, 2, 1, 3));
-        o = ggml_reshape_2d(ctx, o, q_dim, 1);
+        ggml_tensor * K_att_c        = ggml_cont(ctx, K_att);
+        ggml_tensor * V_att_c        = ggml_cont(ctx, V_att);
+        ggml_tensor * K_4d           = ggml_reshape_4d(ctx, K_att_c, head_dim, max_n_kv, 1, n_kv_heads);
+        ggml_tensor * V_4d           = ggml_reshape_4d(ctx, V_att_c, head_dim, max_n_kv, 1, n_kv_heads);
+        ggml_tensor * K_rep_template = ggml_new_tensor_4d(ctx, K_att->type, head_dim, max_n_kv, n_groups, n_kv_heads);
+        ggml_tensor * V_rep_template = ggml_new_tensor_4d(ctx, V_att->type, head_dim, max_n_kv, n_groups, n_kv_heads);
+        ggml_tensor * K_rep          = ggml_repeat(ctx, K_4d, K_rep_template);
+        ggml_tensor * V_rep          = ggml_repeat(ctx, V_4d, V_rep_template);
+        ggml_tensor * K_full         = ggml_reshape_3d(ctx, K_rep, head_dim, max_n_kv, n_heads);
+        ggml_tensor * V_full         = ggml_reshape_3d(ctx, V_rep, head_dim, max_n_kv, n_heads);
+
+        ggml_tensor * kq      = ggml_mul_mat(ctx, K_full, Q_att);
+        ggml_tensor * kq_soft = ggml_soft_max_ext(ctx, kq, mask, scale_attn, /*max_bias=*/0.0f);
+        ggml_tensor * V_t     = ggml_cont(ctx, ggml_permute(ctx, V_full, 1, 0, 2, 3));
+        o                     = ggml_mul_mat(ctx, V_t, kq_soft);
+        o                     = ggml_cont(ctx, ggml_permute(ctx, o, 0, 2, 1, 3));
+        o                     = ggml_reshape_2d(ctx, o, q_dim, 1);
     }
 
     o = mul_mat_f32acc(ctx, view.attn_o_w, o);
     x = ggml_add(ctx, x, o);
 
     ggml_tensor * ff_norm = rms_norm(ctx, x, view.norm_ffn_w, rms_eps);
-    if (view.ffn_scale != nullptr) ff_norm = ggml_mul(ctx, ff_norm, view.ffn_scale);
+    if (view.ffn_scale != nullptr) {
+        ff_norm = ggml_mul(ctx, ff_norm, view.ffn_scale);
+    }
     ggml_tensor * gate_up = mul_mat_f32acc(ctx, view.ffn_gate_up_w, ff_norm);
     ggml_tensor * ff      = ggml_swiglu(ctx, gate_up);
-    ff = mul_mat_f32acc(ctx, view.ffn_down_w, ff);
+    ff                    = mul_mat_f32acc(ctx, view.ffn_down_w, ff);
 
     x = ggml_add(ctx, x, ff);
     return x;
 }
 
 // Block forward — multi-position step (T_seq positions, single utterance).
-ggml_tensor * block_step_n(
-    ggml_context *      ctx,
-    ggml_cgraph *       gf,
-    ggml_tensor *       x,
-    const BlockView &   view,
-    const BlockParams & params,
-    KvCache &           kv_cache,
-    int                 layer_idx,
-    int                 T_seq,
-    int                 max_n_kv,
-    ggml_tensor *       mask,
-    ggml_tensor *       positions,
-    ggml_tensor *       kv_idx,
-    bool                use_flash)
-{
+ggml_tensor * block_step_n(ggml_context *      ctx,
+                           ggml_cgraph *       gf,
+                           ggml_tensor *       x,
+                           const BlockView &   view,
+                           const BlockParams & params,
+                           KvCache &           kv_cache,
+                           int                 layer_idx,
+                           int                 T_seq,
+                           int                 max_n_kv,
+                           ggml_tensor *       mask,
+                           ggml_tensor *       positions,
+                           ggml_tensor *       kv_idx,
+                           bool                use_flash) {
     const int64_t n_heads    = params.n_heads;
     const int64_t n_kv_heads = params.n_kv_heads;
     const int64_t n_groups   = n_heads / n_kv_heads;
     const int64_t head_dim   = params.head_dim;
-    const int64_t q_dim      = n_heads    * head_dim;
+    const int64_t q_dim      = n_heads * head_dim;
     const int64_t kv_dim     = n_kv_heads * head_dim;
     const int     n_ctx      = kv_cache.n_ctx;
     const float   rms_eps    = params.rms_eps;
@@ -521,7 +448,7 @@ ggml_tensor * block_step_n(
     ggml_tensor * K = mul_mat_f32acc(ctx, view.attn_k_w, x_norm);
     ggml_tensor * V = mul_mat_f32acc(ctx, view.attn_v_w, x_norm);
 
-    Q = ggml_reshape_4d(ctx, Q, head_dim, n_heads,    T_seq, 1);
+    Q = ggml_reshape_4d(ctx, Q, head_dim, n_heads, T_seq, 1);
     K = ggml_reshape_4d(ctx, K, head_dim, n_kv_heads, T_seq, 1);
     V = ggml_reshape_4d(ctx, V, head_dim, n_kv_heads, T_seq, 1);
 
@@ -532,124 +459,93 @@ ggml_tensor * block_step_n(
         K = ggml_mul(ctx, ggml_rms_norm(ctx, K, rms_eps), view.attn_k_norm);
     }
 
-    Q = ggml_rope_ext(ctx, Q, positions, nullptr,
-                      static_cast<int>(head_dim),
-                      GGML_ROPE_TYPE_NEOX,
-                      params.max_position,
+    Q = ggml_rope_ext(ctx, Q, positions, nullptr, static_cast<int>(head_dim), GGML_ROPE_TYPE_NEOX, params.max_position,
                       rope_theta, 1.0f, 0.0f, 1.0f, 32.0f, 1.0f);
-    K = ggml_rope_ext(ctx, K, positions, nullptr,
-                      static_cast<int>(head_dim),
-                      GGML_ROPE_TYPE_NEOX,
-                      params.max_position,
+    K = ggml_rope_ext(ctx, K, positions, nullptr, static_cast<int>(head_dim), GGML_ROPE_TYPE_NEOX, params.max_position,
                       rope_theta, 1.0f, 0.0f, 1.0f, 32.0f, 1.0f);
 
     // KV write: T_seq rows at indices kv_idx[T_seq].
     {
-        const size_t layer_off_k =
-            k_elem * static_cast<size_t>(layer_idx) * n_ctx * kv_dim;
-        const size_t layer_off_v =
-            v_elem * static_cast<size_t>(layer_idx) * n_ctx * kv_dim;
-
-        ggml_tensor * k_layer = ggml_view_2d(
-            ctx, kv_cache.self_k,
-            kv_dim, n_ctx,
-            k_elem * kv_dim, layer_off_k);
-        ggml_tensor * v_layer = ggml_view_2d(
-            ctx, kv_cache.self_v,
-            kv_dim, n_ctx,
-            v_elem * kv_dim, layer_off_v);
+        const size_t layer_off_k = k_elem * static_cast<size_t>(layer_idx) * n_ctx * kv_dim;
+        const size_t layer_off_v = v_elem * static_cast<size_t>(layer_idx) * n_ctx * kv_dim;
+
+        ggml_tensor * k_layer = ggml_view_2d(ctx, kv_cache.self_k, kv_dim, n_ctx, k_elem * kv_dim, layer_off_k);
+        ggml_tensor * v_layer = ggml_view_2d(ctx, kv_cache.self_v, kv_dim, n_ctx, v_elem * kv_dim, layer_off_v);
 
         ggml_tensor * K_rows = ggml_reshape_2d(ctx, K, kv_dim, T_seq);
         ggml_tensor * V_rows = ggml_reshape_2d(ctx, V, kv_dim, T_seq);
 
-        ggml_build_forward_expand(
-            gf, ggml_set_rows(ctx, k_layer, K_rows, kv_idx));
-        ggml_build_forward_expand(
-            gf, ggml_set_rows(ctx, v_layer, V_rows, kv_idx));
+        ggml_build_forward_expand(gf, ggml_set_rows(ctx, k_layer, K_rows, kv_idx));
+        ggml_build_forward_expand(gf, ggml_set_rows(ctx, v_layer, V_rows, kv_idx));
     }
 
-    const size_t layer_off_bytes =
-        k_elem * static_cast<size_t>(layer_idx) * n_ctx * kv_dim;
-    ggml_tensor * K_att = ggml_view_3d(
-        ctx, kv_cache.self_k,
-        head_dim, max_n_kv, n_kv_heads,
-        k_elem * kv_dim, k_elem * head_dim,
-        layer_off_bytes);
-    ggml_tensor * V_att = ggml_view_3d(
-        ctx, kv_cache.self_v,
-        head_dim, max_n_kv, n_kv_heads,
-        v_elem * kv_dim, v_elem * head_dim,
-        v_elem * static_cast<size_t>(layer_idx) * n_ctx * kv_dim);
+    const size_t  layer_off_bytes = k_elem * static_cast<size_t>(layer_idx) * n_ctx * kv_dim;
+    ggml_tensor * K_att           = ggml_view_3d(ctx, kv_cache.self_k, head_dim, max_n_kv, n_kv_heads, k_elem * kv_dim,
+                                                 k_elem * head_dim, layer_off_bytes);
+    ggml_tensor * V_att = ggml_view_3d(ctx, kv_cache.self_v, head_dim, max_n_kv, n_kv_heads, v_elem * kv_dim,
+                                       v_elem * head_dim, v_elem * static_cast<size_t>(layer_idx) * n_ctx * kv_dim);
 
     // Q permute: [head_dim, n_heads, T_seq, 1] → [head_dim, T_seq, n_heads, 1]
     ggml_tensor * Q_att = ggml_cont(ctx, ggml_permute(ctx, Q, 0, 2, 1, 3));
 
     ggml_tensor * o;
     if (use_flash) {
-        o = ggml_flash_attn_ext(ctx, Q_att, K_att, V_att, mask,
-                                scale_attn, /*max_bias=*/0.0f,
+        o = ggml_flash_attn_ext(ctx, Q_att, K_att, V_att, mask, scale_attn, /*max_bias=*/0.0f,
                                 /*logit_softcap=*/0.0f);
         o = ggml_reshape_2d(ctx, o, q_dim, T_seq);
     } else {
-        ggml_tensor * K_att_c = ggml_cont(ctx, K_att);
-        ggml_tensor * V_att_c = ggml_cont(ctx, V_att);
-        ggml_tensor * K_4d = ggml_reshape_4d(
-            ctx, K_att_c, head_dim, max_n_kv, 1, n_kv_heads);
-        ggml_tensor * V_4d = ggml_reshape_4d(
-            ctx, V_att_c, head_dim, max_n_kv, 1, n_kv_heads);
-        ggml_tensor * K_rep_template = ggml_new_tensor_4d(
-            ctx, K_att->type, head_dim, max_n_kv, n_groups, n_kv_heads);
-        ggml_tensor * V_rep_template = ggml_new_tensor_4d(
-            ctx, V_att->type, head_dim, max_n_kv, n_groups, n_kv_heads);
-        ggml_tensor * K_rep = ggml_repeat(ctx, K_4d, K_rep_template);
-        ggml_tensor * V_rep = ggml_repeat(ctx, V_4d, V_rep_template);
-        ggml_tensor * K_full = ggml_reshape_3d(
-            ctx, K_rep, head_dim, max_n_kv, n_heads);
-        ggml_tensor * V_full = ggml_reshape_3d(
-            ctx, V_rep, head_dim, max_n_kv, n_heads);
-
-        ggml_tensor * kq = ggml_mul_mat(ctx, K_full, Q_att);
-        ggml_tensor * kq_soft = ggml_soft_max_ext(
-            ctx, kq, mask, scale_attn, /*max_bias=*/0.0f);
-        ggml_tensor * V_t = ggml_cont(ctx, ggml_permute(ctx, V_full, 1, 0, 2, 3));
-        o = ggml_mul_mat(ctx, V_t, kq_soft);
-        o = ggml_cont(ctx, ggml_permute(ctx, o, 0, 2, 1, 3));
-        o = ggml_reshape_2d(ctx, o, q_dim, T_seq);
+        ggml_tensor * K_att_c        = ggml_cont(ctx, K_att);
+        ggml_tensor * V_att_c        = ggml_cont(ctx, V_att);
+        ggml_tensor * K_4d           = ggml_reshape_4d(ctx, K_att_c, head_dim, max_n_kv, 1, n_kv_heads);
+        ggml_tensor * V_4d           = ggml_reshape_4d(ctx, V_att_c, head_dim, max_n_kv, 1, n_kv_heads);
+        ggml_tensor * K_rep_template = ggml_new_tensor_4d(ctx, K_att->type, head_dim, max_n_kv, n_groups, n_kv_heads);
+        ggml_tensor * V_rep_template = ggml_new_tensor_4d(ctx, V_att->type, head_dim, max_n_kv, n_groups, n_kv_heads);
+        ggml_tensor * K_rep          = ggml_repeat(ctx, K_4d, K_rep_template);
+        ggml_tensor * V_rep          = ggml_repeat(ctx, V_4d, V_rep_template);
+        ggml_tensor * K_full         = ggml_reshape_3d(ctx, K_rep, head_dim, max_n_kv, n_heads);
+        ggml_tensor * V_full         = ggml_reshape_3d(ctx, V_rep, head_dim, max_n_kv, n_heads);
+
+        ggml_tensor * kq      = ggml_mul_mat(ctx, K_full, Q_att);
+        ggml_tensor * kq_soft = ggml_soft_max_ext(ctx, kq, mask, scale_attn, /*max_bias=*/0.0f);
+        ggml_tensor * V_t     = ggml_cont(ctx, ggml_permute(ctx, V_full, 1, 0, 2, 3));
+        o                     = ggml_mul_mat(ctx, V_t, kq_soft);
+        o                     = ggml_cont(ctx, ggml_permute(ctx, o, 0, 2, 1, 3));
+        o                     = ggml_reshape_2d(ctx, o, q_dim, T_seq);
     }
 
     o = mul_mat_f32acc(ctx, view.attn_o_w, o);
     x = ggml_add(ctx, x, o);
 
     ggml_tensor * ff_norm = rms_norm(ctx, x, view.norm_ffn_w, rms_eps);
-    if (view.ffn_scale != nullptr) ff_norm = ggml_mul(ctx, ff_norm, view.ffn_scale);
+    if (view.ffn_scale != nullptr) {
+        ff_norm = ggml_mul(ctx, ff_norm, view.ffn_scale);
+    }
     ggml_tensor * gate_up = mul_mat_f32acc(ctx, view.ffn_gate_up_w, ff_norm);
     ggml_tensor * ff      = ggml_swiglu(ctx, gate_up);
-    ff = mul_mat_f32acc(ctx, view.ffn_down_w, ff);
+    ff                    = mul_mat_f32acc(ctx, view.ffn_down_w, ff);
 
     x = ggml_add(ctx, x, ff);
     return x;
 }
 
 // Block forward — batched step (B utterances).
-ggml_tensor * block_step_batched(
-    ggml_context *      ctx,
-    ggml_cgraph *       gf,
-    ggml_tensor *       x,          // [hidden, B]
-    const BlockView &   view,
-    const BlockParams & params,
-    KvCache &           kv_cache,
-    int                 layer_idx,
-    int                 max_n_kv,
-    int                 n_batch,
-    ggml_tensor *       mask,       // [max_n_kv, 1, 1, B] f16
-    ggml_tensor *       position,   // [B] i32
-    ggml_tensor *       kv_idx,     // [1, B] i64
-    bool                use_flash)
-{
+ggml_tensor * block_step_batched(ggml_context *      ctx,
+                                 ggml_cgraph *       gf,
+                                 ggml_tensor *       x,  // [hidden, B]
+                                 const BlockView &   view,
+                                 const BlockParams & params,
+                                 KvCache &           kv_cache,
+                                 int                 layer_idx,
+                                 int                 max_n_kv,
+                                 int                 n_batch,
+                                 ggml_tensor *       mask,      // [max_n_kv, 1, 1, B] f16
+                                 ggml_tensor *       position,  // [B] i32
+                                 ggml_tensor *       kv_idx,    // [1, B] i64
+                                 bool                use_flash) {
     const int64_t n_heads    = params.n_heads;
     const int64_t n_kv_heads = params.n_kv_heads;
     const int64_t head_dim   = params.head_dim;
-    const int64_t q_dim      = n_heads    * head_dim;
+    const int64_t q_dim      = n_heads * head_dim;
     const int64_t kv_dim     = n_kv_heads * head_dim;
     const int64_t n_ctx      = kv_cache.n_ctx;
     const int64_t B          = n_batch;
@@ -668,7 +564,7 @@ ggml_tensor * block_step_batched(
 
     // Batch on ne[2] (the per-token/position axis) so RoPE applies each
     // utterance's own position. T == 1 per utterance, so ne[2] == B.
-    Q = ggml_reshape_3d(ctx, Q, head_dim, n_heads,    B);
+    Q = ggml_reshape_3d(ctx, Q, head_dim, n_heads, B);
     K = ggml_reshape_3d(ctx, K, head_dim, n_kv_heads, B);
     V = ggml_reshape_3d(ctx, V, head_dim, n_kv_heads, B);
 
@@ -680,70 +576,52 @@ ggml_tensor * block_step_batched(
     }
 
     // position [B] indexes ne[2]: row b is rotated by position[b].
-    Q = ggml_rope_ext(ctx, Q, position, nullptr,
-                      static_cast<int>(head_dim),
-                      GGML_ROPE_TYPE_NEOX, params.max_position,
+    Q = ggml_rope_ext(ctx, Q, position, nullptr, static_cast<int>(head_dim), GGML_ROPE_TYPE_NEOX, params.max_position,
                       rope_theta, 1.0f, 0.0f, 1.0f, 32.0f, 1.0f);
-    K = ggml_rope_ext(ctx, K, position, nullptr,
-                      static_cast<int>(head_dim),
-                      GGML_ROPE_TYPE_NEOX, params.max_position,
+    K = ggml_rope_ext(ctx, K, position, nullptr, static_cast<int>(head_dim), GGML_ROPE_TYPE_NEOX, params.max_position,
                       rope_theta, 1.0f, 0.0f, 1.0f, 32.0f, 1.0f);
 
     // Batched KV write: per layer the cache slab is [kv_dim, n_ctx, B]; one
     // ggml_set_rows writes B rows at B independent indices kv_idx[b].
     {
-        const size_t layer_off_k =
-            k_elem * static_cast<size_t>(layer_idx) * n_ctx * kv_dim * B;
-        const size_t layer_off_v =
-            v_elem * static_cast<size_t>(layer_idx) * n_ctx * kv_dim * B;
-
-        ggml_tensor * k_layer = ggml_view_3d(
-            ctx, kv_cache.self_k, kv_dim, n_ctx, B,
-            k_elem * kv_dim, k_elem * kv_dim * n_ctx, layer_off_k);
-        ggml_tensor * v_layer = ggml_view_3d(
-            ctx, kv_cache.self_v, kv_dim, n_ctx, B,
-            v_elem * kv_dim, v_elem * kv_dim * n_ctx, layer_off_v);
+        const size_t layer_off_k = k_elem * static_cast<size_t>(layer_idx) * n_ctx * kv_dim * B;
+        const size_t layer_off_v = v_elem * static_cast<size_t>(layer_idx) * n_ctx * kv_dim * B;
+
+        ggml_tensor * k_layer =
+            ggml_view_3d(ctx, kv_cache.self_k, kv_dim, n_ctx, B, k_elem * kv_dim, k_elem * kv_dim * n_ctx, layer_off_k);
+        ggml_tensor * v_layer =
+            ggml_view_3d(ctx, kv_cache.self_v, kv_dim, n_ctx, B, v_elem * kv_dim, v_elem * kv_dim * n_ctx, layer_off_v);
 
         ggml_tensor * K_row = ggml_reshape_3d(ctx, K, kv_dim, 1, B);
         ggml_tensor * V_row = ggml_reshape_3d(ctx, V, kv_dim, 1, B);
 
-        ggml_build_forward_expand(
-            gf, ggml_set_rows(ctx, k_layer, K_row, kv_idx));
-        ggml_build_forward_expand(
-            gf, ggml_set_rows(ctx, v_layer, V_row, kv_idx));
+        ggml_build_forward_expand(gf, ggml_set_rows(ctx, k_layer, K_row, kv_idx));
+        ggml_build_forward_expand(gf, ggml_set_rows(ctx, v_layer, V_row, kv_idx));
     }
 
     // Attention read: [head_dim, max_n_kv, n_kv_heads, B] per layer.
-    const size_t layer_off_bytes_k =
-        k_elem * static_cast<size_t>(layer_idx) * n_ctx * kv_dim * B;
-    const size_t layer_off_bytes_v =
-        v_elem * static_cast<size_t>(layer_idx) * n_ctx * kv_dim * B;
-    ggml_tensor * K_att = ggml_view_4d(
-        ctx, kv_cache.self_k, head_dim, max_n_kv, n_kv_heads, B,
-        /*nb1=*/k_elem * kv_dim,
-        /*nb2=*/k_elem * head_dim,
-        /*nb3=*/k_elem * kv_dim * n_ctx,
-        layer_off_bytes_k);
-    ggml_tensor * V_att = ggml_view_4d(
-        ctx, kv_cache.self_v, head_dim, max_n_kv, n_kv_heads, B,
-        v_elem * kv_dim, v_elem * head_dim, v_elem * kv_dim * n_ctx,
-        layer_off_bytes_v);
+    const size_t  layer_off_bytes_k = k_elem * static_cast<size_t>(layer_idx) * n_ctx * kv_dim * B;
+    const size_t  layer_off_bytes_v = v_elem * static_cast<size_t>(layer_idx) * n_ctx * kv_dim * B;
+    ggml_tensor * K_att             = ggml_view_4d(ctx, kv_cache.self_k, head_dim, max_n_kv, n_kv_heads, B,
+                                                   /*nb1=*/k_elem * kv_dim,
+                                                   /*nb2=*/k_elem * head_dim,
+                                                   /*nb3=*/k_elem * kv_dim * n_ctx, layer_off_bytes_k);
+    ggml_tensor * V_att = ggml_view_4d(ctx, kv_cache.self_v, head_dim, max_n_kv, n_kv_heads, B, v_elem * kv_dim,
+                                       v_elem * head_dim, v_elem * kv_dim * n_ctx, layer_off_bytes_v);
 
     // Q for flash: [head_dim, n_heads, B, 1] → [head_dim, 1, n_heads, B].
     ggml_tensor * Q_att = ggml_cont(ctx, ggml_permute(ctx, Q, 0, 2, 3, 1));
 
     ggml_tensor * o;
     if (use_flash) {
-        o = ggml_flash_attn_ext(ctx, Q_att, K_att, V_att, mask,
-                                scale_attn, /*max_bias=*/0.0f,
+        o = ggml_flash_attn_ext(ctx, Q_att, K_att, V_att, mask, scale_attn, /*max_bias=*/0.0f,
                                 /*logit_softcap=*/0.0f);
         // o = [head_dim, n_heads, 1, B] → [q_dim, B].
         o = ggml_reshape_2d(ctx, o, q_dim, B);
     } else {
         // The manual GQA path is single-shot only; batched decode requires
         // flash. Callers gate on use_flash and fall back to serial run().
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "causal_lm block_step_batched: non-flash path unsupported");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "causal_lm block_step_batched: non-flash path unsupported");
         return nullptr;
     }
 
@@ -751,35 +629,35 @@ ggml_tensor * block_step_batched(
     x = ggml_add(ctx, x, o);
 
     ggml_tensor * ff_norm = rms_norm(ctx, x, view.norm_ffn_w, rms_eps);
-    if (view.ffn_scale != nullptr) ff_norm = ggml_mul(ctx, ff_norm, view.ffn_scale);
+    if (view.ffn_scale != nullptr) {
+        ff_norm = ggml_mul(ctx, ff_norm, view.ffn_scale);
+    }
     ggml_tensor * gate_up = mul_mat_f32acc(ctx, view.ffn_gate_up_w, ff_norm);
     ggml_tensor * ff      = ggml_swiglu(ctx, gate_up);
-    ff = mul_mat_f32acc(ctx, view.ffn_down_w, ff);
+    ff                    = mul_mat_f32acc(ctx, view.ffn_down_w, ff);
 
     x = ggml_add(ctx, x, ff);
     return x;
 }
 
 // Block forward — batched prefill (B utterances, T tokens each).
-ggml_tensor * block_prefill_batched(
-    ggml_context *      ctx,
-    ggml_cgraph *       gf,
-    ggml_tensor *       x,          // [hidden, T, B]
-    const BlockView &   view,
-    const BlockParams & params,
-    KvCache &           kv_cache,
-    int                 layer_idx,
-    int                 T_seq,
-    int                 n_batch,
-    ggml_tensor *       mask,       // [T_seq, T_seq] f16 causal
-    ggml_tensor *       positions,  // [T_seq] i32
-    ggml_tensor *       kv_idx,     // [T_seq, B] i64
-    bool                use_flash)
-{
+ggml_tensor * block_prefill_batched(ggml_context *      ctx,
+                                    ggml_cgraph *       gf,
+                                    ggml_tensor *       x,  // [hidden, T, B]
+                                    const BlockView &   view,
+                                    const BlockParams & params,
+                                    KvCache &           kv_cache,
+                                    int                 layer_idx,
+                                    int                 T_seq,
+                                    int                 n_batch,
+                                    ggml_tensor *       mask,       // [T_seq, T_seq] f16 causal
+                                    ggml_tensor *       positions,  // [T_seq] i32
+                                    ggml_tensor *       kv_idx,     // [T_seq, B] i64
+                                    bool                use_flash) {
     const int64_t n_heads    = params.n_heads;
     const int64_t n_kv_heads = params.n_kv_heads;
     const int64_t head_dim   = params.head_dim;
-    const int64_t q_dim      = n_heads    * head_dim;
+    const int64_t q_dim      = n_heads * head_dim;
     const int64_t kv_dim     = n_kv_heads * head_dim;
     const int64_t n_ctx      = kv_cache.n_ctx;
     const int64_t T          = T_seq;
@@ -797,7 +675,7 @@ ggml_tensor * block_prefill_batched(
     ggml_tensor * K = mul_mat_f32acc(ctx, view.attn_k_w, x_norm);  // [kv_dim, T, B]
     ggml_tensor * V = mul_mat_f32acc(ctx, view.attn_v_w, x_norm);  // [kv_dim, T, B]
 
-    Q = ggml_reshape_4d(ctx, Q, head_dim, n_heads,    T, B);
+    Q = ggml_reshape_4d(ctx, Q, head_dim, n_heads, T, B);
     K = ggml_reshape_4d(ctx, K, head_dim, n_kv_heads, T, B);
     V = ggml_reshape_4d(ctx, V, head_dim, n_kv_heads, T, B);
 
@@ -809,61 +687,45 @@ ggml_tensor * block_prefill_batched(
     }
 
     // RoPE position indexes ne[2] (the time axis); shared across heads/batch.
-    Q = ggml_rope_ext(ctx, Q, positions, nullptr, static_cast<int>(head_dim),
-                      GGML_ROPE_TYPE_NEOX, params.max_position,
+    Q = ggml_rope_ext(ctx, Q, positions, nullptr, static_cast<int>(head_dim), GGML_ROPE_TYPE_NEOX, params.max_position,
                       rope_theta, 1.0f, 0.0f, 1.0f, 32.0f, 1.0f);
-    K = ggml_rope_ext(ctx, K, positions, nullptr, static_cast<int>(head_dim),
-                      GGML_ROPE_TYPE_NEOX, params.max_position,
+    K = ggml_rope_ext(ctx, K, positions, nullptr, static_cast<int>(head_dim), GGML_ROPE_TYPE_NEOX, params.max_position,
                       rope_theta, 1.0f, 0.0f, 1.0f, 32.0f, 1.0f);
 
     // Batched KV write: each utterance's T rows -> [0, T) of its slab.
     {
-        const size_t layer_off_k =
-            k_elem * static_cast<size_t>(layer_idx) * n_ctx * kv_dim * B;
-        const size_t layer_off_v =
-            v_elem * static_cast<size_t>(layer_idx) * n_ctx * kv_dim * B;
-        ggml_tensor * k_layer = ggml_view_3d(
-            ctx, kv_cache.self_k, kv_dim, n_ctx, B,
-            k_elem * kv_dim, k_elem * kv_dim * n_ctx, layer_off_k);
-        ggml_tensor * v_layer = ggml_view_3d(
-            ctx, kv_cache.self_v, kv_dim, n_ctx, B,
-            v_elem * kv_dim, v_elem * kv_dim * n_ctx, layer_off_v);
+        const size_t  layer_off_k = k_elem * static_cast<size_t>(layer_idx) * n_ctx * kv_dim * B;
+        const size_t  layer_off_v = v_elem * static_cast<size_t>(layer_idx) * n_ctx * kv_dim * B;
+        ggml_tensor * k_layer =
+            ggml_view_3d(ctx, kv_cache.self_k, kv_dim, n_ctx, B, k_elem * kv_dim, k_elem * kv_dim * n_ctx, layer_off_k);
+        ggml_tensor * v_layer =
+            ggml_view_3d(ctx, kv_cache.self_v, kv_dim, n_ctx, B, v_elem * kv_dim, v_elem * kv_dim * n_ctx, layer_off_v);
 
         // K/V are [head_dim, n_kv_heads, T, B]; collapse heads -> [kv_dim, T, B].
         ggml_tensor * K_rows = ggml_reshape_3d(ctx, K, kv_dim, T, B);
         ggml_tensor * V_rows = ggml_reshape_3d(ctx, V, kv_dim, T, B);
 
-        ggml_build_forward_expand(
-            gf, ggml_set_rows(ctx, k_layer, K_rows, kv_idx));
-        ggml_build_forward_expand(
-            gf, ggml_set_rows(ctx, v_layer, V_rows, kv_idx));
+        ggml_build_forward_expand(gf, ggml_set_rows(ctx, k_layer, K_rows, kv_idx));
+        ggml_build_forward_expand(gf, ggml_set_rows(ctx, v_layer, V_rows, kv_idx));
     }
 
     // Attention read: [head_dim, T, n_kv_heads, B] (positions [0, T)).
-    const size_t layer_off_bytes_k =
-        k_elem * static_cast<size_t>(layer_idx) * n_ctx * kv_dim * B;
-    const size_t layer_off_bytes_v =
-        v_elem * static_cast<size_t>(layer_idx) * n_ctx * kv_dim * B;
-    ggml_tensor * K_att = ggml_view_4d(
-        ctx, kv_cache.self_k, head_dim, T, n_kv_heads, B,
-        k_elem * kv_dim, k_elem * head_dim, k_elem * kv_dim * n_ctx,
-        layer_off_bytes_k);
-    ggml_tensor * V_att = ggml_view_4d(
-        ctx, kv_cache.self_v, head_dim, T, n_kv_heads, B,
-        v_elem * kv_dim, v_elem * head_dim, v_elem * kv_dim * n_ctx,
-        layer_off_bytes_v);
+    const size_t  layer_off_bytes_k = k_elem * static_cast<size_t>(layer_idx) * n_ctx * kv_dim * B;
+    const size_t  layer_off_bytes_v = v_elem * static_cast<size_t>(layer_idx) * n_ctx * kv_dim * B;
+    ggml_tensor * K_att             = ggml_view_4d(ctx, kv_cache.self_k, head_dim, T, n_kv_heads, B, k_elem * kv_dim,
+                                                   k_elem * head_dim, k_elem * kv_dim * n_ctx, layer_off_bytes_k);
+    ggml_tensor * V_att             = ggml_view_4d(ctx, kv_cache.self_v, head_dim, T, n_kv_heads, B, v_elem * kv_dim,
+                                                   v_elem * head_dim, v_elem * kv_dim * n_ctx, layer_off_bytes_v);
 
     // Q -> [head_dim, T, n_heads, B].
     ggml_tensor * Q_att = ggml_cont(ctx, ggml_permute(ctx, Q, 0, 2, 1, 3));
 
     ggml_tensor * o;
     if (use_flash) {
-        o = ggml_flash_attn_ext(ctx, Q_att, K_att, V_att, mask,
-                                scale_attn, 0.0f, 0.0f);
+        o = ggml_flash_attn_ext(ctx, Q_att, K_att, V_att, mask, scale_attn, 0.0f, 0.0f);
         o = ggml_reshape_3d(ctx, o, q_dim, T, B);
     } else {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "causal_lm block_prefill_batched: non-flash unsupported");
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "causal_lm block_prefill_batched: non-flash unsupported");
         return nullptr;
     }
 
@@ -871,10 +733,12 @@ ggml_tensor * block_prefill_batched(
     x = ggml_add(ctx, x, o);
 
     ggml_tensor * ff_norm = rms_norm(ctx, x, view.norm_ffn_w, rms_eps);
-    if (view.ffn_scale != nullptr) ff_norm = ggml_mul(ctx, ff_norm, view.ffn_scale);
+    if (view.ffn_scale != nullptr) {
+        ff_norm = ggml_mul(ctx, ff_norm, view.ffn_scale);
+    }
     ggml_tensor * gate_up = mul_mat_f32acc(ctx, view.ffn_gate_up_w, ff_norm);
     ggml_tensor * ff      = ggml_swiglu(ctx, gate_up);
-    ff = mul_mat_f32acc(ctx, view.ffn_down_w, ff);
+    ff                    = mul_mat_f32acc(ctx, view.ffn_down_w, ff);
 
     x = ggml_add(ctx, x, ff);
     return x;
@@ -891,34 +755,27 @@ void PackedGateUpHandles::free() {
     }
 }
 
-
-bool pack_gate_up(ggml_backend_t                  backend,
-                  int                             hidden,
-                  int                             intermediate,
+bool pack_gate_up(ggml_backend_t                   backend,
+                  int                              hidden,
+                  int                              intermediate,
                   const std::vector<GateUpEntry> & entries,
-                  PackedGateUpHandles &           out_handles,
-                  const char *                    error_tag)
-{
-    if (backend == nullptr || hidden <= 0 || intermediate <= 0 ||
-        entries.empty())
-    {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "%s: pack_gate_up invalid args (hidden=%d intermediate=%d n=%zu)",
-                     error_tag, hidden, intermediate, entries.size());
+                  PackedGateUpHandles &            out_handles,
+                  const char *                     error_tag) {
+    if (backend == nullptr || hidden <= 0 || intermediate <= 0 || entries.empty()) {
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: pack_gate_up invalid args (hidden=%d intermediate=%d n=%zu)",
+                error_tag, hidden, intermediate, entries.size());
         return false;
     }
 
-    const size_t ctx_size =
-        entries.size() * ggml_tensor_overhead() + 1024;
-    ggml_init_params packed_params {};
+    const size_t     ctx_size = entries.size() * ggml_tensor_overhead() + 1024;
+    ggml_init_params packed_params{};
     packed_params.mem_size   = ctx_size;
     packed_params.mem_buffer = nullptr;
     packed_params.no_alloc   = true;
 
     out_handles.ctx = ggml_init(packed_params);
     if (out_handles.ctx == nullptr) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "%s: pack_gate_up ggml_init failed", error_tag);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: pack_gate_up ggml_init failed", error_tag);
         return false;
     }
 
@@ -926,109 +783,100 @@ bool pack_gate_up(ggml_backend_t                  backend,
     // a row-wise quant block size).
     for (size_t i = 0; i < entries.size(); ++i) {
         const auto & e = entries[i];
-        if (e.gate_w == nullptr || e.up_w == nullptr ||
-            e.gate_up_w_out == nullptr)
-        {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "%s: pack_gate_up entry %zu has null member",
-                         error_tag, i);
+        if (e.gate_w == nullptr || e.up_w == nullptr || e.gate_up_w_out == nullptr) {
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: pack_gate_up entry %zu has null member", error_tag, i);
             return false;
         }
         if (e.gate_w->type != e.up_w->type) {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "%s: pack_gate_up entry %zu gate/up type mismatch (%d vs %d)",
-                         error_tag, i,
-                         static_cast<int>(e.gate_w->type),
-                         static_cast<int>(e.up_w->type));
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: pack_gate_up entry %zu gate/up type mismatch (%d vs %d)",
+                    error_tag, i, static_cast<int>(e.gate_w->type), static_cast<int>(e.up_w->type));
             return false;
         }
-        ggml_tensor * t = ggml_new_tensor_2d(
-            out_handles.ctx, e.gate_w->type, hidden, 2 * intermediate);
+        ggml_tensor * t = ggml_new_tensor_2d(out_handles.ctx, e.gate_w->type, hidden, 2 * intermediate);
         if (t == nullptr) {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "%s: pack_gate_up new_tensor_2d failed at %zu",
-                         error_tag, i);
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: pack_gate_up new_tensor_2d failed at %zu", error_tag, i);
             return false;
         }
         *e.gate_up_w_out = t;
     }
 
-    out_handles.buffer = ggml_backend_alloc_ctx_tensors(
-        out_handles.ctx, backend);
+    out_handles.buffer = ggml_backend_alloc_ctx_tensors(out_handles.ctx, backend);
     if (out_handles.buffer == nullptr) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "%s: pack_gate_up backend buffer alloc failed",
-                     error_tag);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: pack_gate_up backend buffer alloc failed", error_tag);
         return false;
     }
-    ggml_backend_buffer_set_usage(out_handles.buffer,
-                                  GGML_BACKEND_BUFFER_USAGE_WEIGHTS);
+    ggml_backend_buffer_set_usage(out_handles.buffer, GGML_BACKEND_BUFFER_USAGE_WEIGHTS);
 
     // Fill: concat-along-dim-1 is gate's bytes followed by up's bytes
     // (one CPU round-trip per block at load time).
     std::vector<uint8_t> buf;
     for (const auto & e : entries) {
-        ggml_tensor * gate_up = *e.gate_up_w_out;
+        ggml_tensor * gate_up    = *e.gate_up_w_out;
         const size_t  gate_bytes = ggml_nbytes(e.gate_w);
         const size_t  up_bytes   = ggml_nbytes(e.up_w);
         if (ggml_nbytes(gate_up) != gate_bytes + up_bytes) {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "%s: pack_gate_up size mismatch (%zu vs %zu + %zu)",
-                         error_tag, ggml_nbytes(gate_up), gate_bytes, up_bytes);
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: pack_gate_up size mismatch (%zu vs %zu + %zu)", error_tag,
+                    ggml_nbytes(gate_up), gate_bytes, up_bytes);
             return false;
         }
         buf.resize(std::max(gate_bytes, up_bytes));
         ggml_backend_tensor_get(e.gate_w, buf.data(), 0, gate_bytes);
-        ggml_backend_tensor_set(gate_up,  buf.data(), 0, gate_bytes);
-        ggml_backend_tensor_get(e.up_w,   buf.data(), 0, up_bytes);
-        ggml_backend_tensor_set(gate_up,  buf.data(), gate_bytes, up_bytes);
+        ggml_backend_tensor_set(gate_up, buf.data(), 0, gate_bytes);
+        ggml_backend_tensor_get(e.up_w, buf.data(), 0, up_bytes);
+        ggml_backend_tensor_set(gate_up, buf.data(), gate_bytes, up_bytes);
     }
     return true;
 }
 
-transcribe_status run_batched_step_loop(
-    transcribe_session *                session,
-    ggml_backend_sched_t                sched,
-    const StepBatchedIO &               io,
-    int                                 n_batch,
-    int                                 max_n_kv,
-    int32_t                             eos_id,
-    int                                 max_new,
-    const StepBatchedState &            state,
-    std::vector<std::vector<int32_t>> & generated,
-    StepLoopStats *                     stats,
-    std::vector<char> *                 truncated_out)
-{
+transcribe_status run_batched_step_loop(transcribe_session *                session,
+                                        ggml_backend_sched_t                sched,
+                                        const StepBatchedIO &               io,
+                                        int                                 n_batch,
+                                        int                                 max_n_kv,
+                                        int32_t                             eos_id,
+                                        int                                 max_new,
+                                        const StepBatchedState &            state,
+                                        std::vector<std::vector<int32_t>> & generated,
+                                        StepLoopStats *                     stats,
+                                        std::vector<char> *                 truncated_out) {
     const int n = n_batch;
 
     // Per-row working state.
-    std::vector<int32_t> next_tok = state.next_tok;
-    std::vector<int>     n_past   = state.n_past;
-    const std::vector<char> & valid = state.valid;
-    std::vector<char>    finished(n, 1);
+    std::vector<int32_t>      next_tok = state.next_tok;
+    std::vector<int>          n_past   = state.n_past;
+    const std::vector<char> & valid    = state.valid;
+    std::vector<char>         finished(n, 1);
     for (int b = 0; b < n; ++b) {
-        if (valid[b]) finished[b] = (next_tok[b] == eos_id);
+        if (valid[b]) {
+            finished[b] = (next_tok[b] == eos_id);
+        }
     }
 
     // Host-side step inputs.
-    std::vector<int32_t> ids_buf(n, 0), pos_buf(n, 0), out_buf(n, 0);
-    std::vector<int64_t> kvidx_buf(n, 0);
-    const ggml_fp16_t mz = ggml_fp32_to_fp16(0.0f);
-    const ggml_fp16_t mn = ggml_fp32_to_fp16(-INFINITY);
+    std::vector<int32_t>     ids_buf(n, 0), pos_buf(n, 0), out_buf(n, 0);
+    std::vector<int64_t>     kvidx_buf(n, 0);
+    const ggml_fp16_t        mz = ggml_fp32_to_fp16(0.0f);
+    const ggml_fp16_t        mn = ggml_fp32_to_fp16(-INFINITY);
     std::vector<ggml_fp16_t> mask_buf(static_cast<size_t>(max_n_kv) * n, mn);
     // Initialise each row's mask: attendable [0, n_past[b]] (prompt + the first
     // generated token, which step 0 writes at row n_past[b]).
     for (int b = 0; b < n; ++b) {
-        if (!valid[b]) continue;
+        if (!valid[b]) {
+            continue;
+        }
         const size_t base = static_cast<size_t>(b) * max_n_kv;
-        for (int c = 0; c <= n_past[b] && c < max_n_kv; ++c) mask_buf[base + c] = mz;
+        for (int c = 0; c <= n_past[b] && c < max_n_kv; ++c) {
+            mask_buf[base + c] = mz;
+        }
     }
 
-    const int64_t t_step0 = ggml_time_us();
-    int  n_steps  = 0;
-    bool all_done = false;
+    const int64_t t_step0  = ggml_time_us();
+    int           n_steps  = 0;
+    bool          all_done = false;
     while (!all_done) {
-        if (session->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
+        if (session->poll_abort()) {
+            return TRANSCRIBE_ERR_ABORTED;
+        }
         for (int b = 0; b < n; ++b) {
             // Finished/invalid rows keep stepping with frozen, valid inputs;
             // their independent KV slab means the overwrite is a no-op for live
@@ -1037,36 +885,32 @@ transcribe_status run_batched_step_loop(
             pos_buf[b]   = n_past[b];
             kvidx_buf[b] = n_past[b];
         }
-        ggml_backend_tensor_set(io.input_ids, ids_buf.data(),
-                                0, ids_buf.size() * sizeof(int32_t));
-        ggml_backend_tensor_set(io.positions, pos_buf.data(),
-                                0, pos_buf.size() * sizeof(int32_t));
-        ggml_backend_tensor_set(io.kv_idx, kvidx_buf.data(),
-                                0, kvidx_buf.size() * sizeof(int64_t));
-        ggml_backend_tensor_set(io.mask, mask_buf.data(),
-                                0, mask_buf.size() * sizeof(ggml_fp16_t));
-
-        if (ggml_backend_sched_graph_compute(sched, io.graph) !=
-            GGML_STATUS_SUCCESS) {
+        ggml_backend_tensor_set(io.input_ids, ids_buf.data(), 0, ids_buf.size() * sizeof(int32_t));
+        ggml_backend_tensor_set(io.positions, pos_buf.data(), 0, pos_buf.size() * sizeof(int32_t));
+        ggml_backend_tensor_set(io.kv_idx, kvidx_buf.data(), 0, kvidx_buf.size() * sizeof(int64_t));
+        ggml_backend_tensor_set(io.mask, mask_buf.data(), 0, mask_buf.size() * sizeof(ggml_fp16_t));
+
+        if (ggml_backend_sched_graph_compute(sched, io.graph) != GGML_STATUS_SUCCESS) {
             return TRANSCRIBE_ERR_GGUF;
         }
-        ggml_backend_tensor_get(io.argmax, out_buf.data(), 0,
-                                out_buf.size() * sizeof(int32_t));
+        ggml_backend_tensor_get(io.argmax, out_buf.data(), 0, out_buf.size() * sizeof(int32_t));
         ++n_steps;
 
         all_done = true;
         for (int b = 0; b < n; ++b) {
-            if (finished[b] || !valid[b]) continue;
+            if (finished[b] || !valid[b]) {
+                continue;
+            }
             const int32_t tok = out_buf[b];
-            next_tok[b] = tok;
+            next_tok[b]       = tok;
             generated[b].push_back(tok);
             n_past[b] += 1;
             // Open the new KV position for the NEXT step's attention.
             const size_t base = static_cast<size_t>(b) * max_n_kv;
-            if (n_past[b] < max_n_kv) mask_buf[base + n_past[b]] = mz;
-            if (tok == eos_id ||
-                static_cast<int>(generated[b].size()) >= max_new ||
-                n_past[b] + 1 > max_n_kv) {
+            if (n_past[b] < max_n_kv) {
+                mask_buf[base + n_past[b]] = mz;
+            }
+            if (tok == eos_id || static_cast<int>(generated[b].size()) >= max_new || n_past[b] + 1 > max_n_kv) {
                 finished[b] = 1;
             } else {
                 all_done = false;
@@ -1093,4 +937,4 @@ transcribe_status run_batched_step_loop(
     return TRANSCRIBE_OK;
 }
 
-} // namespace transcribe::causal_lm
+}  // namespace transcribe::causal_lm
diff --git a/src/causal_lm/causal_lm.h b/src/causal_lm/causal_lm.h
index a7935722..c83f394a 100644
--- a/src/causal_lm/causal_lm.h
+++ b/src/causal_lm/causal_lm.h
@@ -14,10 +14,9 @@
 
 #pragma once
 
-#include "transcribe.h"
-
-#include "ggml.h"
 #include "ggml-backend.h"
+#include "ggml.h"
+#include "transcribe.h"
 
 #include <cstdint>
 #include <vector>
@@ -56,7 +55,7 @@ struct BlockParams {
     int   n_heads      = 0;
     int   n_kv_heads   = 0;
     int   head_dim     = 0;
-    int   max_position = 0;     // RoPE max position (passed to ggml_rope_ext)
+    int   max_position = 0;  // RoPE max position (passed to ggml_rope_ext)
     float rms_eps      = 0.0f;
     float rope_theta   = 0.0f;
 };
@@ -71,11 +70,11 @@ struct KvCache {
     ggml_context *        ctx    = nullptr;
     ggml_backend_buffer_t buffer = nullptr;
 
-    int n_ctx    = 0;
-    int n        = 0;     // current fill (high-water mark)
-    int head     = 0;     // next write position
-    int n_batch  = 1;     // utterances packed along the batch axis
-                          // (offline batched decode); 1 == single-shot
+    int n_ctx   = 0;
+    int n       = 0;  // current fill (high-water mark)
+    int head    = 0;  // next write position
+    int n_batch = 1;  // utterances packed along the batch axis
+                      // (offline batched decode); 1 == single-shot
 
     void free();
 };
@@ -103,7 +102,7 @@ bool kv_init_batched(KvCache &      cache,
                      ggml_type      kv_type);
 
 struct BlockOpts {
-    bool use_flash             = true;
+    bool use_flash = true;
 
     // When true, after the post-attention residual add but before the FFN,
     // slice x to the last position only (output [hidden, 1]). Used on the
@@ -116,8 +115,8 @@ struct BlockOpts {
     // per-(layer,slot) byte offset becomes
     //   (kv_batch_slot + kv_n_batch * layer_idx) * n_ctx * kv_dim.
     // Defaults (0, 1) reproduce the single-shot offset.
-    int  kv_batch_slot = 0;
-    int  kv_n_batch    = 1;
+    int kv_batch_slot = 0;
+    int kv_n_batch    = 1;
 };
 
 // Block forward (prefill, T_seq > 1). Runs one block on `x`
@@ -126,18 +125,17 @@ struct BlockOpts {
 // i32. Returns the post-block hidden state ([hidden, T_seq], or
 // [hidden, 1] under opts.slice_last_before_ffn). Names no tensors; the
 // family's prefill builder owns naming and dump-point selection.
-ggml_tensor * block_prefill(
-    ggml_context *      ctx,
-    ggml_cgraph *       gf,
-    ggml_tensor *       x,
-    const BlockView &   view,
-    const BlockParams & params,
-    KvCache &           kv_cache,
-    int                 layer_idx,
-    int                 T_seq,
-    ggml_tensor *       mask,       // [T_seq, T_seq] f16
-    ggml_tensor *       positions,  // [T_seq] i32
-    BlockOpts           opts = {});
+ggml_tensor * block_prefill(ggml_context *      ctx,
+                            ggml_cgraph *       gf,
+                            ggml_tensor *       x,
+                            const BlockView &   view,
+                            const BlockParams & params,
+                            KvCache &           kv_cache,
+                            int                 layer_idx,
+                            int                 T_seq,
+                            ggml_tensor *       mask,       // [T_seq, T_seq] f16
+                            ggml_tensor *       positions,  // [T_seq] i32
+                            BlockOpts           opts = {});
 
 // Block forward (step, T_seq == 1). Runs one block on a single new token,
 // writing K/V for the row indexed by `kv_idx` (i64 [1]) into layer
@@ -145,39 +143,37 @@ ggml_tensor * block_prefill(
 // [max_n_kv, 1] f16 (zeros ≤ n_past, -inf beyond). `position` ([1] i32)
 // and `kv_idx` ([1] i64) are equal at runtime but kept distinct (RoPE
 // wants i32, set_rows wants i64).
-ggml_tensor * block_step(
-    ggml_context *      ctx,
-    ggml_cgraph *       gf,
-    ggml_tensor *       x,          // [hidden, 1]
-    const BlockView &   view,
-    const BlockParams & params,
-    KvCache &           kv_cache,
-    int                 layer_idx,
-    int                 max_n_kv,
-    ggml_tensor *       mask,       // [max_n_kv, 1] f16
-    ggml_tensor *       position,   // [1] i32
-    ggml_tensor *       kv_idx,     // [1] i64
-    bool                use_flash);
+ggml_tensor * block_step(ggml_context *      ctx,
+                         ggml_cgraph *       gf,
+                         ggml_tensor *       x,  // [hidden, 1]
+                         const BlockView &   view,
+                         const BlockParams & params,
+                         KvCache &           kv_cache,
+                         int                 layer_idx,
+                         int                 max_n_kv,
+                         ggml_tensor *       mask,      // [max_n_kv, 1] f16
+                         ggml_tensor *       position,  // [1] i32
+                         ggml_tensor *       kv_idx,    // [1] i64
+                         bool                use_flash);
 
 // Block forward (multi-position step). Like block_step but processes
 // T_seq positions in one forward: writes T_seq rows at the indices in
 // `kv_idx` (i64 [T_seq]) and reads the full [0, max_n_kv) window. `mask`
 // is [max_n_kv, T_seq] f16 — column `c` masks the c-th query position.
 // Used by the spec-decode verify pass.
-ggml_tensor * block_step_n(
-    ggml_context *      ctx,
-    ggml_cgraph *       gf,
-    ggml_tensor *       x,          // [hidden, T_seq]
-    const BlockView &   view,
-    const BlockParams & params,
-    KvCache &           kv_cache,
-    int                 layer_idx,
-    int                 T_seq,
-    int                 max_n_kv,
-    ggml_tensor *       mask,       // [max_n_kv, T_seq] f16
-    ggml_tensor *       positions,  // [T_seq] i32
-    ggml_tensor *       kv_idx,     // [T_seq] i64
-    bool                use_flash);
+ggml_tensor * block_step_n(ggml_context *      ctx,
+                           ggml_cgraph *       gf,
+                           ggml_tensor *       x,  // [hidden, T_seq]
+                           const BlockView &   view,
+                           const BlockParams & params,
+                           KvCache &           kv_cache,
+                           int                 layer_idx,
+                           int                 T_seq,
+                           int                 max_n_kv,
+                           ggml_tensor *       mask,       // [max_n_kv, T_seq] f16
+                           ggml_tensor *       positions,  // [T_seq] i32
+                           ggml_tensor *       kv_idx,     // [T_seq] i64
+                           bool                use_flash);
 
 // Block forward (batched step). Runs one block on B new tokens
 // (x = [hidden, B]), one per utterance stepping in lockstep against a
@@ -197,20 +193,19 @@ ggml_tensor * block_step_n(
 //
 // Requires use_flash (the manual GQA path is single-shot only). Returns
 // [hidden, B].
-ggml_tensor * block_step_batched(
-    ggml_context *      ctx,
-    ggml_cgraph *       gf,
-    ggml_tensor *       x,          // [hidden, B]
-    const BlockView &   view,
-    const BlockParams & params,
-    KvCache &           kv_cache,
-    int                 layer_idx,
-    int                 max_n_kv,
-    int                 n_batch,
-    ggml_tensor *       mask,       // [max_n_kv, 1, 1, B] f16
-    ggml_tensor *       position,   // [B] i32
-    ggml_tensor *       kv_idx,     // [1, B] i64
-    bool                use_flash);
+ggml_tensor * block_step_batched(ggml_context *      ctx,
+                                 ggml_cgraph *       gf,
+                                 ggml_tensor *       x,  // [hidden, B]
+                                 const BlockView &   view,
+                                 const BlockParams & params,
+                                 KvCache &           kv_cache,
+                                 int                 layer_idx,
+                                 int                 max_n_kv,
+                                 int                 n_batch,
+                                 ggml_tensor *       mask,      // [max_n_kv, 1, 1, B] f16
+                                 ggml_tensor *       position,  // [B] i32
+                                 ggml_tensor *       kv_idx,    // [1, B] i64
+                                 bool                use_flash);
 
 // Block forward (batched prefill). Runs one block over B prompts of T
 // tokens each (x = [hidden, T, B]), writing each utterance's K/V to
@@ -221,20 +216,19 @@ ggml_tensor * block_step_batched(
 // the step loop overwrites before attending, and the caller gathers only
 // each utterance's real last-position output. Requires use_flash.
 // Returns [hidden, T, B].
-ggml_tensor * block_prefill_batched(
-    ggml_context *      ctx,
-    ggml_cgraph *       gf,
-    ggml_tensor *       x,          // [hidden, T, B]
-    const BlockView &   view,
-    const BlockParams & params,
-    KvCache &           kv_cache,
-    int                 layer_idx,
-    int                 T_seq,
-    int                 n_batch,
-    ggml_tensor *       mask,       // [T_seq, T_seq] f16 causal (shared)
-    ggml_tensor *       positions,  // [T_seq] i32 (shared)
-    ggml_tensor *       kv_idx,     // [T_seq, B] i64 (idx[t,b] = t)
-    bool                use_flash);
+ggml_tensor * block_prefill_batched(ggml_context *      ctx,
+                                    ggml_cgraph *       gf,
+                                    ggml_tensor *       x,  // [hidden, T, B]
+                                    const BlockView &   view,
+                                    const BlockParams & params,
+                                    KvCache &           kv_cache,
+                                    int                 layer_idx,
+                                    int                 T_seq,
+                                    int                 n_batch,
+                                    ggml_tensor *       mask,       // [T_seq, T_seq] f16 causal (shared)
+                                    ggml_tensor *       positions,  // [T_seq] i32 (shared)
+                                    ggml_tensor *       kv_idx,     // [T_seq, B] i64 (idx[t,b] = t)
+                                    bool                use_flash);
 
 // Load-time gate/up packing.
 
@@ -266,12 +260,12 @@ struct PackedGateUpHandles {
 // new tensor and marks the buffer GGML_BACKEND_BUFFER_USAGE_WEIGHTS.
 // Returns false on alloc / size-mismatch failure; `out_handles` is left in
 // a state safe to free.
-bool pack_gate_up(ggml_backend_t                  backend,
-                  int                             hidden,
-                  int                             intermediate,
+bool pack_gate_up(ggml_backend_t                   backend,
+                  int                              hidden,
+                  int                              intermediate,
                   const std::vector<GateUpEntry> & entries,
-                  PackedGateUpHandles &           out_handles,
-                  const char *                    error_tag = "causal_lm");
+                  PackedGateUpHandles &            out_handles,
+                  const char *                     error_tag = "causal_lm");
 
 // Batched greedy step loop (offline transcribe_run_batch decode).
 
@@ -310,17 +304,16 @@ struct StepLoopStats {
 // session->poll_abort() once per step. The step graph must already be built
 // and allocated on `sched`. Returns TRANSCRIBE_ERR_ABORTED on abort,
 // TRANSCRIBE_ERR_GGUF on a compute failure, else TRANSCRIBE_OK.
-transcribe_status run_batched_step_loop(
-    transcribe_session *                session,
-    ggml_backend_sched_t                sched,
-    const StepBatchedIO &               io,
-    int                                 n_batch,
-    int                                 max_n_kv,
-    int32_t                             eos_id,
-    int                                 max_new,
-    const StepBatchedState &            state,
-    std::vector<std::vector<int32_t>> & generated,
-    StepLoopStats *                     stats = nullptr,
-    std::vector<char> *                 truncated_out = nullptr);
-
-} // namespace transcribe::causal_lm
+transcribe_status run_batched_step_loop(transcribe_session *                session,
+                                        ggml_backend_sched_t                sched,
+                                        const StepBatchedIO &               io,
+                                        int                                 n_batch,
+                                        int                                 max_n_kv,
+                                        int32_t                             eos_id,
+                                        int                                 max_new,
+                                        const StepBatchedState &            state,
+                                        std::vector<std::vector<int32_t>> & generated,
+                                        StepLoopStats *                     stats         = nullptr,
+                                        std::vector<char> *                 truncated_out = nullptr);
+
+}  // namespace transcribe::causal_lm
diff --git a/src/conformer/conformer.cpp b/src/conformer/conformer.cpp
index 26722912..3ecfe27d 100644
--- a/src/conformer/conformer.cpp
+++ b/src/conformer/conformer.cpp
@@ -8,10 +8,10 @@
 // family's depthwise detect delegate to — one place owns the parsing.
 
 #include "conformer/conformer.h"
-#include "transcribe-env.h"
-#include "transcribe-log.h"
 
 #include "ggml.h"
+#include "transcribe-env.h"
+#include "transcribe-log.h"
 
 #include <cmath>
 #include <cstdio>
@@ -31,13 +31,9 @@ ggml_tensor * named(ggml_tensor * t, const char * name) {
 // ggml_norm normalizes along ne[0] (the d_model axis of [d_model, T, B]);
 // gamma/beta [d_model] broadcast over T and B. `gamma` required; `beta`
 // may be null for bias-free LN.
-ggml_tensor * layer_norm(ggml_context * ctx,
-                         ggml_tensor *  x,
-                         ggml_tensor *  gamma,
-                         ggml_tensor *  beta)
-{
+ggml_tensor * layer_norm(ggml_context * ctx, ggml_tensor * x, ggml_tensor * gamma, ggml_tensor * beta) {
     ggml_tensor * y = ggml_norm(ctx, x, kLayerNormEps);
-    y = ggml_mul(ctx, y, gamma);
+    y               = ggml_mul(ctx, y, gamma);
     if (beta != nullptr) {
         y = ggml_add(ctx, y, beta);
     }
@@ -52,8 +48,7 @@ ggml_tensor * feed_forward(ggml_context * ctx,
                            ggml_tensor *  lin1_w,
                            ggml_tensor *  lin1_b,
                            ggml_tensor *  lin2_w,
-                           ggml_tensor *  lin2_b)
-{
+                           ggml_tensor *  lin2_b) {
     ggml_tensor * y = ggml_mul_mat(ctx, lin1_w, x);
     if (lin1_b != nullptr) {
         y = ggml_add(ctx, y, lin1_b);
@@ -75,11 +70,10 @@ ggml_tensor * macaron_ff_residual(ggml_context * ctx,
                                   ggml_tensor *  lin1_w,
                                   ggml_tensor *  lin1_b,
                                   ggml_tensor *  lin2_w,
-                                  ggml_tensor *  lin2_b)
-{
+                                  ggml_tensor *  lin2_b) {
     ggml_tensor * y = layer_norm(ctx, x, norm_w, norm_b);
-    y = feed_forward(ctx, y, lin1_w, lin1_b, lin2_w, lin2_b);
-    y = ggml_scale(ctx, y, 0.5f);
+    y               = feed_forward(ctx, y, lin1_w, lin1_b, lin2_w, lin2_b);
+    y               = ggml_scale(ctx, y, 0.5f);
     return ggml_add(ctx, x, y);
 }
 
@@ -97,17 +91,15 @@ ggml_tensor * rel_shift(ggml_context * ctx, ggml_tensor * x) {
     // the same shape filled with the given constant. ggml_concat
     // along dim=0 produces [pos_len+1, T_q, H, B] with the first
     // axis-0 element being our zero column.
-    ggml_tensor * zero_template = ggml_new_tensor_4d(ctx, GGML_TYPE_F32,
-                                                     1, T_q, H, B);
-    ggml_tensor * zeros = ggml_fill(ctx, zero_template, 0.0f);
-    ggml_tensor * y = ggml_concat(ctx, zeros, x, /*dim=*/0);
+    ggml_tensor * zero_template = ggml_new_tensor_4d(ctx, GGML_TYPE_F32, 1, T_q, H, B);
+    ggml_tensor * zeros         = ggml_fill(ctx, zero_template, 0.0f);
+    ggml_tensor * y             = ggml_concat(ctx, zeros, x, /*dim=*/0);
 
     // Step 2: reshape (swap inner two axes; total elements unchanged).
     y = ggml_reshape_4d(ctx, y, T_q, pos_len + 1, H, B);
 
     // Step 3: drop the first row of axis 1.
-    y = ggml_view_4d(ctx, y, T_q, pos_len, H, B,
-                     y->nb[1], y->nb[2], y->nb[3],
+    y = ggml_view_4d(ctx, y, T_q, pos_len, H, B, y->nb[1], y->nb[2], y->nb[3],
                      /*offset=*/y->nb[1]);
 
     // Step 4: materialize as contiguous (the view above is sparse:
@@ -128,22 +120,17 @@ ggml_tensor * conv_1d_f32(ggml_context * ctx,
                           ggml_tensor *  data,
                           int            stride,
                           int            padding,
-                          int            dilation)
-{
+                          int            dilation) {
     // im2col: kernel shape [K, IC, OC] in ggml ne; data shape
     // [W, IC, N] in ggml ne. Output ne[0] = IC*K, ne[1] = OW (output
     // width), ne[2] = N (batch).
-    ggml_tensor * im2col = ggml_im2col(ctx, kernel, data,
-                                       stride, /*s1=*/0,
-                                       padding, /*p1=*/0,
-                                       dilation, /*d1=*/0,
+    ggml_tensor * im2col = ggml_im2col(ctx, kernel, data, stride, /*s1=*/0, padding, /*p1=*/0, dilation, /*d1=*/0,
                                        /*is_2D=*/false,
                                        /*dst_type=*/kernel->type);
     // im2col ne = [IC*K, OW, N].
 
-    const int64_t N = im2col->ne[2];
-    ggml_tensor * kernel_2d = ggml_reshape_2d(ctx, kernel,
-                                              kernel->ne[0] * kernel->ne[1],
+    const int64_t N         = im2col->ne[2];
+    ggml_tensor * kernel_2d = ggml_reshape_2d(ctx, kernel, kernel->ne[0] * kernel->ne[1],
                                               kernel->ne[2]);  // [IC*K, OC]
 
     // F32 accumulation when the kernel is F16 (see mul_mat_f32acc in
@@ -153,14 +140,12 @@ ggml_tensor * conv_1d_f32(ggml_context * ctx,
     if (N == 1) {
         // Single-shot path: flatten OW*N (== OW) and reshape the [OW, OC]
         // result back to [OW, OC, 1].
-        ggml_tensor * result = ggml_mul_mat(ctx,
-            ggml_reshape_2d(ctx, im2col, im2col->ne[0], im2col->ne[1]),
-            kernel_2d);  // [OW, OC]
+        ggml_tensor * result = ggml_mul_mat(ctx, ggml_reshape_2d(ctx, im2col, im2col->ne[0], im2col->ne[1]),
+                                            kernel_2d);  // [OW, OC]
         if (kernel_needs_f32_acc) {
             ggml_mul_mat_set_prec(result, GGML_PREC_F32);
         }
-        result = ggml_reshape_3d(ctx, result,
-                                 im2col->ne[1], kernel->ne[2], 1);
+        result = ggml_reshape_3d(ctx, result, im2col->ne[1], kernel->ne[2], 1);
         return result;
     }
 
@@ -187,30 +172,23 @@ ggml_tensor * conv_1d_f32(ggml_context * ctx,
 ggml_tensor * conv_2d_dw_f32(ggml_context * ctx,
                              ggml_tensor *  kernel,  // [KW, KH, 1, C]
                              ggml_tensor *  data,    // [W, H, C, N]
-                             int            s0, int s1,
-                             int            p0, int p1,
-                             int            d0, int d1)
-{
+                             int            s0,
+                             int            s1,
+                             int            p0,
+                             int            p1,
+                             int            d0,
+                             int            d1) {
     // Same op sequence as ggml_conv_2d_dw, only dst_type changes.
-    ggml_tensor * new_a = ggml_reshape_4d(ctx, kernel,
-        kernel->ne[0], kernel->ne[1], 1,
-        kernel->ne[2] * kernel->ne[3]);
-    ggml_tensor * data_4d = ggml_reshape_4d(ctx, data,
-        data->ne[0], data->ne[1], 1,
-        data->ne[2] * data->ne[3]);
-    ggml_tensor * im2col = ggml_im2col(ctx, new_a, data_4d,
-        s0, s1, p0, p1, d0, d1,
-        /*is_2D=*/true,
-        /*dst_type=*/kernel->type);
-    ggml_tensor * new_b = ggml_reshape_4d(ctx, im2col,
-        im2col->ne[0], im2col->ne[2] * im2col->ne[1],
-        data->ne[2], data->ne[3]);
-    new_a = ggml_reshape_4d(ctx, new_a,
-        new_a->ne[0] * new_a->ne[1], new_a->ne[2], new_a->ne[3], 1);
+    ggml_tensor * new_a = ggml_reshape_4d(ctx, kernel, kernel->ne[0], kernel->ne[1], 1, kernel->ne[2] * kernel->ne[3]);
+    ggml_tensor * data_4d = ggml_reshape_4d(ctx, data, data->ne[0], data->ne[1], 1, data->ne[2] * data->ne[3]);
+    ggml_tensor * im2col  = ggml_im2col(ctx, new_a, data_4d, s0, s1, p0, p1, d0, d1,
+                                        /*is_2D=*/true,
+                                        /*dst_type=*/kernel->type);
+    ggml_tensor * new_b =
+        ggml_reshape_4d(ctx, im2col, im2col->ne[0], im2col->ne[2] * im2col->ne[1], data->ne[2], data->ne[3]);
+    new_a                = ggml_reshape_4d(ctx, new_a, new_a->ne[0] * new_a->ne[1], new_a->ne[2], new_a->ne[3], 1);
     ggml_tensor * result = ggml_mul_mat(ctx, new_a, new_b);
-    result = ggml_reshape_4d(ctx, result,
-        im2col->ne[1], im2col->ne[2],
-        data->ne[2], data->ne[3]);
+    result               = ggml_reshape_4d(ctx, result, im2col->ne[1], im2col->ne[2], data->ne[2], data->ne[3]);
     return result;
 }
 
@@ -222,8 +200,7 @@ ggml_tensor * conv_2d_dw_f32(ggml_context * ctx,
 // kernel is tiny, so the cast is negligible; F32 kernels pass through
 // untouched. Only the direct_dw path (CUDA/Vulkan) routes here — the im2col
 // fallback used on Metal/CPU takes the kernel's real type and is unaffected.
-static ggml_tensor * dw_kernel_for_direct(ggml_context * ctx,
-                                          ggml_tensor *  kernel) {
+static ggml_tensor * dw_kernel_for_direct(ggml_context * ctx, ggml_tensor * kernel) {
     if (kernel == nullptr || kernel->type == GGML_TYPE_F32) {
         return kernel;
     }
@@ -237,46 +214,39 @@ ggml_tensor * conv_1d_dw_f32(ggml_context * ctx,
                              ggml_tensor *  data,
                              int            stride,
                              int            padding,
-                             int            dilation)
-{
+                             int            dilation) {
     // Offline batch: data ne=[W, C, B] with B>1. The im2col path below
     // collapses the batch axis (its final reshape hardcodes ne[2]=1), so
     // route B>1 through the direct depthwise-2D op (W, H=1, C, N=B), which
     // threads the utterance batch at ne[3].
     const int64_t B = data->ne[2];
     if (B > 1) {
-        const int64_t k = kernel->ne[0];
-        const int64_t C = data->ne[1];
+        const int64_t k   = kernel->ne[0];
+        const int64_t C   = data->ne[1];
         // ggml_conv_2d_dw_direct misbehaves for non-f32 kernels; the
         // depthwise kernel is tiny, so cast to f32.
         ggml_tensor * knl = kernel;
         if (knl->type != GGML_TYPE_F32) {
             knl = ggml_cast(ctx, knl, GGML_TYPE_F32);
         }
-        knl = ggml_reshape_4d(ctx, knl, k, 1, 1, C);
+        knl              = ggml_reshape_4d(ctx, knl, k, 1, 1, C);
         ggml_tensor * d4 = ggml_reshape_4d(ctx, data, data->ne[0], 1, C, B);
-        ggml_tensor * o = ggml_conv_2d_dw_direct(ctx, knl, d4,
-                                                 /*s0=*/stride, /*s1=*/1,
-                                                 /*p0=*/padding, /*p1=*/0,
-                                                 /*d0=*/dilation, /*d1=*/1);
+        ggml_tensor * o  = ggml_conv_2d_dw_direct(ctx, knl, d4,
+                                                  /*s0=*/stride, /*s1=*/1,
+                                                  /*p0=*/padding, /*p1=*/0,
+                                                  /*d0=*/dilation, /*d1=*/1);
         return ggml_reshape_3d(ctx, o, o->ne[0], C, B);  // [W_out, C, B]
     }
 
     // The depthwise wrapper reshapes the data into a 2D image with
     // H=1 so the same im2col path can be reused. ggml_conv_1d_dw
     // does this; we replicate it here with the dst_type override.
-    ggml_tensor * data_4d = ggml_reshape_4d(ctx, data,
-                                            data->ne[0], 1,
-                                            data->ne[1], data->ne[2]);
-    ggml_tensor * im2col = ggml_im2col(ctx, kernel, data_4d,
-                                       stride, /*s1=*/0,
-                                       padding, /*p1=*/0,
-                                       dilation, /*d1=*/0,
-                                       /*is_2D=*/false,
-                                       /*dst_type=*/kernel->type);
-    ggml_tensor * result = ggml_mul_mat(ctx, im2col, kernel);
-    result = ggml_reshape_3d(ctx, result,
-                             result->ne[0], result->ne[2], 1);
+    ggml_tensor * data_4d = ggml_reshape_4d(ctx, data, data->ne[0], 1, data->ne[1], data->ne[2]);
+    ggml_tensor * im2col  = ggml_im2col(ctx, kernel, data_4d, stride, /*s1=*/0, padding, /*p1=*/0, dilation, /*d1=*/0,
+                                        /*is_2D=*/false,
+                                        /*dst_type=*/kernel->type);
+    ggml_tensor * result  = ggml_mul_mat(ctx, im2col, kernel);
+    result                = ggml_reshape_3d(ctx, result, result->ne[0], result->ne[2], 1);
     return result;
 }
 
@@ -285,16 +255,12 @@ ggml_tensor * conv_1d_dw_f32(ggml_context * ctx,
 // 4-op batch_norm (sub, div/sqrt, mul, add) with 2 ops (mul, add).
 // The 1-D tensors [d_model] are reshaped to [1, d_model, 1, 1] to
 // broadcast across the time axis of [T, d_model, 1, 1].
-ggml_tensor * fused_batch_norm(ggml_context * ctx,
-                               ggml_tensor *  x,
-                               ggml_tensor *  scale_1d,
-                               ggml_tensor *  bias_1d)
-{
-    const int64_t C = scale_1d->ne[0];
+ggml_tensor * fused_batch_norm(ggml_context * ctx, ggml_tensor * x, ggml_tensor * scale_1d, ggml_tensor * bias_1d) {
+    const int64_t C        = scale_1d->ne[0];
     ggml_tensor * scale_4d = ggml_reshape_4d(ctx, scale_1d, 1, C, 1, 1);
-    ggml_tensor * bias_4d  = ggml_reshape_4d(ctx, bias_1d,  1, C, 1, 1);
-    ggml_tensor * y = ggml_mul(ctx, x, scale_4d);
-    y = ggml_add(ctx, y, bias_4d);
+    ggml_tensor * bias_4d  = ggml_reshape_4d(ctx, bias_1d, 1, C, 1, 1);
+    ggml_tensor * y        = ggml_mul(ctx, x, scale_4d);
+    y                      = ggml_add(ctx, y, bias_4d);
     return y;
 }
 
@@ -302,21 +268,22 @@ ggml_tensor * fused_batch_norm(ggml_context * ctx,
 // the bias to [1, 1, C, 1] so ggml_add broadcasts the W, H, and N
 // axes for free. The reshape is a metadata-only view because the
 // 1-D tensor is contiguous; no data copy.
-ggml_tensor * add_conv_bias(ggml_context * ctx,
-                            ggml_tensor *  conv_out,
-                            ggml_tensor *  bias_1d)
-{
-    if (bias_1d == nullptr) return conv_out;
+ggml_tensor * add_conv_bias(ggml_context * ctx, ggml_tensor * conv_out, ggml_tensor * bias_1d) {
+    if (bias_1d == nullptr) {
+        return conv_out;
+    }
     const int64_t channels = bias_1d->ne[0];
-    ggml_tensor * bias_4d = ggml_reshape_4d(ctx, bias_1d, 1, 1, channels, 1);
+    ggml_tensor * bias_4d  = ggml_reshape_4d(ctx, bias_1d, 1, 1, channels, 1);
     return ggml_add(ctx, conv_out, bias_4d);
 }
 
-bool resolve_conv_direct(const char * direct_env,
-                         const char * no_direct_env,
-                         bool         backend_default) {
-    if (transcribe::env::flag(direct_env))    return true;  // user override
-    if (transcribe::env::flag(no_direct_env)) return false; // user override
+bool resolve_conv_direct(const char * direct_env, const char * no_direct_env, bool backend_default) {
+    if (transcribe::env::flag(direct_env)) {
+        return true;  // user override
+    }
+    if (transcribe::env::flag(no_direct_env)) {
+        return false;  // user override
+    }
     return backend_default;
 }
 
@@ -324,11 +291,8 @@ bool detect_direct_pw(const char * backend) {
     // Vulkan defaults to im2col: on AMD Renoir, im2col + mul_mat measured
     // ~200 ms/encode faster than direct for f32 weights. Metal/CPU prefer
     // direct.
-    const bool backend_default =
-        !(backend != nullptr && std::strstr(backend, "Vulkan") != nullptr);
-    return resolve_conv_direct("TRANSCRIBE_CONV_DIRECT_PW",
-                               "TRANSCRIBE_CONV_NO_DIRECT_PW",
-                               backend_default);
+    const bool backend_default = !(backend != nullptr && std::strstr(backend, "Vulkan") != nullptr);
+    return resolve_conv_direct("TRANSCRIBE_CONV_DIRECT_PW", "TRANSCRIBE_CONV_NO_DIRECT_PW", backend_default);
 }
 
 // Conv module (pointwise -> GLU -> depthwise -> BN/LN -> SiLU -> pointwise).
@@ -336,11 +300,7 @@ bool detect_direct_pw(const char * backend) {
 // Pointwise convs (k=1) are direct mul_mats in [d_model, T] layout by
 // default; TRANSCRIBE_CONV_NO_DIRECT_PW=1 forces the im2col path. BatchNorm
 // uses fused scale + bias; LayerNorm normalizes per-channel on the fly.
-ggml_tensor * conv_module(ggml_context *      ctx,
-                          ggml_tensor *       x,
-                          const BlockView &   b,
-                          const BlockParams & params)
-{
+ggml_tensor * conv_module(ggml_context * ctx, ggml_tensor * x, const BlockView & b, const BlockParams & params) {
     const int          conv_kernel = params.conv_kernel;
     const ConvPolicy & policy      = params.policy;
 
@@ -357,7 +317,7 @@ ggml_tensor * conv_module(ggml_context *      ctx,
     const int64_t d_model = x->ne[0];
     // Utterance batch lives at ne[2] of the [d_model, T, B] activation.
     // B == 1 for single-shot; the offline batched encoder passes B > 1.
-    const int64_t B = x->ne[2];
+    const int64_t B       = x->ne[2];
 
     if (policy.direct_pw) {
         // Pointwise conv 1 as direct mul_mat in [d_model, T, B] layout.
@@ -365,9 +325,8 @@ ggml_tensor * conv_module(ggml_context *      ctx,
         // Force F32 accumulation for F16 weights (see mul_mat_f32acc in
         // causal_lm.cpp for the CUDA COMPUTE_16F saturation rationale).
         {
-            ggml_tensor * pw1 = ggml_reshape_2d(ctx, b.conv_pw1_w,
-                                                d_model, 2 * d_model);
-            x = ggml_mul_mat(ctx, pw1, x);  // [2*d_model, T, B]
+            ggml_tensor * pw1 = ggml_reshape_2d(ctx, b.conv_pw1_w, d_model, 2 * d_model);
+            x                 = ggml_mul_mat(ctx, pw1, x);  // [2*d_model, T, B]
             if (b.conv_pw1_w->type == GGML_TYPE_F16) {
                 ggml_mul_mat_set_prec(x, GGML_PREC_F32);
             }
@@ -379,15 +338,12 @@ ggml_tensor * conv_module(ggml_context *      ctx,
         // GLU: split ne[0] in half, gate * sigmoid(value). The views carry
         // the batch axis (ne[2]) so the split is per-utterance.
         {
-            const int64_t T    = x->ne[1];
-            const int64_t half = x->ne[0] / 2;
-            ggml_tensor * gate  = ggml_view_3d(ctx, x, half, T, B,
-                                               x->nb[1], x->nb[2],
+            const int64_t T     = x->ne[1];
+            const int64_t half  = x->ne[0] / 2;
+            ggml_tensor * gate  = ggml_view_3d(ctx, x, half, T, B, x->nb[1], x->nb[2],
                                                /*offset=*/0);
-            ggml_tensor * value = ggml_view_3d(ctx, x, half, T, B,
-                                               x->nb[1], x->nb[2],
-                                               half * ggml_element_size(x));
-            x = ggml_mul(ctx, gate, ggml_sigmoid(ctx, value));
+            ggml_tensor * value = ggml_view_3d(ctx, x, half, T, B, x->nb[1], x->nb[2], half * ggml_element_size(x));
+            x                   = ggml_mul(ctx, gate, ggml_sigmoid(ctx, value));
         }
         // x ne = [d_model, T, B]
 
@@ -403,21 +359,15 @@ ggml_tensor * conv_module(ggml_context *      ctx,
         if (b.conv_pw1_b != nullptr) {
             // conv_1d_f32 returns ne=[T, 2*d_model, 1]. Reshape the
             // 1-D bias to [1, 2*d_model] so ggml_add broadcasts.
-            x = ggml_reshape_2d(ctx, x, x->ne[0], x->ne[1]);
-            ggml_tensor * bias_r = ggml_reshape_2d(ctx, b.conv_pw1_b,
-                                                   1, 2 * d_model);
-            x = ggml_add(ctx, x, bias_r);
+            x                    = ggml_reshape_2d(ctx, x, x->ne[0], x->ne[1]);
+            ggml_tensor * bias_r = ggml_reshape_2d(ctx, b.conv_pw1_b, 1, 2 * d_model);
+            x                    = ggml_add(ctx, x, bias_r);
         }
 
-        const int64_t half = x->ne[1] / 2;
-        ggml_tensor * gate = ggml_view_4d(ctx, x,
-                                          x->ne[0], half, 1, 1,
-                                          x->nb[1], x->nb[2], x->nb[3], 0);
-        ggml_tensor * value = ggml_view_4d(ctx, x,
-                                           x->ne[0], half, 1, 1,
-                                           x->nb[1], x->nb[2], x->nb[3],
-                                           x->nb[1] * half);
-        x = ggml_mul(ctx, gate, ggml_sigmoid(ctx, value));
+        const int64_t half  = x->ne[1] / 2;
+        ggml_tensor * gate  = ggml_view_4d(ctx, x, x->ne[0], half, 1, 1, x->nb[1], x->nb[2], x->nb[3], 0);
+        ggml_tensor * value = ggml_view_4d(ctx, x, x->ne[0], half, 1, 1, x->nb[1], x->nb[2], x->nb[3], x->nb[1] * half);
+        x                   = ggml_mul(ctx, gate, ggml_sigmoid(ctx, value));
 
         x = ggml_cont(ctx, x);
     }
@@ -460,35 +410,25 @@ ggml_tensor * conv_module(ggml_context *      ctx,
             // Take the LAST pad_left frames as the next-chunk cache slot.
             // pad_left always <= x->ne[0] here because the concat above
             // contributes exactly pad_left frames of prev_cache.
-            if (params.streaming_time_out != nullptr &&
-                params.streaming_graph != nullptr)
-            {
+            if (params.streaming_time_out != nullptr && params.streaming_graph != nullptr) {
                 const int64_t T_padded = x->ne[0];
-                ggml_tensor * tail = ggml_view_4d(
-                    ctx, x,
-                    pad_left, x->ne[1], x->ne[2], x->ne[3],
-                    x->nb[1], x->nb[2], x->nb[3],
-                    (T_padded - pad_left) * x->nb[0]);
-                ggml_tensor * cpy = ggml_cpy(ctx, tail,
-                                             params.streaming_time_out);
+                ggml_tensor * tail = ggml_view_4d(ctx, x, pad_left, x->ne[1], x->ne[2], x->ne[3], x->nb[1], x->nb[2],
+                                                  x->nb[3], (T_padded - pad_left) * x->nb[0]);
+                ggml_tensor * cpy  = ggml_cpy(ctx, tail, params.streaming_time_out);
                 // Cache writes are SIDE outputs of the encoder graph:
                 // not reachable from `eb.out`, so the scheduler won't
                 // schedule them unless we expand them explicitly.
                 ggml_build_forward_expand(params.streaming_graph, cpy);
             }
         } else if (pad_left > 0) {
-            ggml_tensor * pad_l = ggml_new_tensor_4d(ctx, x->type,
-                                                     pad_left, x->ne[1],
-                                                     x->ne[2], x->ne[3]);
-            pad_l = ggml_fill(ctx, pad_l, 0.0f);
-            x = ggml_concat(ctx, pad_l, x, /*dim=*/0);
+            ggml_tensor * pad_l = ggml_new_tensor_4d(ctx, x->type, pad_left, x->ne[1], x->ne[2], x->ne[3]);
+            pad_l               = ggml_fill(ctx, pad_l, 0.0f);
+            x                   = ggml_concat(ctx, pad_l, x, /*dim=*/0);
         }
         if (pad_right > 0) {
-            ggml_tensor * pad_r = ggml_new_tensor_4d(ctx, x->type,
-                                                     pad_right, x->ne[1],
-                                                     x->ne[2], x->ne[3]);
-            pad_r = ggml_fill(ctx, pad_r, 0.0f);
-            x = ggml_concat(ctx, x, pad_r, /*dim=*/0);
+            ggml_tensor * pad_r = ggml_new_tensor_4d(ctx, x->type, pad_right, x->ne[1], x->ne[2], x->ne[3]);
+            pad_r               = ggml_fill(ctx, pad_r, 0.0f);
+            x                   = ggml_concat(ctx, x, pad_r, /*dim=*/0);
         }
     }
     const int padding_op = symmetric_pad ? pad_left : 0;
@@ -497,17 +437,14 @@ ggml_tensor * conv_module(ggml_context *      ctx,
         // from the transpose above. Reshape to 4D [T, 1, d_model, B] for
         // ggml_conv_2d_dw_direct which expects [W, H, C, N] (N == B, the
         // utterance batch). Kernel [k, 1, d_model] → [k, 1, 1, d_model].
-        ggml_tensor * knl = ggml_reshape_4d(ctx,
-                                            dw_kernel_for_direct(ctx, b.conv_dw_w),
-                                            conv_kernel, 1, 1, d_model);
-        ggml_tensor * data = ggml_reshape_4d(ctx, x,
-                                             x->ne[0], 1, x->ne[1], B);
-        x = ggml_conv_2d_dw_direct(ctx, knl, data,
-                                   /*s0=*/1, /*s1=*/1,
-                                   /*p0=*/padding_op, /*p1=*/0,
-                                   /*d0=*/1, /*d1=*/1);
+        ggml_tensor * knl  = ggml_reshape_4d(ctx, dw_kernel_for_direct(ctx, b.conv_dw_w), conv_kernel, 1, 1, d_model);
+        ggml_tensor * data = ggml_reshape_4d(ctx, x, x->ne[0], 1, x->ne[1], B);
+        x                  = ggml_conv_2d_dw_direct(ctx, knl, data,
+                                                    /*s0=*/1, /*s1=*/1,
+                                                    /*p0=*/padding_op, /*p1=*/0,
+                                                    /*d0=*/1, /*d1=*/1);
         // Output: [T_out, 1, d_model, B] → [T_out, d_model, B].
-        x = ggml_reshape_3d(ctx, x, x->ne[0], x->ne[2], x->ne[3]);
+        x                  = ggml_reshape_3d(ctx, x, x->ne[0], x->ne[2], x->ne[3]);
     } else {
         // im2col depthwise (cohere on Metal/CPU); single-utterance only.
         x = conv_1d_dw_f32(ctx, b.conv_dw_w, x,
@@ -517,7 +454,7 @@ ggml_tensor * conv_module(ggml_context *      ctx,
     // Add depthwise bias in [T, d_model] layout (nullable).
     if (b.conv_dw_b != nullptr) {
         ggml_tensor * bias_r = ggml_reshape_2d(ctx, b.conv_dw_b, 1, d_model);
-        x = ggml_add(ctx, x, bias_r);
+        x                    = ggml_add(ctx, x, bias_r);
     }
 
     // Post-depthwise normalisation: BN (fused mul + add) or LN (per-channel
@@ -529,8 +466,7 @@ ggml_tensor * conv_module(ggml_context *      ctx,
         x = layer_norm(ctx, x, b.conv_ln_w, b.conv_ln_b);
         x = ggml_cont(ctx, ggml_permute(ctx, x, 1, 0, 2, 3));
     } else {
-        x = fused_batch_norm(ctx, x,
-                             b.conv_bn_fused_scale, b.conv_bn_fused_bias);
+        x = fused_batch_norm(ctx, x, b.conv_bn_fused_scale, b.conv_bn_fused_bias);
     }
 
     x = ggml_silu(ctx, x);
@@ -541,9 +477,8 @@ ggml_tensor * conv_module(ggml_context *      ctx,
 
         // Pointwise conv 2 as direct mul_mat in [d_model, T] layout. See
         // the pw1 comment above for the F16 / CUDA COMPUTE_16F rationale.
-        ggml_tensor * pw2 = ggml_reshape_2d(ctx, b.conv_pw2_w,
-                                            d_model, d_model);
-        x = ggml_mul_mat(ctx, pw2, x);
+        ggml_tensor * pw2 = ggml_reshape_2d(ctx, b.conv_pw2_w, d_model, d_model);
+        x                 = ggml_mul_mat(ctx, pw2, x);
         if (b.conv_pw2_w->type == GGML_TYPE_F16) {
             ggml_mul_mat_set_prec(x, GGML_PREC_F32);
         }
@@ -553,10 +488,9 @@ ggml_tensor * conv_module(ggml_context *      ctx,
     } else {
         x = conv_1d_f32(ctx, b.conv_pw2_w, x, /*s=*/1, /*p=*/0, /*d=*/1);
         if (b.conv_pw2_b != nullptr) {
-            x = ggml_reshape_2d(ctx, x, x->ne[0], x->ne[1]);
-            ggml_tensor * bias_r = ggml_reshape_2d(ctx, b.conv_pw2_b,
-                                                   1, d_model);
-            x = ggml_add(ctx, x, bias_r);
+            x                    = ggml_reshape_2d(ctx, x, x->ne[0], x->ne[1]);
+            ggml_tensor * bias_r = ggml_reshape_2d(ctx, b.conv_pw2_b, 1, d_model);
+            x                    = ggml_add(ctx, x, bias_r);
         }
         x = ggml_cont(ctx, ggml_permute(ctx, x, 1, 0, 2, 3));
     }
@@ -590,35 +524,33 @@ ggml_tensor * rel_pos_mhsa(ggml_context *      ctx,
                            const BlockParams & params,
                            ggml_tensor *       x_q,
                            ggml_tensor *       k_full,
-                           ggml_tensor *       v_full)
-{
-    const int     d_model  = params.d_model;
-    const int     n_head   = params.n_head;
-    const ggml_type kv_type  = params.kv_type;
-    const bool      use_flash = params.use_flash;
-    const int     att_context_left  = params.att_context_left;
-    const int     att_context_right = params.att_context_right;
-    const int     head_dim = d_model / n_head;
-    const float   scale    = 1.0f / std::sqrt(static_cast<float>(head_dim));
+                           ggml_tensor *       v_full) {
+    const int       d_model           = params.d_model;
+    const int       n_head            = params.n_head;
+    const ggml_type kv_type           = params.kv_type;
+    const bool      use_flash         = params.use_flash;
+    const int       att_context_left  = params.att_context_left;
+    const int       att_context_right = params.att_context_right;
+    const int       head_dim          = d_model / n_head;
+    const float     scale             = 1.0f / std::sqrt(static_cast<float>(head_dim));
     // Query/key-value split (see the x_q / k_full contracts in conformer.h).
     // kv_cached: K/V arrive pre-projected, x is the query-only activation.
     // q_sliced: queries from x_q, K/V projected from x. rect covers both —
     // the score geometry is rectangular [T_kv, T_q].
-    const bool    kv_cached = (k_full != nullptr && v_full != nullptr);
-    const bool    q_sliced  = !kv_cached && (x_q != nullptr && x_q != x);
-    const bool    rect      = kv_cached || q_sliced;
-    const int64_t T_kv      = kv_cached ? k_full->ne[1] : x->ne[1];
-    const int64_t T_q       = q_sliced  ? x_q->ne[1]    : x->ne[1];
+    const bool      kv_cached         = (k_full != nullptr && v_full != nullptr);
+    const bool      q_sliced          = !kv_cached && (x_q != nullptr && x_q != x);
+    const bool      rect              = kv_cached || q_sliced;
+    const int64_t   T_kv              = kv_cached ? k_full->ne[1] : x->ne[1];
+    const int64_t   T_q               = q_sliced ? x_q->ne[1] : x->ne[1];
     // With a precomputed pos projection, pos_emb may be null (the
     // caller's graph carries no pos_emb input at all).
-    ggml_tensor * pos_proj = params.streaming_pos_proj_in;
-    const int64_t pos_len  = pos_proj != nullptr ? pos_proj->ne[1]
-                                                 : pos_emb->ne[1];
+    ggml_tensor *   pos_proj          = params.streaming_pos_proj_in;
+    const int64_t   pos_len           = pos_proj != nullptr ? pos_proj->ne[1] : pos_emb->ne[1];
     if (rect && pos_len != T_q + T_kv - 1) {
         std::fprintf(stderr,
                      "conformer rel_pos_mhsa: rectangular pos_emb length "
                      "%lld != T_q + T_kv - 1 = %lld\n",
-                     (long long)pos_len, (long long)(T_q + T_kv - 1));
+                     (long long) pos_len, (long long) (T_q + T_kv - 1));
         return nullptr;
     }
     // Utterance batch at ne[2] (moves to ne[3] after the head split). Flash
@@ -627,41 +559,43 @@ ggml_tensor * rel_pos_mhsa(ggml_context *      ctx,
     // the mask's ne[1] padded to GGML_KQ_MASK_PAD, which the [T_kv, T_q]
     // streaming mask does not satisfy. (TRANSCRIBE_NO_FLASH=1 also forces
     // manual, for the bit-exact CPU tensor gate.)
-    const int64_t B         = x->ne[2];
-    const bool    flash     = use_flash && !rect;
+    const int64_t B     = x->ne[2];
+    const bool    flash = use_flash && !rect;
 
     // Local-attention bookkeeping. With both window sides non-negative
     // in the Regular style, pos_emb arrives at the smaller
     // [left+right+1, d] length and matrix_bd needs zero/-inf padding to
     // keep the rel_shift trick intact. ChunkedLimited keeps pos_emb at
     // its full 2T-1 length and uses the external chunked mask instead.
-    const bool is_chunked =
-        (params.att_context_style == BlockParams::AttContextStyle::ChunkedLimited);
-    const bool is_local =
-        (!is_chunked) && (att_context_left >= 0 && att_context_right >= 0);
-    const int  W_left  = is_local ? att_context_left  : 0;
-    const int  W_right = is_local ? att_context_right : 0;
+    const bool is_chunked = (params.att_context_style == BlockParams::AttContextStyle::ChunkedLimited);
+    const bool is_local   = (!is_chunked) && (att_context_left >= 0 && att_context_right >= 0);
+    const int  W_left     = is_local ? att_context_left : 0;
+    const int  W_right    = is_local ? att_context_right : 0;
 
     // Q, K, V, P projections. Q/K/V may have bias (Cohere) or not
     // (Parakeet); the pos projection (attn_pos_w) never has a bias.
     ggml_tensor * q = ggml_mul_mat(ctx, b.attn_q_w, q_sliced ? x_q : x);
-    if (b.attn_q_b != nullptr) q = ggml_add(ctx, q, b.attn_q_b);
+    if (b.attn_q_b != nullptr) {
+        q = ggml_add(ctx, q, b.attn_q_b);
+    }
     // KV-cache mode: keys/values arrive pre-projected (bias included).
     ggml_tensor * k = k_full;
     ggml_tensor * v = v_full;
     if (!kv_cached) {
         k = ggml_mul_mat(ctx, b.attn_k_w, x);
-        if (b.attn_k_b != nullptr) k = ggml_add(ctx, k, b.attn_k_b);
+        if (b.attn_k_b != nullptr) {
+            k = ggml_add(ctx, k, b.attn_k_b);
+        }
         v = ggml_mul_mat(ctx, b.attn_v_w, x);
-        if (b.attn_v_b != nullptr) v = ggml_add(ctx, v, b.attn_v_b);
+        if (b.attn_v_b != nullptr) {
+            v = ggml_add(ctx, v, b.attn_v_b);
+        }
     }
-    ggml_tensor * p = pos_proj == nullptr
-        ? ggml_mul_mat(ctx, b.attn_pos_w, pos_emb)
-        : nullptr;
+    ggml_tensor * p = pos_proj == nullptr ? ggml_mul_mat(ctx, b.attn_pos_w, pos_emb) : nullptr;
 
     // Split heads: [head_dim, n_head, T, B] (batch at ne[3]). pos_bias_u/v
     // broadcast onto this BEFORE the permute that moves T past n_head.
-    q = ggml_reshape_4d(ctx, q, head_dim, n_head, T_q, B);
+    q                 = ggml_reshape_4d(ctx, q, head_dim, n_head, T_q, B);
     ggml_tensor * q_u = ggml_add(ctx, q, b.attn_pos_u);
     ggml_tensor * q_v = ggml_add(ctx, q, b.attn_pos_v);
 
@@ -706,32 +640,25 @@ ggml_tensor * rel_pos_mhsa(ggml_context *      ctx,
     if (is_local) {
         const int top_pad = static_cast<int>(T_q) - 1 - W_left;
         if (top_pad > 0) {
-            ggml_tensor * top_template = ggml_new_tensor_4d(
-                ctx, GGML_TYPE_F32, top_pad, T_q, n_head, B);
-            ggml_tensor * top = ggml_fill(ctx, top_template, -INFINITY);
-            matrix_bd = ggml_concat(ctx, top, matrix_bd, /*dim=*/0);
+            ggml_tensor * top_template = ggml_new_tensor_4d(ctx, GGML_TYPE_F32, top_pad, T_q, n_head, B);
+            ggml_tensor * top          = ggml_fill(ctx, top_template, -INFINITY);
+            matrix_bd                  = ggml_concat(ctx, top, matrix_bd, /*dim=*/0);
         } else if (top_pad < 0) {
             const int kept = static_cast<int>(matrix_bd->ne[0]) + top_pad;
-            matrix_bd = ggml_view_4d(ctx, matrix_bd,
-                                     kept, T_q, n_head, B,
-                                     matrix_bd->nb[1], matrix_bd->nb[2],
-                                     matrix_bd->nb[3],
-                                     (-top_pad) * matrix_bd->nb[0]);
-            matrix_bd = ggml_cont(ctx, matrix_bd);
+            matrix_bd      = ggml_view_4d(ctx, matrix_bd, kept, T_q, n_head, B, matrix_bd->nb[1], matrix_bd->nb[2],
+                                          matrix_bd->nb[3], (-top_pad) * matrix_bd->nb[0]);
+            matrix_bd      = ggml_cont(ctx, matrix_bd);
         }
         const int bot_pad = static_cast<int>(T_q) - 1 - W_right;
         if (bot_pad > 0) {
-            ggml_tensor * bot_template = ggml_new_tensor_4d(
-                ctx, GGML_TYPE_F32, bot_pad, T_q, n_head, B);
-            ggml_tensor * bot = ggml_fill(ctx, bot_template, -INFINITY);
-            matrix_bd = ggml_concat(ctx, matrix_bd, bot, /*dim=*/0);
+            ggml_tensor * bot_template = ggml_new_tensor_4d(ctx, GGML_TYPE_F32, bot_pad, T_q, n_head, B);
+            ggml_tensor * bot          = ggml_fill(ctx, bot_template, -INFINITY);
+            matrix_bd                  = ggml_concat(ctx, matrix_bd, bot, /*dim=*/0);
         } else if (bot_pad < 0) {
             const int kept = static_cast<int>(matrix_bd->ne[0]) + bot_pad;
-            matrix_bd = ggml_view_4d(ctx, matrix_bd,
-                                     kept, T_q, n_head, B,
-                                     matrix_bd->nb[1], matrix_bd->nb[2],
-                                     matrix_bd->nb[3], /*offset=*/0);
-            matrix_bd = ggml_cont(ctx, matrix_bd);
+            matrix_bd      = ggml_view_4d(ctx, matrix_bd, kept, T_q, n_head, B, matrix_bd->nb[1], matrix_bd->nb[2],
+                                          matrix_bd->nb[3], /*offset=*/0);
+            matrix_bd      = ggml_cont(ctx, matrix_bd);
         }
     }
 
@@ -744,10 +671,8 @@ ggml_tensor * rel_pos_mhsa(ggml_context *      ctx,
     // T_q == T_kv specialization. The zero column injected by the trick
     // only lands at k >= T_kv, which the view below slices off.
     matrix_bd = rel_shift(ctx, matrix_bd);
-    matrix_bd = ggml_view_4d(ctx, matrix_bd,
-                             T_kv, T_q, n_head, B,
-                             matrix_bd->nb[1], matrix_bd->nb[2],
-                             matrix_bd->nb[3], /*offset=*/0);
+    matrix_bd = ggml_view_4d(ctx, matrix_bd, T_kv, T_q, n_head, B, matrix_bd->nb[1], matrix_bd->nb[2], matrix_bd->nb[3],
+                             /*offset=*/0);
     // The view is non-contiguous (nb[1] stays at parent's
     // pos_len*es), but it IS contiguous-rows. The flash path calls
     // ggml_scale which wants full contiguity, so cont there. The
@@ -789,8 +714,7 @@ ggml_tensor * rel_pos_mhsa(ggml_context *      ctx,
         {
             ggml_type effective_kv = kv_type;
             if (effective_kv == GGML_TYPE_COUNT) {
-                effective_kv = (b.attn_k_w->type != GGML_TYPE_F32)
-                             ? GGML_TYPE_F16 : GGML_TYPE_F32;
+                effective_kv = (b.attn_k_w->type != GGML_TYPE_F32) ? GGML_TYPE_F16 : GGML_TYPE_F32;
             }
             if (effective_kv != GGML_TYPE_F32) {
                 k = ggml_cast(ctx, k, effective_kv);
@@ -798,8 +722,7 @@ ggml_tensor * rel_pos_mhsa(ggml_context *      ctx,
             }
         }
 
-        o = ggml_flash_attn_ext(ctx, q_u, k, v, matrix_bd,
-                                scale, /*max_bias=*/0.0f,
+        o = ggml_flash_attn_ext(ctx, q_u, k, v, matrix_bd, scale, /*max_bias=*/0.0f,
                                 /*logit_softcap=*/0.0f);
         // Output is [head_dim, n_head, T_q, 1] — already permuted.
     } else {
@@ -816,13 +739,11 @@ ggml_tensor * rel_pos_mhsa(ggml_context *      ctx,
         ggml_tensor * kq = ggml_mul_mat(ctx, k, q_u);
 
         // Add relative position bias; soft_max_ext fuses the scale.
-        kq = ggml_add(ctx, kq, matrix_bd);
-        ggml_tensor * kq_soft = ggml_soft_max_ext(ctx, kq, /*mask=*/nullptr,
-                                                  scale, /*max_bias=*/0.0f);
+        kq                    = ggml_add(ctx, kq, matrix_bd);
+        ggml_tensor * kq_soft = ggml_soft_max_ext(ctx, kq, /*mask=*/nullptr, scale, /*max_bias=*/0.0f);
 
         // V transposed for the value matmul: [T_q, head_dim, n_head, 1].
-        ggml_tensor * v_t = ggml_cont(ctx,
-                                      ggml_permute(ctx, v, 1, 0, 2, 3));
+        ggml_tensor * v_t = ggml_cont(ctx, ggml_permute(ctx, v, 1, 0, 2, 3));
 
         // attn_weights @ V: [head_dim, T_q, n_head, 1]
         o = ggml_mul_mat(ctx, v_t, kq_soft);
@@ -836,7 +757,9 @@ ggml_tensor * rel_pos_mhsa(ggml_context *      ctx,
     o = ggml_reshape_3d(ctx, o, d_model, T_q, B);
 
     o = ggml_mul_mat(ctx, b.attn_out_w, o);
-    if (b.attn_out_b != nullptr) o = ggml_add(ctx, o, b.attn_out_b);
+    if (b.attn_out_b != nullptr) {
+        o = ggml_add(ctx, o, b.attn_out_b);
+    }
     return o;
 }
 
@@ -849,8 +772,7 @@ ggml_tensor * build_conformer_block(ggml_context *        ctx,
                                     ggml_tensor *         pos_emb,
                                     const BlockView &     b,
                                     const BlockParams &   params,
-                                    const BlockObserver * obs)
-{
+                                    const BlockObserver * obs) {
     // Observer dispatch helper (no-op when obs / its callback is null).
     const auto notify = [&](const char * tag, ggml_tensor * t) {
         if (obs != nullptr && obs->on_point != nullptr) {
@@ -859,10 +781,7 @@ ggml_tensor * build_conformer_block(ggml_context *        ctx,
     };
 
     // Macaron FF1: x = x + 0.5 * FF1(LN_ff1(x))
-    x = macaron_ff_residual(ctx, x,
-                            b.norm_ff1_w, b.norm_ff1_b,
-                            b.ff1_lin1_w, b.ff1_lin1_b,
-                            b.ff1_lin2_w, b.ff1_lin2_b);
+    x = macaron_ff_residual(ctx, x, b.norm_ff1_w, b.norm_ff1_b, b.ff1_lin1_w, b.ff1_lin1_b, b.ff1_lin2_w, b.ff1_lin2_b);
     notify("after_ff1", x);
 
     // Self-attention with relative position. Full residual.
@@ -878,39 +797,29 @@ ggml_tensor * build_conformer_block(ggml_context *        ctx,
     //      rectangular [T_virtual, T_q_new] geometry.
     // T_q_new comes from the running x's ne[1].
     {
-        const bool streaming = (params.streaming_channel_in != nullptr);
+        const bool    streaming = (params.streaming_channel_in != nullptr);
         // KV-cache streaming: keys/values are cached pre-projected, so
         // the channel cache (and its concat/write) is skipped entirely
         // and x_norm stays at the new frames throughout.
-        const bool kv_mode = streaming &&
-            params.streaming_kv_k_in != nullptr &&
-            params.streaming_kv_v_in != nullptr;
+        const bool    kv_mode = streaming && params.streaming_kv_k_in != nullptr && params.streaming_kv_v_in != nullptr;
         const int64_t T_q_new = streaming ? x->ne[1] : 0;
-        const int64_t T_cache = streaming
-            ? params.streaming_channel_in->ne[1]
-            : 0;
+        const int64_t T_cache = streaming ? params.streaming_channel_in->ne[1] : 0;
         ggml_tensor * x_q_new = nullptr;
-        ggml_tensor * x_norm = layer_norm(ctx, x,
-                                          b.norm_attn_w, b.norm_attn_b);
+        ggml_tensor * x_norm  = layer_norm(ctx, x, b.norm_attn_w, b.norm_attn_b);
 
         // Streaming cache rotation: new_cache = concat(prev[T_q_new:],
         // fresh) for the common T_q_new < cache-size case, else the
         // last cache-size rows of fresh. Shared by the channel cache
         // and the KV cache (identical rolling-window semantics).
-        const auto emit_rotated_cache = [&](ggml_tensor * prev,
-                                            ggml_tensor * fresh,
-                                            ggml_tensor * out) {
-            const int64_t Tc = prev->ne[1];
+        const auto emit_rotated_cache = [&](ggml_tensor * prev, ggml_tensor * fresh, ggml_tensor * out) {
+            const int64_t Tc        = prev->ne[1];
             ggml_tensor * new_cache = nullptr;
             if (T_q_new < Tc) {
-                ggml_tensor * prev_tail = ggml_view_2d(
-                    ctx, prev, prev->ne[0], Tc - T_q_new, prev->nb[1],
-                    /*offset=*/T_q_new * prev->nb[1]);
-                new_cache = ggml_concat(ctx, prev_tail, fresh, /*dim=*/1);
+                ggml_tensor * prev_tail = ggml_view_2d(ctx, prev, prev->ne[0], Tc - T_q_new, prev->nb[1],
+                                                       /*offset=*/T_q_new * prev->nb[1]);
+                new_cache               = ggml_concat(ctx, prev_tail, fresh, /*dim=*/1);
             } else {
-                new_cache = ggml_view_2d(
-                    ctx, fresh, fresh->ne[0], Tc, fresh->nb[1],
-                    (T_q_new - Tc) * fresh->nb[1]);
+                new_cache = ggml_view_2d(ctx, fresh, fresh->ne[0], Tc, fresh->nb[1], (T_q_new - Tc) * fresh->nb[1]);
             }
             ggml_tensor * cpy = ggml_cpy(ctx, new_cache, out);
             ggml_build_forward_expand(params.streaming_graph, cpy);
@@ -921,30 +830,21 @@ ggml_tensor * build_conformer_block(ggml_context *        ctx,
             // x_norm: prev_cache tail (T_cache - T_q_new rows) concatenated
             // with this chunk's x_norm, or x_norm's last T_cache rows when
             // T_q_new >= T_cache.
-            if (params.streaming_channel_out != nullptr &&
-                params.streaming_graph != nullptr)
-            {
+            if (params.streaming_channel_out != nullptr && params.streaming_graph != nullptr) {
                 ggml_tensor * new_cache = nullptr;
                 if (T_q_new < T_cache) {
-                    ggml_tensor * prev_tail = ggml_view_2d(
-                        ctx, params.streaming_channel_in,
-                        params.streaming_channel_in->ne[0],
-                        T_cache - T_q_new,
-                        params.streaming_channel_in->nb[1],
-                        /*offset=*/T_q_new *
-                            params.streaming_channel_in->nb[1]);
+                    ggml_tensor * prev_tail =
+                        ggml_view_2d(ctx, params.streaming_channel_in, params.streaming_channel_in->ne[0],
+                                     T_cache - T_q_new, params.streaming_channel_in->nb[1],
+                                     /*offset=*/T_q_new * params.streaming_channel_in->nb[1]);
                     new_cache = ggml_concat(ctx, prev_tail, x_norm,
                                             /*dim=*/1);
                 } else {
                     // x_norm's last T_cache rows.
-                    new_cache = ggml_view_2d(
-                        ctx, x_norm,
-                        x_norm->ne[0], T_cache,
-                        x_norm->nb[1],
-                        (T_q_new - T_cache) * x_norm->nb[1]);
+                    new_cache = ggml_view_2d(ctx, x_norm, x_norm->ne[0], T_cache, x_norm->nb[1],
+                                             (T_q_new - T_cache) * x_norm->nb[1]);
                 }
-                ggml_tensor * cpy = ggml_cpy(ctx, new_cache,
-                                             params.streaming_channel_out);
+                ggml_tensor * cpy = ggml_cpy(ctx, new_cache, params.streaming_channel_out);
                 ggml_build_forward_expand(params.streaming_graph, cpy);
             }
 
@@ -953,8 +853,7 @@ ggml_tensor * build_conformer_block(ggml_context *        ctx,
             // is computed for just the T_q_new new frames while K/V span
             // the full virtual window (after the concat below).
             x_q_new = x_norm;
-            x_norm = ggml_concat(ctx, params.streaming_channel_in,
-                                 x_norm, /*dim=*/1);
+            x_norm  = ggml_concat(ctx, params.streaming_channel_in, x_norm, /*dim=*/1);
         }
 
         ggml_tensor * attn_out = nullptr;
@@ -962,23 +861,21 @@ ggml_tensor * build_conformer_block(ggml_context *        ctx,
             // Project K/V for the new frames only, prepend the cached
             // window, and rotate the cache forward.
             ggml_tensor * k_new = ggml_mul_mat(ctx, b.attn_k_w, x_norm);
-            if (b.attn_k_b != nullptr) k_new = ggml_add(ctx, k_new, b.attn_k_b);
+            if (b.attn_k_b != nullptr) {
+                k_new = ggml_add(ctx, k_new, b.attn_k_b);
+            }
             ggml_tensor * v_new = ggml_mul_mat(ctx, b.attn_v_w, x_norm);
-            if (b.attn_v_b != nullptr) v_new = ggml_add(ctx, v_new, b.attn_v_b);
-
-            ggml_tensor * k_all = ggml_concat(
-                ctx, params.streaming_kv_k_in, k_new, /*dim=*/1);
-            ggml_tensor * v_all = ggml_concat(
-                ctx, params.streaming_kv_v_in, v_new, /*dim=*/1);
-
-            if (params.streaming_kv_k_out != nullptr &&
-                params.streaming_kv_v_out != nullptr &&
-                params.streaming_graph != nullptr)
-            {
-                emit_rotated_cache(params.streaming_kv_k_in, k_new,
-                                   params.streaming_kv_k_out);
-                emit_rotated_cache(params.streaming_kv_v_in, v_new,
-                                   params.streaming_kv_v_out);
+            if (b.attn_v_b != nullptr) {
+                v_new = ggml_add(ctx, v_new, b.attn_v_b);
+            }
+
+            ggml_tensor * k_all = ggml_concat(ctx, params.streaming_kv_k_in, k_new, /*dim=*/1);
+            ggml_tensor * v_all = ggml_concat(ctx, params.streaming_kv_v_in, v_new, /*dim=*/1);
+
+            if (params.streaming_kv_k_out != nullptr && params.streaming_kv_v_out != nullptr &&
+                params.streaming_graph != nullptr) {
+                emit_rotated_cache(params.streaming_kv_k_in, k_new, params.streaming_kv_k_out);
+                emit_rotated_cache(params.streaming_kv_v_in, v_new, params.streaming_kv_v_out);
             }
 
             attn_out = rel_pos_mhsa(ctx, x_norm, pos_emb, b, params,
@@ -988,8 +885,7 @@ ggml_tensor * build_conformer_block(ggml_context *        ctx,
             // nullptr offline (full self-attention). rel_pos_mhsa already
             // returns only the T_q_new query rows in the streaming case,
             // so no output slicing is needed.
-            attn_out = rel_pos_mhsa(ctx, x_norm, pos_emb, b, params,
-                                    x_q_new);
+            attn_out = rel_pos_mhsa(ctx, x_norm, pos_emb, b, params, x_q_new);
         }
 
         x = ggml_add(ctx, x, attn_out);
@@ -998,18 +894,14 @@ ggml_tensor * build_conformer_block(ggml_context *        ctx,
 
     // Convolution module. Full residual.
     {
-        ggml_tensor * x_norm = layer_norm(ctx, x,
-                                          b.norm_conv_w, b.norm_conv_b);
+        ggml_tensor * x_norm   = layer_norm(ctx, x, b.norm_conv_w, b.norm_conv_b);
         ggml_tensor * conv_out = conv_module(ctx, x_norm, b, params);
-        x = ggml_add(ctx, x, conv_out);
+        x                      = ggml_add(ctx, x, conv_out);
     }
     notify("after_conv", x);
 
     // Macaron FF2.
-    x = macaron_ff_residual(ctx, x,
-                            b.norm_ff2_w, b.norm_ff2_b,
-                            b.ff2_lin1_w, b.ff2_lin1_b,
-                            b.ff2_lin2_w, b.ff2_lin2_b);
+    x = macaron_ff_residual(ctx, x, b.norm_ff2_w, b.norm_ff2_b, b.ff2_lin1_w, b.ff2_lin1_b, b.ff2_lin2_w, b.ff2_lin2_b);
     notify("after_ff2", x);
 
     // Final per-block LayerNorm.
@@ -1024,17 +916,17 @@ namespace {
 
 // Name a tensor as `<prefix>.<suffix>` if prefix is non-null. Returns t
 // unchanged.
-ggml_tensor * name_prefixed(ggml_tensor * t, const char * prefix,
-                            const char * suffix)
-{
-    if (t == nullptr || prefix == nullptr) return t;
+ggml_tensor * name_prefixed(ggml_tensor * t, const char * prefix, const char * suffix) {
+    if (t == nullptr || prefix == nullptr) {
+        return t;
+    }
     char buf[64];
     std::snprintf(buf, sizeof(buf), "%s.%s", prefix, suffix);
     ggml_set_name(t, buf);
     return t;
 }
 
-} // namespace
+}  // namespace
 
 // Pre-encode subsampling stack. Op order matches NeMo's
 // DwStridingSubsampling (conformer.py:206-328):
@@ -1054,18 +946,17 @@ ggml_tensor * build_pre_encode(ggml_context *        ctx,
                                const ConvPolicy &    policy,
                                const char *          name_prefix,
                                const char *          error_tag,
-                               PreEncodeValidMasks * valid_masks)
-{
+                               PreEncodeValidMasks * valid_masks) {
     // Masked-subsampling helper: zeros each conv intermediate's padded time
     // region after a ReLU. The mask is a graph input ne=[1, H_stage, 1, B]
     // (broadcasts over freq and channels); `slot` receives the handle for
     // the driver to fill. No-op when valid_masks is null.
-    const int64_t pe_batch = mel_in->ne[3];
-    auto apply_valid_mask = [&](ggml_tensor * x, ggml_tensor ** slot,
-                                const char * mname) -> ggml_tensor * {
-        if (valid_masks == nullptr) return x;
-        ggml_tensor * m = ggml_new_tensor_4d(ctx, GGML_TYPE_F32,
-                                             1, x->ne[1], 1, pe_batch);
+    const int64_t pe_batch         = mel_in->ne[3];
+    auto          apply_valid_mask = [&](ggml_tensor * x, ggml_tensor ** slot, const char * mname) -> ggml_tensor * {
+        if (valid_masks == nullptr) {
+            return x;
+        }
+        ggml_tensor * m = ggml_new_tensor_4d(ctx, GGML_TYPE_F32, 1, x->ne[1], 1, pe_batch);
         ggml_set_name(m, mname);
         ggml_set_input(m);
         *slot = m;
@@ -1079,40 +970,37 @@ ggml_tensor * build_pre_encode(ggml_context *        ctx,
     ggml_tensor * x = ggml_permute(ctx, mel_in,
                                    /*axis0=*/1, /*axis1=*/0,
                                    /*axis2=*/2, /*axis3=*/3);
-    x = ggml_cont(ctx, x);
-    x = name_prefixed(x, name_prefix, "mel_t");
+    x               = ggml_cont(ctx, x);
+    x               = name_prefixed(x, name_prefix, "mel_t");
 
     // Causal pre_encode: NeMo's CausalConv2D pads (left=k-1, right=stride-1)
     // on both spatial axes before the conv (p=0). Offline variants take the
     // op-side (k-1)/2 symmetric padding instead.
-    const bool causal_pe = policy.causal_pre_encode;
-    const int  pe_p_op   = causal_pe ? 0 : 1;
-    auto pad_causal = [&](ggml_tensor * t) {
-        if (!causal_pe) return t;
+    const bool causal_pe  = policy.causal_pre_encode;
+    const int  pe_p_op    = causal_pe ? 0 : 1;
+    auto       pad_causal = [&](ggml_tensor * t) {
+        if (!causal_pe) {
+            return t;
+        }
         // For k=3 / s=2: left=2, right=1 on both axes (zero F32 pads).
         const int left = 2, right = 1;
-        auto make_pad = [&](int width_w, int width_h) {
-            ggml_tensor * p = ggml_new_tensor_4d(
-                ctx, t->type,
-                width_w > 0 ? width_w : t->ne[0],
-                width_h > 0 ? width_h : t->ne[1],
-                t->ne[2], t->ne[3]);
+        auto      make_pad = [&](int width_w, int width_h) {
+            ggml_tensor * p = ggml_new_tensor_4d(ctx, t->type, width_w > 0 ? width_w : t->ne[0],
+                                                 width_h > 0 ? width_h : t->ne[1], t->ne[2], t->ne[3]);
             return ggml_fill(ctx, p, 0.0f);
         };
         // dim 0 (W = freq).
         ggml_tensor * pad_l = make_pad(left, /*h=*/0);
-        t = ggml_concat(ctx, pad_l, t, /*dim=*/0);
+        t                   = ggml_concat(ctx, pad_l, t, /*dim=*/0);
         ggml_tensor * pad_r = make_pad(right, /*h=*/0);
-        t = ggml_concat(ctx, t, pad_r, /*dim=*/0);
+        t                   = ggml_concat(ctx, t, pad_r, /*dim=*/0);
         // dim 1 (H = time). At this point ne[0] grew by left+right.
-        ggml_tensor * pad_t = ggml_new_tensor_4d(
-            ctx, t->type, t->ne[0], left, t->ne[2], t->ne[3]);
-        pad_t = ggml_fill(ctx, pad_t, 0.0f);
-        t = ggml_concat(ctx, pad_t, t, /*dim=*/1);
-        ggml_tensor * pad_b = ggml_new_tensor_4d(
-            ctx, t->type, t->ne[0], right, t->ne[2], t->ne[3]);
-        pad_b = ggml_fill(ctx, pad_b, 0.0f);
-        t = ggml_concat(ctx, t, pad_b, /*dim=*/1);
+        ggml_tensor * pad_t = ggml_new_tensor_4d(ctx, t->type, t->ne[0], left, t->ne[2], t->ne[3]);
+        pad_t               = ggml_fill(ctx, pad_t, 0.0f);
+        t                   = ggml_concat(ctx, pad_t, t, /*dim=*/1);
+        ggml_tensor * pad_b = ggml_new_tensor_4d(ctx, t->type, t->ne[0], right, t->ne[2], t->ne[3]);
+        pad_b               = ggml_fill(ctx, pad_b, 0.0f);
+        t                   = ggml_concat(ctx, t, pad_b, /*dim=*/1);
         return t;
     };
 
@@ -1126,8 +1014,7 @@ ggml_tensor * build_pre_encode(ggml_context *        ctx,
     x = name_prefixed(x, name_prefix, "conv0");
     x = ggml_relu(ctx, x);
     x = name_prefixed(x, name_prefix, "relu0");
-    x = apply_valid_mask(x, valid_masks ? &valid_masks->mask_s1 : nullptr,
-                         "pre_encode.valid_mask.s1");
+    x = apply_valid_mask(x, valid_masks ? &valid_masks->mask_s1 : nullptr, "pre_encode.valid_mask.s1");
 
     // conv2 (depthwise: channels -> channels, groups=channels, k=3 s=2).
     // im2col path (conv_2d_dw_f32) when direct_dw_in_pre_encode is false.
@@ -1155,8 +1042,7 @@ ggml_tensor * build_pre_encode(ggml_context *        ctx,
     x = name_prefixed(x, name_prefix, "conv3");
     x = ggml_relu(ctx, x);
     x = name_prefixed(x, name_prefix, "relu3");
-    x = apply_valid_mask(x, valid_masks ? &valid_masks->mask_s2 : nullptr,
-                         "pre_encode.valid_mask.s2");
+    x = apply_valid_mask(x, valid_masks ? &valid_masks->mask_s2 : nullptr, "pre_encode.valid_mask.s2");
 
     // conv5 (depthwise) -> conv6 (pointwise) -> ReLU
     x = pad_causal(x);
@@ -1182,8 +1068,7 @@ ggml_tensor * build_pre_encode(ggml_context *        ctx,
     x = name_prefixed(x, name_prefix, "conv6");
     x = ggml_relu(ctx, x);
     x = name_prefixed(x, name_prefix, "relu6");
-    x = apply_valid_mask(x, valid_masks ? &valid_masks->mask_s3 : nullptr,
-                         "pre_encode.valid_mask.s3");
+    x = apply_valid_mask(x, valid_masks ? &valid_masks->mask_s3 : nullptr, "pre_encode.valid_mask.s3");
 
     // At this point ne = [F'=16, T_enc, channels=256, 1] where
     // T_enc = floor(T_mel / 8). Flatten (F', C) into one feature axis
@@ -1192,27 +1077,26 @@ ggml_tensor * build_pre_encode(ggml_context *        ctx,
     // ggml ne is: permute F' to axis 0, C to axis 1, then collapse 0 and 1:
     //   permute (0, 2, 1, 3): [F', T, C, 1] -> [F', C, T, 1]
     //   ggml_cont; reshape -> [F'*C, T] = [pre_encode_in, T_enc]
-    const int64_t F_prime = x->ne[0];
-    const int64_t T_enc   = x->ne[1];
-    const int64_t C       = x->ne[2];
+    const int64_t F_prime       = x->ne[0];
+    const int64_t T_enc         = x->ne[1];
+    const int64_t C             = x->ne[2];
     // Utterance batch rides the conv "N" axis (ne[3]) through the stem; the
     // flatten + linear below land it on ne[2] == B for the conformer blocks.
-    const int64_t B       = x->ne[3];
+    const int64_t B             = x->ne[3];
     const int64_t pre_encode_in = F_prime * C;
 
     // Sanity check: the linear layer expects exactly pre_encode_in features.
     if (pe.out_w != nullptr && pre_encode_in != pe.out_w->ne[0]) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "%s encoder: pre_encode_in mismatch: "
-                     "F'*C=%lld but out_w expects %lld",
-                     error_tag != nullptr ? error_tag : "conformer",
-                     static_cast<long long>(pre_encode_in),
-                     static_cast<long long>(pe.out_w->ne[0]));
+                "%s encoder: pre_encode_in mismatch: "
+                "F'*C=%lld but out_w expects %lld",
+                error_tag != nullptr ? error_tag : "conformer", static_cast<long long>(pre_encode_in),
+                static_cast<long long>(pe.out_w->ne[0]));
         return nullptr;
     }
 
     x = ggml_permute(ctx, x, /*axis0=*/0, /*axis1=*/2,
-                              /*axis2=*/1, /*axis3=*/3);
+                     /*axis2=*/1, /*axis3=*/3);
     x = name_prefixed(x, name_prefix, "permuted");
     x = ggml_cont(ctx, x);
     x = name_prefixed(x, name_prefix, "flat_pre");
@@ -1227,13 +1111,12 @@ ggml_tensor * build_pre_encode(ggml_context *        ctx,
     // Add bias [d_model], broadcast to [d_model, T_enc, 1, 1].
     if (pe.out_b != nullptr) {
         const int64_t d_model = pe.out_b->ne[0];
-        ggml_tensor * bias_4d = ggml_reshape_4d(ctx, pe.out_b,
-                                                d_model, 1, 1, 1);
-        x = ggml_add(ctx, x, bias_4d);
+        ggml_tensor * bias_4d = ggml_reshape_4d(ctx, pe.out_b, d_model, 1, 1, 1);
+        x                     = ggml_add(ctx, x, bias_4d);
     }
     x = name_prefixed(x, name_prefix, "out");
 
     return x;
 }
 
-} // namespace transcribe::conformer
+}  // namespace transcribe::conformer
diff --git a/src/conformer/conformer.h b/src/conformer/conformer.h
index 8e9b891a..cb1c547a 100644
--- a/src/conformer/conformer.h
+++ b/src/conformer/conformer.h
@@ -30,71 +30,71 @@ constexpr float kLayerNormEps = 1e-5f;
 // Nullable-pointer projection over the pre_encode weights. The family
 // fills this from its own weights struct at the call site.
 struct PreEncodeView {
-    ggml_tensor * conv0_w = nullptr; // [KW=3, KH=3, IC=1,        OC=channels]
-    ggml_tensor * conv0_b = nullptr; // [channels]
-    ggml_tensor * conv2_w = nullptr; // depthwise [KW=3, KH=3, 1, OC=channels]
-    ggml_tensor * conv2_b = nullptr; // [channels]
-    ggml_tensor * conv3_w = nullptr; // pointwise [1, 1, channels, channels]
-    ggml_tensor * conv3_b = nullptr; // [channels]
-    ggml_tensor * conv5_w = nullptr; // depthwise
+    ggml_tensor * conv0_w = nullptr;  // [KW=3, KH=3, IC=1,        OC=channels]
+    ggml_tensor * conv0_b = nullptr;  // [channels]
+    ggml_tensor * conv2_w = nullptr;  // depthwise [KW=3, KH=3, 1, OC=channels]
+    ggml_tensor * conv2_b = nullptr;  // [channels]
+    ggml_tensor * conv3_w = nullptr;  // pointwise [1, 1, channels, channels]
+    ggml_tensor * conv3_b = nullptr;  // [channels]
+    ggml_tensor * conv5_w = nullptr;  // depthwise
     ggml_tensor * conv5_b = nullptr;
-    ggml_tensor * conv6_w = nullptr; // pointwise
+    ggml_tensor * conv6_w = nullptr;  // pointwise
     ggml_tensor * conv6_b = nullptr;
     // Final projection from [channels * (num_mels / subsampling)] to d_model.
-    ggml_tensor * out_w   = nullptr; // [pre_encode_in, d_model]
-    ggml_tensor * out_b   = nullptr; // [d_model]
+    ggml_tensor * out_w   = nullptr;  // [pre_encode_in, d_model]
+    ggml_tensor * out_b   = nullptr;  // [d_model]
 };
 
 // Nullable-pointer projection over one Conformer block's weights.
 // Every `_b` (bias) slot is optional — null = skip the add.
 struct BlockView {
     // Macaron FF1.
-    ggml_tensor * norm_ff1_w = nullptr; // [d_model]
-    ggml_tensor * norm_ff1_b = nullptr; // [d_model]
-    ggml_tensor * ff1_lin1_w = nullptr; // [d_model, d_ff]
-    ggml_tensor * ff1_lin1_b = nullptr; // [d_ff], nullable
-    ggml_tensor * ff1_lin2_w = nullptr; // [d_ff, d_model]
-    ggml_tensor * ff1_lin2_b = nullptr; // [d_model], nullable
+    ggml_tensor * norm_ff1_w = nullptr;  // [d_model]
+    ggml_tensor * norm_ff1_b = nullptr;  // [d_model]
+    ggml_tensor * ff1_lin1_w = nullptr;  // [d_model, d_ff]
+    ggml_tensor * ff1_lin1_b = nullptr;  // [d_ff], nullable
+    ggml_tensor * ff1_lin2_w = nullptr;  // [d_ff, d_model]
+    ggml_tensor * ff1_lin2_b = nullptr;  // [d_model], nullable
 
     // Self-attention with relative positional encoding.
-    ggml_tensor * norm_attn_w = nullptr; // [d_model]
-    ggml_tensor * norm_attn_b = nullptr; // [d_model]
-    ggml_tensor * attn_q_w    = nullptr; // [d_model, d_model]
-    ggml_tensor * attn_q_b    = nullptr; // [d_model], nullable
-    ggml_tensor * attn_k_w    = nullptr; // [d_model, d_model]
-    ggml_tensor * attn_k_b    = nullptr; // [d_model], nullable
-    ggml_tensor * attn_v_w    = nullptr; // [d_model, d_model]
-    ggml_tensor * attn_v_b    = nullptr; // [d_model], nullable
-    ggml_tensor * attn_out_w  = nullptr; // [d_model, d_model]
-    ggml_tensor * attn_out_b  = nullptr; // [d_model], nullable
-    ggml_tensor * attn_pos_w  = nullptr; // [d_model, d_model] linear_pos (no bias)
-    ggml_tensor * attn_pos_u  = nullptr; // [n_head, head_dim]
-    ggml_tensor * attn_pos_v  = nullptr; // [n_head, head_dim]
+    ggml_tensor * norm_attn_w = nullptr;  // [d_model]
+    ggml_tensor * norm_attn_b = nullptr;  // [d_model]
+    ggml_tensor * attn_q_w    = nullptr;  // [d_model, d_model]
+    ggml_tensor * attn_q_b    = nullptr;  // [d_model], nullable
+    ggml_tensor * attn_k_w    = nullptr;  // [d_model, d_model]
+    ggml_tensor * attn_k_b    = nullptr;  // [d_model], nullable
+    ggml_tensor * attn_v_w    = nullptr;  // [d_model, d_model]
+    ggml_tensor * attn_v_b    = nullptr;  // [d_model], nullable
+    ggml_tensor * attn_out_w  = nullptr;  // [d_model, d_model]
+    ggml_tensor * attn_out_b  = nullptr;  // [d_model], nullable
+    ggml_tensor * attn_pos_w  = nullptr;  // [d_model, d_model] linear_pos (no bias)
+    ggml_tensor * attn_pos_u  = nullptr;  // [n_head, head_dim]
+    ggml_tensor * attn_pos_v  = nullptr;  // [n_head, head_dim]
 
     // Convolution module. Pointwise conv1 is 2*d_model for GLU.
-    ggml_tensor * norm_conv_w         = nullptr; // [d_model]
-    ggml_tensor * norm_conv_b         = nullptr; // [d_model]
-    ggml_tensor * conv_pw1_w          = nullptr; // [1, d_model, 2*d_model]
-    ggml_tensor * conv_pw1_b          = nullptr; // [2*d_model], nullable
-    ggml_tensor * conv_dw_w           = nullptr; // [k, 1, d_model]
-    ggml_tensor * conv_dw_b           = nullptr; // [d_model], nullable
-    ggml_tensor * conv_pw2_w          = nullptr; // [1, d_model, d_model]
-    ggml_tensor * conv_pw2_b          = nullptr; // [d_model], nullable
+    ggml_tensor * norm_conv_w         = nullptr;  // [d_model]
+    ggml_tensor * norm_conv_b         = nullptr;  // [d_model]
+    ggml_tensor * conv_pw1_w          = nullptr;  // [1, d_model, 2*d_model]
+    ggml_tensor * conv_pw1_b          = nullptr;  // [2*d_model], nullable
+    ggml_tensor * conv_dw_w           = nullptr;  // [k, 1, d_model]
+    ggml_tensor * conv_dw_b           = nullptr;  // [d_model], nullable
+    ggml_tensor * conv_pw2_w          = nullptr;  // [1, d_model, d_model]
+    ggml_tensor * conv_pw2_b          = nullptr;  // [d_model], nullable
     // Post-depthwise normalisation. Exactly one pair is populated per block
     // per BlockParams::conv_norm_type: BatchNorm (conv_bn_fused_*, fused at
     // load) or LayerNorm (conv_ln_*, per-channel mean/std at inference).
-    ggml_tensor * conv_bn_fused_scale = nullptr; // [d_model]
-    ggml_tensor * conv_bn_fused_bias  = nullptr; // [d_model]
-    ggml_tensor * conv_ln_w           = nullptr; // [d_model]
-    ggml_tensor * conv_ln_b           = nullptr; // [d_model]
+    ggml_tensor * conv_bn_fused_scale = nullptr;  // [d_model]
+    ggml_tensor * conv_bn_fused_bias  = nullptr;  // [d_model]
+    ggml_tensor * conv_ln_w           = nullptr;  // [d_model]
+    ggml_tensor * conv_ln_b           = nullptr;  // [d_model]
 
     // Macaron FF2.
     ggml_tensor * norm_ff2_w = nullptr;
     ggml_tensor * norm_ff2_b = nullptr;
     ggml_tensor * ff2_lin1_w = nullptr;
-    ggml_tensor * ff2_lin1_b = nullptr; // nullable
+    ggml_tensor * ff2_lin1_b = nullptr;  // nullable
     ggml_tensor * ff2_lin2_w = nullptr;
-    ggml_tensor * ff2_lin2_b = nullptr; // nullable
+    ggml_tensor * ff2_lin2_b = nullptr;  // nullable
 
     // Final per-block layer norm.
     ggml_tensor * norm_out_w = nullptr;
@@ -110,9 +110,9 @@ struct BlockView {
 // direct_dw_* false (im2col), which is safe on Metal where the direct 2-D
 // depthwise kernel is not implemented for all shapes.
 struct ConvPolicy {
-    bool direct_pw                = true;
-    bool direct_dw_in_block       = false;
-    bool direct_dw_in_pre_encode  = false;
+    bool direct_pw               = true;
+    bool direct_dw_in_block      = false;
+    bool direct_dw_in_pre_encode = false;
 
     // Causal pre_encode convolutions. NeMo's cache-aware streaming swaps
     // every Conv2d in ConvSubsampling for CausalConv2D, padding
@@ -120,7 +120,7 @@ struct ConvPolicy {
     // is (left=2, right=1), different from the offline (k-1)/2 symmetric
     // path, and shifts both the freq and time output dims. False on every
     // offline variant; true on nemotron-speech-streaming-en.
-    bool causal_pre_encode        = false;
+    bool causal_pre_encode = false;
 };
 
 // Resolve a conv-dispatch toggle from its env overrides. The DIRECT var forces
@@ -129,9 +129,7 @@ struct ConvPolicy {
 // pointwise and the per-family depthwise dispatch helpers, so the env-var read
 // has exactly one definition. `direct_env` / `no_direct_env` are env var names
 // (e.g. "TRANSCRIBE_CONV_DIRECT_DW" / "TRANSCRIBE_CONV_NO_DIRECT_DW").
-bool resolve_conv_direct(const char * direct_env,
-                         const char * no_direct_env,
-                         bool         backend_default);
+bool resolve_conv_direct(const char * direct_env, const char * no_direct_env, bool backend_default);
 
 // Pointwise conv dispatch auto-detect (same answer for every family today).
 // Env overrides: TRANSCRIBE_CONV_NO_DIRECT_PW forces im2col,
@@ -146,8 +144,8 @@ struct BlockParams {
     int        d_model;
     int        n_head;
     int        conv_kernel;
-    ggml_type  kv_type;      // GGML_TYPE_COUNT = auto (f16 if quant, f32 if f32)
-    bool       use_flash;    // false -> manual mul_mat + soft_max + mul_mat
+    ggml_type  kv_type;    // GGML_TYPE_COUNT = auto (f16 if quant, f32 if f32)
+    bool       use_flash;  // false -> manual mul_mat + soft_max + mul_mat
     ConvPolicy policy;
 
     // Local attention window. -1 / -1 = full attention (default).
@@ -262,10 +260,7 @@ ggml_tensor * named(ggml_tensor * t, const char * name);
 
 // LayerNorm with affine: y = gamma * (x - mean) / sqrt(var + eps) + beta.
 // `gamma` is required; `beta` may be null for bias-free LN.
-ggml_tensor * layer_norm(ggml_context * ctx,
-                         ggml_tensor *  x,
-                         ggml_tensor *  gamma,
-                         ggml_tensor *  beta);
+ggml_tensor * layer_norm(ggml_context * ctx, ggml_tensor * x, ggml_tensor * gamma, ggml_tensor * beta);
 
 // Two-linear FeedForward: y = Linear2(SiLU(Linear1(x))). Biases are
 // optional — pass nullptr to skip the add.
@@ -305,9 +300,12 @@ ggml_tensor * conv_1d_f32(ggml_context * ctx,
 ggml_tensor * conv_2d_dw_f32(ggml_context * ctx,
                              ggml_tensor *  kernel,
                              ggml_tensor *  data,
-                             int            s0, int s1,
-                             int            p0, int p1,
-                             int            d0, int d1);
+                             int            s0,
+                             int            s1,
+                             int            p0,
+                             int            p1,
+                             int            d0,
+                             int            d1);
 
 // f32-friendly 1D depthwise conv. Same Metal reasoning.
 ggml_tensor * conv_1d_dw_f32(ggml_context * ctx,
@@ -323,17 +321,12 @@ ggml_tensor * conv_1d_dw_f32(ggml_context * ctx,
 // from the load-time BN fusion and must always be present. Callers
 // that need a no-op path should skip the call entirely rather than
 // pass null.
-ggml_tensor * fused_batch_norm(ggml_context * ctx,
-                               ggml_tensor *  x,
-                               ggml_tensor *  scale_1d,
-                               ggml_tensor *  bias_1d);
+ggml_tensor * fused_batch_norm(ggml_context * ctx, ggml_tensor * x, ggml_tensor * scale_1d, ggml_tensor * bias_1d);
 
 // Add a 1-D bias [C] to a 4-D conv output [W, H, C, N] via broadcast.
 // Nullable: passing bias_1d == nullptr is a no-op that returns
 // conv_out unchanged.
-ggml_tensor * add_conv_bias(ggml_context * ctx,
-                            ggml_tensor *  conv_out,
-                            ggml_tensor *  bias_1d);
+ggml_tensor * add_conv_bias(ggml_context * ctx, ggml_tensor * conv_out, ggml_tensor * bias_1d);
 
 // Sub-blocks (exposed for families that hand-build a block).
 
@@ -343,10 +336,7 @@ ggml_tensor * add_conv_bias(ggml_context * ctx,
 // BlockParams::conv_context_{left,right} (depthwise padding),
 // BlockParams::conv_pad_mask, and BlockParams::conv_norm_type
 // (BN vs LN).
-ggml_tensor * conv_module(ggml_context *      ctx,
-                          ggml_tensor *       x,
-                          const BlockView &   b,
-                          const BlockParams & params);
+ggml_tensor * conv_module(ggml_context * ctx, ggml_tensor * x, const BlockView & b, const BlockParams & params);
 
 // Relative-position multi-head self-attention. Flash attention when
 // use_flash is true; manual mul_mat + soft_max_ext + mul_mat fallback
@@ -383,7 +373,7 @@ ggml_tensor * rel_pos_mhsa(ggml_context *      ctx,
                            ggml_tensor *       pos_emb,
                            const BlockView &   b,
                            const BlockParams & params,
-                           ggml_tensor *       x_q = nullptr,
+                           ggml_tensor *       x_q    = nullptr,
                            ggml_tensor *       k_full = nullptr,
                            ggml_tensor *       v_full = nullptr);
 
@@ -396,10 +386,8 @@ ggml_tensor * rel_pos_mhsa(ggml_context *      ctx,
 // output. Pointer-of-struct + user pointer (not std::function) keeps the
 // header C-ABI-friendly. Pass nullptr to skip observation.
 struct BlockObserver {
-    void (*on_point)(void *        user,
-                     const char *  tag,
-                     ggml_tensor * t) = nullptr;
-    void * user = nullptr;
+    void (*on_point)(void * user, const char * tag, ggml_tensor * t) = nullptr;
+    void * user                                                      = nullptr;
 };
 
 // Full Conformer block forward: FF1 -> attn -> conv -> FF2 -> LN_out.
@@ -444,4 +432,4 @@ ggml_tensor * build_pre_encode(ggml_context *        ctx,
                                const char *          error_tag,
                                PreEncodeValidMasks * valid_masks = nullptr);
 
-} // namespace transcribe::conformer
+}  // namespace transcribe::conformer
diff --git a/src/granite_conformer/shaw_attn.cpp b/src/granite_conformer/shaw_attn.cpp
index 6a047623..a40cb676 100644
--- a/src/granite_conformer/shaw_attn.cpp
+++ b/src/granite_conformer/shaw_attn.cpp
@@ -3,9 +3,9 @@
 // See shaw_attn.h for the contract.
 
 #include "shaw_attn.h"
-#include "transcribe-log.h"
 
 #include "ggml.h"
+#include "transcribe-log.h"
 
 #include <cmath>
 #include <cstdio>
@@ -14,29 +14,29 @@ namespace transcribe::granite_conformer {
 
 namespace {
 
-ggml_tensor * layer_norm(ggml_context * ctx, ggml_tensor * x,
-                         ggml_tensor * gamma, ggml_tensor * beta,
-                         float eps) {
+ggml_tensor * layer_norm(ggml_context * ctx, ggml_tensor * x, ggml_tensor * gamma, ggml_tensor * beta, float eps) {
     ggml_tensor * y = ggml_norm(ctx, x, eps);
-    y = ggml_mul(ctx, y, gamma);
-    if (beta != nullptr) y = ggml_add(ctx, y, beta);
+    y               = ggml_mul(ctx, y, gamma);
+    if (beta != nullptr) {
+        y = ggml_add(ctx, y, beta);
+    }
     return y;
 }
 
-} // namespace
-
-ggml_tensor * shaw_block_attn(ggml_context *           ctx,
-                              ggml_tensor *            x,
-                              ggml_tensor *            zero_pad,
-                              ggml_tensor *            dists,
-                              ggml_tensor *            pad_mask_3d,
-                              const ShawAttnWeights &  w,
-                              int                      n_heads,
-                              int                      head_dim,
-                              int                      context_size,
-                              int                      num_blocks,
-                              int                      T_enc,
-                              float                    layer_norm_eps) {
+}  // namespace
+
+ggml_tensor * shaw_block_attn(ggml_context *          ctx,
+                              ggml_tensor *           x,
+                              ggml_tensor *           zero_pad,
+                              ggml_tensor *           dists,
+                              ggml_tensor *           pad_mask_3d,
+                              const ShawAttnWeights & w,
+                              int                     n_heads,
+                              int                     head_dim,
+                              int                     context_size,
+                              int                     num_blocks,
+                              int                     T_enc,
+                              float                   layer_norm_eps) {
     const int64_t inner_dim = static_cast<int64_t>(n_heads) * head_dim;
     const int64_t T_pad     = static_cast<int64_t>(context_size) * num_blocks;
     const float   scale     = 1.0f / std::sqrt(static_cast<float>(head_dim));
@@ -50,8 +50,7 @@ ggml_tensor * shaw_block_attn(ggml_context *           ctx,
     const int64_t num_blocks_eff = static_cast<int64_t>(num_blocks) * B;
 
     // Pre-LayerNorm on the T_enc input.
-    ggml_tensor * h = layer_norm(ctx, x, w.norm_attn_w, w.norm_attn_b,
-                                 layer_norm_eps);
+    ggml_tensor * h = layer_norm(ctx, x, w.norm_attn_w, w.norm_attn_b, layer_norm_eps);
 
     // Zero-pad along the time axis when T_enc is not block-aligned. The
     // pad buffer is a caller-owned graph input; nullptr is a programmer
@@ -59,8 +58,8 @@ ggml_tensor * shaw_block_attn(ggml_context *           ctx,
     if (T_pad > T_enc) {
         if (zero_pad == nullptr) {
             log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "granite_conformer::shaw_block_attn: "
-                         "zero_pad is null but T_pad > T_enc");
+                    "granite_conformer::shaw_block_attn: "
+                    "zero_pad is null but T_pad > T_enc");
             return nullptr;
         }
         h = ggml_concat(ctx, h, zero_pad, /*dim=*/1);
@@ -69,17 +68,15 @@ ggml_tensor * shaw_block_attn(ggml_context *           ctx,
 
     // QKV projections. q has no bias; kv is fused (2*inner_dim) with no
     // bias; out has bias.
-    ggml_tensor * q  = ggml_mul_mat(ctx, w.attn_q_w,  h);  // [inner_dim, T_pad]
+    ggml_tensor * q  = ggml_mul_mat(ctx, w.attn_q_w, h);   // [inner_dim, T_pad]
     ggml_tensor * kv = ggml_mul_mat(ctx, w.attn_kv_w, h);  // [2*inner_dim, T_pad]
 
     // Split kv into k, v along ne[0]. The mul_mat output is contiguous, so
     // views with a strided ne[0] are safe. ne[2] carries the utterance batch
     // (1 for single-shot, == B otherwise).
-    ggml_tensor * k = ggml_view_3d(ctx, kv, inner_dim, kv->ne[1], kv->ne[2],
-                                   kv->nb[1], kv->nb[2], /*offset=*/0);
-    ggml_tensor * v = ggml_view_3d(ctx, kv, inner_dim, kv->ne[1], kv->ne[2],
-                                   kv->nb[1], kv->nb[2],
-                                   inner_dim * ggml_element_size(kv));
+    ggml_tensor * k = ggml_view_3d(ctx, kv, inner_dim, kv->ne[1], kv->ne[2], kv->nb[1], kv->nb[2], /*offset=*/0);
+    ggml_tensor * v =
+        ggml_view_3d(ctx, kv, inner_dim, kv->ne[1], kv->ne[2], kv->nb[1], kv->nb[2], inner_dim * ggml_element_size(kv));
     k = ggml_cont(ctx, k);
     v = ggml_cont(ctx, v);
 
@@ -87,10 +84,8 @@ ggml_tensor * shaw_block_attn(ggml_context *           ctx,
     // [head_dim, context_size, n_heads, num_blocks_eff] so that
     // ggml_mul_mat(k, q) does per-(head, block, utterance) batched attention.
     auto reshape_qkv = [&](ggml_tensor * t) -> ggml_tensor * {
-        ggml_tensor * r = ggml_reshape_4d(ctx, t,
-                                          head_dim, n_heads,
-                                          context_size, num_blocks_eff);
-        r = ggml_cont(ctx, ggml_permute(ctx, r, 0, 2, 1, 3));
+        ggml_tensor * r = ggml_reshape_4d(ctx, t, head_dim, n_heads, context_size, num_blocks_eff);
+        r               = ggml_cont(ctx, ggml_permute(ctx, r, 0, 2, 1, 3));
         return r;
     };
     q = reshape_qkv(q);
@@ -101,12 +96,9 @@ ggml_tensor * shaw_block_attn(ggml_context *           ctx,
     // [context_size, context_size] int32. Materialise the per-(c, r) lookup
     // as [head_dim, context_size*context_size], then reshape to
     // [head_dim, r=context_size, c=context_size].
-    ggml_tensor * dists_flat = ggml_reshape_1d(
-        ctx, dists, static_cast<int64_t>(context_size) * context_size);
-    ggml_tensor * rel_lookup = ggml_get_rows(ctx, w.attn_rel_pos_emb,
-                                             dists_flat);
-    rel_lookup = ggml_reshape_3d(ctx, rel_lookup,
-                                 head_dim, context_size, context_size);
+    ggml_tensor * dists_flat = ggml_reshape_1d(ctx, dists, static_cast<int64_t>(context_size) * context_size);
+    ggml_tensor * rel_lookup = ggml_get_rows(ctx, w.attn_rel_pos_emb, dists_flat);
+    rel_lookup               = ggml_reshape_3d(ctx, rel_lookup, head_dim, context_size, context_size);
 
     // pos_attn[h, b, c, r] = sum_d q[h, b, c, d] * rel_lookup[c, r, d].
     // Permute q to put c on ne[2] for batched mul_mat against
@@ -123,15 +115,13 @@ ggml_tensor * shaw_block_attn(ggml_context *           ctx,
 
     // scores = (kq + pos_attn) * scale + pad_mask
     ggml_tensor * scores = ggml_add(ctx, kq, pos_attn);
-    scores = ggml_scale(ctx, scores, scale);
+    scores               = ggml_scale(ctx, scores, scale);
 
     // Broadcast the per-block additive mask across n_heads by giving it
     // ne[2]=1 in a 4D view. pad_mask_3d is [ctx, ctx, num_blocks_eff] — the
     // caller tiles the per-block pattern across the batch.
-    ggml_tensor * pad_mask_4d = ggml_reshape_4d(ctx, pad_mask_3d,
-                                                context_size, context_size,
-                                                1, num_blocks_eff);
-    scores = ggml_add(ctx, scores, pad_mask_4d);
+    ggml_tensor * pad_mask_4d = ggml_reshape_4d(ctx, pad_mask_3d, context_size, context_size, 1, num_blocks_eff);
+    scores                    = ggml_add(ctx, scores, pad_mask_4d);
 
     // Softmax over the k axis (ne[0]).
     ggml_tensor * attn = ggml_soft_max(ctx, scores);
@@ -149,16 +139,17 @@ ggml_tensor * shaw_block_attn(ggml_context *           ctx,
     // pad-row garbage from leaking through the post-attention depthwise
     // conv.
     if (T_pad > T_enc) {
-        out = ggml_view_3d(ctx, out, inner_dim, T_enc, B,
-                           out->nb[1], out->nb[2], 0);
+        out = ggml_view_3d(ctx, out, inner_dim, T_enc, B, out->nb[1], out->nb[2], 0);
         out = ggml_cont(ctx, out);
     }
 
     // Final out_proj (with bias). Operates at T_enc.
     out = ggml_mul_mat(ctx, w.attn_out_w, out);
-    if (w.attn_out_b != nullptr) out = ggml_add(ctx, out, w.attn_out_b);
+    if (w.attn_out_b != nullptr) {
+        out = ggml_add(ctx, out, w.attn_out_b);
+    }
     // out ne = [d_model, T_enc]
     return out;
 }
 
-} // namespace transcribe::granite_conformer
+}  // namespace transcribe::granite_conformer
diff --git a/src/granite_conformer/shaw_attn.h b/src/granite_conformer/shaw_attn.h
index 1d21e7da..80bae314 100644
--- a/src/granite_conformer/shaw_attn.h
+++ b/src/granite_conformer/shaw_attn.h
@@ -25,13 +25,13 @@ namespace transcribe::granite_conformer {
 // GraniteNarEncBlock, packed so the helper has no compile-time dependency on
 // either family's weights struct.
 struct ShawAttnWeights {
-    ggml_tensor * norm_attn_w     = nullptr;  // [hidden]
-    ggml_tensor * norm_attn_b     = nullptr;  // [hidden]      (nullable)
-    ggml_tensor * attn_q_w        = nullptr;  // [hidden, inner_dim]
-    ggml_tensor * attn_kv_w       = nullptr;  // [hidden, 2*inner_dim]  (fused K|V)
-    ggml_tensor * attn_rel_pos_emb = nullptr; // [head_dim, 2*max_pos_emb+1]
-    ggml_tensor * attn_out_w      = nullptr;  // [inner_dim, hidden]
-    ggml_tensor * attn_out_b      = nullptr;  // [hidden]      (nullable)
+    ggml_tensor * norm_attn_w      = nullptr;  // [hidden]
+    ggml_tensor * norm_attn_b      = nullptr;  // [hidden]      (nullable)
+    ggml_tensor * attn_q_w         = nullptr;  // [hidden, inner_dim]
+    ggml_tensor * attn_kv_w        = nullptr;  // [hidden, 2*inner_dim]  (fused K|V)
+    ggml_tensor * attn_rel_pos_emb = nullptr;  // [head_dim, 2*max_pos_emb+1]
+    ggml_tensor * attn_out_w       = nullptr;  // [inner_dim, hidden]
+    ggml_tensor * attn_out_b       = nullptr;  // [hidden]      (nullable)
 };
 
 // Build the Shaw block-local attention sub-graph.
@@ -59,17 +59,17 @@ struct ShawAttnWeights {
 //   layer_norm_eps : pre-norm eps (both Granite families use 1e-5).
 //
 // Returns: [d_model, T_enc, B] (matches input), or nullptr on shape error.
-ggml_tensor * shaw_block_attn(ggml_context *           ctx,
-                              ggml_tensor *            x,
-                              ggml_tensor *            zero_pad,
-                              ggml_tensor *            dists,
-                              ggml_tensor *            pad_mask_3d,
-                              const ShawAttnWeights &  w,
-                              int                      n_heads,
-                              int                      head_dim,
-                              int                      context_size,
-                              int                      num_blocks,
-                              int                      T_enc,
-                              float                    layer_norm_eps);
+ggml_tensor * shaw_block_attn(ggml_context *          ctx,
+                              ggml_tensor *           x,
+                              ggml_tensor *           zero_pad,
+                              ggml_tensor *           dists,
+                              ggml_tensor *           pad_mask_3d,
+                              const ShawAttnWeights & w,
+                              int                     n_heads,
+                              int                     head_dim,
+                              int                     context_size,
+                              int                     num_blocks,
+                              int                     T_enc,
+                              float                   layer_norm_eps);
 
-} // namespace transcribe::granite_conformer
+}  // namespace transcribe::granite_conformer
diff --git a/src/sanm/sanm.cpp b/src/sanm/sanm.cpp
index e8e9ac37..fb231f6c 100644
--- a/src/sanm/sanm.cpp
+++ b/src/sanm/sanm.cpp
@@ -5,7 +5,6 @@
 #include "sanm/sanm.h"
 
 #include "conformer/conformer.h"
-
 #include "ggml.h"
 
 #include <cmath>
@@ -16,10 +15,7 @@ namespace transcribe::sanm {
 // causal_lm.cpp for the CUDA COMPUTE_16F saturation rationale). SAN-M scales
 // activations by sqrt(d_model), so its internal activations run large and
 // overflow F16 on CUDA without this.
-static ggml_tensor * mul_mat_f32acc(ggml_context * ctx,
-                                    ggml_tensor *  w,
-                                    ggml_tensor *  x)
-{
+static ggml_tensor * mul_mat_f32acc(ggml_context * ctx, ggml_tensor * w, ggml_tensor * x) {
     ggml_tensor * y = ggml_mul_mat(ctx, w, x);
     if (w->type == GGML_TYPE_F16) {
         ggml_mul_mat_set_prec(y, GGML_PREC_F32);
@@ -27,13 +23,9 @@ static ggml_tensor * mul_mat_f32acc(ggml_context * ctx,
     return y;
 }
 
-ggml_tensor * sv_layer_norm(ggml_context * ctx,
-                            ggml_tensor *  x,
-                            ggml_tensor *  gamma,
-                            ggml_tensor *  beta)
-{
+ggml_tensor * sv_layer_norm(ggml_context * ctx, ggml_tensor * x, ggml_tensor * gamma, ggml_tensor * beta) {
     ggml_tensor * y = ggml_norm(ctx, x, kLayerNormEps);
-    y = ggml_mul(ctx, y, gamma);
+    y               = ggml_mul(ctx, y, gamma);
     if (beta != nullptr) {
         y = ggml_add(ctx, y, beta);
     }
@@ -41,10 +33,10 @@ ggml_tensor * sv_layer_norm(ggml_context * ctx,
 }
 
 ggml_tensor * fsmn_branch(ggml_context * ctx,
-                          ggml_tensor *  v_pre,        // [d_model, T, B]
-                          ggml_tensor *  fsmn_w,       // ne=[K, 1, d_model]
+                          ggml_tensor *  v_pre,          // [d_model, T, B]
+                          ggml_tensor *  fsmn_w,         // ne=[K, 1, d_model]
                           int            kernel,
-                          ggml_tensor *  conv_pad_mask) // [1, T, B] or null
+                          ggml_tensor *  conv_pad_mask)  // [1, T, B] or null
 {
     namespace conf = transcribe::conformer;
 
@@ -72,25 +64,23 @@ ggml_tensor * fsmn_branch(ggml_context * ctx,
         // batch axis, so use the direct depthwise-2D op (W=T, H=1, C=d_model,
         // N=B), which threads the utterance batch at ne[3]. Kernel
         // [K, 1, d_model] -> [K, 1, 1, d_model].
-        ggml_tensor * knl = ggml_reshape_4d(ctx, fsmn_w,
-                                            kernel, 1, 1, d_model);
-        ggml_tensor * data = ggml_reshape_4d(ctx, v_t,
-                                             v_t->ne[0], 1, d_model, B);
-        fsmn = ggml_conv_2d_dw_direct(ctx, knl, data,
-                                      /*s0=*/1, /*s1=*/1,
-                                      /*p0=*/padding, /*p1=*/0,
-                                      /*d0=*/1, /*d1=*/1);
+        ggml_tensor * knl  = ggml_reshape_4d(ctx, fsmn_w, kernel, 1, 1, d_model);
+        ggml_tensor * data = ggml_reshape_4d(ctx, v_t, v_t->ne[0], 1, d_model, B);
+        fsmn               = ggml_conv_2d_dw_direct(ctx, knl, data,
+                                                    /*s0=*/1, /*s1=*/1,
+                                                    /*p0=*/padding, /*p1=*/0,
+                                                    /*d0=*/1, /*d1=*/1);
         // [T, 1, d_model, B] -> [T, d_model, B].
-        fsmn = ggml_reshape_3d(ctx, fsmn, fsmn->ne[0], d_model, B);
+        fsmn               = ggml_reshape_3d(ctx, fsmn, fsmn->ne[0], d_model, B);
     } else {
         // Single-shot: im2col path.
         fsmn = conf::conv_1d_dw_f32(ctx, fsmn_w, v_t,
                                     /*stride=*/1, /*padding=*/padding,
                                     /*dilation=*/1);
         // fsmn ne=[T, d_model, 1]. Drop the singleton batch.
-        fsmn = ggml_reshape_2d(ctx, fsmn, fsmn->ne[0], fsmn->ne[1]); // [T, d_model]
+        fsmn = ggml_reshape_2d(ctx, fsmn, fsmn->ne[0], fsmn->ne[1]);  // [T, d_model]
     }
-    fsmn = ggml_cont(ctx, ggml_transpose(ctx, fsmn));  // [d_model, T, B]
+    fsmn = ggml_cont(ctx, ggml_transpose(ctx, fsmn));                 // [d_model, T, B]
 
     // Residual within the FSMN: x_fsmn += masked_v. (Padded frames carry
     // unmasked residual here, but they are masked out of attention and
@@ -100,31 +90,29 @@ ggml_tensor * fsmn_branch(ggml_context * ctx,
 }
 
 ggml_tensor * sanm_attention(ggml_context *          ctx,
-                             ggml_tensor *           x,         // [d_in, T, B]
+                             ggml_tensor *           x,  // [d_in, T, B]
                              const SanmBlockView &   b,
-                             const SanmBlockParams & p)
-{
-    const int   d_model  = p.d_model;
-    const int   n_heads  = p.n_heads;
-    const int   kernel   = p.kernel;
-    const int   head_dim = d_model / n_heads;
-    const int64_t T      = x->ne[1];
-    const int64_t B      = x->ne[2];
-    const float scale    = 1.0f / std::sqrt(static_cast<float>(head_dim));
+                             const SanmBlockParams & p) {
+    const int     d_model  = p.d_model;
+    const int     n_heads  = p.n_heads;
+    const int     kernel   = p.kernel;
+    const int     head_dim = d_model / n_heads;
+    const int64_t T        = x->ne[1];
+    const int64_t B        = x->ne[2];
+    const float   scale    = 1.0f / std::sqrt(static_cast<float>(head_dim));
 
     // Fused QKV projection. W_qkv ne=[d_in, 3*d_model] (PyTorch
     // [3*d_model, d_in] stored ggml-style as [d_in, 3*d_model]).
     ggml_tensor * qkv = mul_mat_f32acc(ctx, b.attn_qkv_w, x);  // [3*d_model, T, B]
-    qkv = ggml_add(ctx, qkv, b.attn_qkv_b);
+    qkv               = ggml_add(ctx, qkv, b.attn_qkv_b);
 
     // Split QKV along the channel axis (ne[0]). Each view is contiguous
     // in time (ne[1]) and batch (ne[2]) but the channel slices live at
     // offsets 0, d_model, 2*d_model. The utterance batch rides ne[2].
-    const size_t qkv_nb1 = qkv->nb[1];
-    const size_t qkv_nb2 = qkv->nb[2];
-    auto split_qkv = [&](size_t channel_offset) {
-        return ggml_view_3d(ctx, qkv, d_model, T, B, qkv_nb1, qkv_nb2,
-                            channel_offset * sizeof(float));
+    const size_t qkv_nb1   = qkv->nb[1];
+    const size_t qkv_nb2   = qkv->nb[2];
+    auto         split_qkv = [&](size_t channel_offset) {
+        return ggml_view_3d(ctx, qkv, d_model, T, B, qkv_nb1, qkv_nb2, channel_offset * sizeof(float));
     };
     ggml_tensor * q = split_qkv(0);
     ggml_tensor * k = split_qkv(static_cast<size_t>(d_model));
@@ -136,8 +124,7 @@ ggml_tensor * sanm_attention(ggml_context *          ctx,
     ggml_tensor * v_pre = ggml_cont(ctx, v);
 
     // FSMN branch (parallel to SDPA).
-    ggml_tensor * fsmn = fsmn_branch(ctx, v_pre, b.attn_fsmn_w, kernel,
-                                     p.conv_pad_mask);
+    ggml_tensor * fsmn = fsmn_branch(ctx, v_pre, b.attn_fsmn_w, kernel, p.conv_pad_mask);
 
     // SDPA. Reshape Q,K,V to [head_dim, n_heads, T, B]. The fused QKV split
     // is non-contiguous along the channel axis, so cont each before reshape.
@@ -152,7 +139,7 @@ ggml_tensor * sanm_attention(ggml_context *          ctx,
     // Attention layout: ne=[head_dim, T, n_heads, B] (head_dim innermost,
     // time at ne[1], heads at ne[2], utterance batch at ne[3]).
     auto to_attn_layout = [&](ggml_tensor * t) {
-        t = ggml_permute(ctx, t, 0, 2, 1, 3);   // [head_dim, T, n_heads, B]
+        t = ggml_permute(ctx, t, 0, 2, 1, 3);  // [head_dim, T, n_heads, B]
         return ggml_cont(ctx, t);
     };
     qh = to_attn_layout(qh);
@@ -165,9 +152,8 @@ ggml_tensor * sanm_attention(ggml_context *          ctx,
     // (and single-shot) take the flash path.
     ggml_tensor * o;
     if (p.use_flash && p.attn_pad_mask == nullptr) {
-        o = ggml_flash_attn_ext(
-            ctx, qh, kh, vh, /*mask=*/nullptr,
-            /*scale=*/scale, /*max_bias=*/0.0f, /*logit_softcap=*/0.0f);
+        o = ggml_flash_attn_ext(ctx, qh, kh, vh, /*mask=*/nullptr,
+                                /*scale=*/scale, /*max_bias=*/0.0f, /*logit_softcap=*/0.0f);
         // ggml_flash_attn_ext returns ne=[head_dim, n_heads, T, B] — already
         // heads-concatenated in memory. Reshape directly to [d_model, T, B].
         o = ggml_cont(ctx, o);
@@ -178,13 +164,12 @@ ggml_tensor * sanm_attention(ggml_context *          ctx,
         if (p.attn_pad_mask != nullptr) {
             kq = ggml_add(ctx, kq, p.attn_pad_mask);
         }
-        ggml_tensor * kq_soft = ggml_soft_max_ext(
-            ctx, kq, /*mask=*/nullptr, scale, /*max_bias=*/0.0f);
+        ggml_tensor * kq_soft = ggml_soft_max_ext(ctx, kq, /*mask=*/nullptr, scale, /*max_bias=*/0.0f);
         // V^T: [T, head_dim, n_heads, B].
-        ggml_tensor * v_t = ggml_cont(ctx, ggml_permute(ctx, vh, 1, 0, 2, 3));
-        o = ggml_mul_mat(ctx, v_t, kq_soft);     // [head_dim, T, n_heads, B]
-        o = ggml_cont(ctx, ggml_permute(ctx, o, 0, 2, 1, 3)); // [head_dim, n_heads, T, B]
-        o = ggml_reshape_3d(ctx, o, d_model, T, B);
+        ggml_tensor * v_t     = ggml_cont(ctx, ggml_permute(ctx, vh, 1, 0, 2, 3));
+        o                     = ggml_mul_mat(ctx, v_t, kq_soft);                   // [head_dim, T, n_heads, B]
+        o                     = ggml_cont(ctx, ggml_permute(ctx, o, 0, 2, 1, 3));  // [head_dim, n_heads, T, B]
+        o                     = ggml_reshape_3d(ctx, o, d_model, T, B);
     }
 
     o = mul_mat_f32acc(ctx, b.attn_out_w, o);
@@ -194,75 +179,69 @@ ggml_tensor * sanm_attention(ggml_context *          ctx,
     return ggml_add(ctx, o, fsmn);
 }
 
-ggml_tensor * sanm_ffn(ggml_context *        ctx,
-                       ggml_tensor *         x,
-                       const SanmBlockView & b)
-{
+ggml_tensor * sanm_ffn(ggml_context * ctx, ggml_tensor * x, const SanmBlockView & b) {
     ggml_tensor * h = mul_mat_f32acc(ctx, b.ffn_fc1_w, x);
-    h = ggml_add(ctx, h, b.ffn_fc1_b);
-    h = ggml_relu(ctx, h);
-    h = mul_mat_f32acc(ctx, b.ffn_fc2_w, h);
-    h = ggml_add(ctx, h, b.ffn_fc2_b);
+    h               = ggml_add(ctx, h, b.ffn_fc1_b);
+    h               = ggml_relu(ctx, h);
+    h               = mul_mat_f32acc(ctx, b.ffn_fc2_w, h);
+    h               = ggml_add(ctx, h, b.ffn_fc2_b);
     return h;
 }
 
 ggml_tensor * sanm_block_residual(ggml_context *          ctx,
                                   ggml_tensor *           x,
                                   const SanmBlockView &   b,
-                                  const SanmBlockParams & p)
-{
+                                  const SanmBlockParams & p) {
     ggml_tensor * y = sv_layer_norm(ctx, x, b.norm_attn_w, b.norm_attn_b);
-    y = sanm_attention(ctx, y, b, p);
-    x = ggml_add(ctx, x, y);
+    y               = sanm_attention(ctx, y, b, p);
+    x               = ggml_add(ctx, x, y);
 
     ggml_tensor * z = sv_layer_norm(ctx, x, b.norm_ffn_w, b.norm_ffn_b);
-    z = sanm_ffn(ctx, z, b);
+    z               = sanm_ffn(ctx, z, b);
     return ggml_add(ctx, x, z);
 }
 
 ggml_tensor * sanm_block_projection(ggml_context *          ctx,
-                                    ggml_tensor *           x,        // [d_input, T]
+                                    ggml_tensor *           x,  // [d_input, T]
                                     const SanmBlockView &   b,
-                                    const SanmBlockParams & p)
-{
+                                    const SanmBlockParams & p) {
     ggml_tensor * y = sv_layer_norm(ctx, x, b.norm_attn_w, b.norm_attn_b);
-    y = sanm_attention(ctx, y, b, p);
+    y               = sanm_attention(ctx, y, b, p);
     // No attention residual — the channel count changes (e.g. 560 → 512).
-    x = y;
+    x               = y;
 
     ggml_tensor * z = sv_layer_norm(ctx, x, b.norm_ffn_w, b.norm_ffn_b);
-    z = sanm_ffn(ctx, z, b);
+    z               = sanm_ffn(ctx, z, b);
     return ggml_add(ctx, x, z);
 }
 
-void build_sinusoidal_pe(std::vector<float> & out,
-                         int                  depth,
-                         int                  T)
-{
+void build_sinusoidal_pe(std::vector<float> & out, int depth, int T) {
     out.assign(static_cast<size_t>(T) * depth, 0.0f);
-    if (depth <= 1 || T <= 0) return;
+    if (depth <= 1 || T <= 0) {
+        return;
+    }
 
     const int half = depth / 2;
-    if (half <= 1) return;
+    if (half <= 1) {
+        return;
+    }
 
-    const double log_increment =
-        std::log(10000.0) / static_cast<double>(half - 1);
+    const double log_increment = std::log(10000.0) / static_cast<double>(half - 1);
 
     std::vector<double> inv_ts(static_cast<size_t>(half));
     for (int k = 0; k < half; ++k) {
-        inv_ts[static_cast<size_t>(k)] =
-            std::exp(static_cast<double>(k) * (-log_increment));
+        inv_ts[static_cast<size_t>(k)] = std::exp(static_cast<double>(k) * (-log_increment));
     }
 
     for (int i = 0; i < T; ++i) {
         const double pos = static_cast<double>(i + 1);  // 1-based
-        float * row = out.data() + static_cast<size_t>(i) * depth;
+        float *      row = out.data() + static_cast<size_t>(i) * depth;
         for (int k = 0; k < half; ++k) {
             const double s = pos * inv_ts[static_cast<size_t>(k)];
-            row[k]        = static_cast<float>(std::sin(s));
-            row[half + k] = static_cast<float>(std::cos(s));
+            row[k]         = static_cast<float>(std::sin(s));
+            row[half + k]  = static_cast<float>(std::cos(s));
         }
     }
 }
 
-} // namespace transcribe::sanm
+}  // namespace transcribe::sanm
diff --git a/src/sanm/sanm.h b/src/sanm/sanm.h
index f9791104..4dbe4d97 100644
--- a/src/sanm/sanm.h
+++ b/src/sanm/sanm.h
@@ -40,19 +40,19 @@ constexpr float kLayerNormEps = 1e-12f;
 //   ffn_fc2_w       [d_ff, d_model]
 //   ffn_fc2_b       [d_model]
 struct SanmBlockView {
-    ggml_tensor * norm_attn_w  = nullptr;
-    ggml_tensor * norm_attn_b  = nullptr;
-    ggml_tensor * attn_qkv_w   = nullptr;
-    ggml_tensor * attn_qkv_b   = nullptr;
-    ggml_tensor * attn_out_w   = nullptr;
-    ggml_tensor * attn_out_b   = nullptr;
-    ggml_tensor * attn_fsmn_w  = nullptr;
-    ggml_tensor * norm_ffn_w   = nullptr;
-    ggml_tensor * norm_ffn_b   = nullptr;
-    ggml_tensor * ffn_fc1_w    = nullptr;
-    ggml_tensor * ffn_fc1_b    = nullptr;
-    ggml_tensor * ffn_fc2_w    = nullptr;
-    ggml_tensor * ffn_fc2_b    = nullptr;
+    ggml_tensor * norm_attn_w = nullptr;
+    ggml_tensor * norm_attn_b = nullptr;
+    ggml_tensor * attn_qkv_w  = nullptr;
+    ggml_tensor * attn_qkv_b  = nullptr;
+    ggml_tensor * attn_out_w  = nullptr;
+    ggml_tensor * attn_out_b  = nullptr;
+    ggml_tensor * attn_fsmn_w = nullptr;
+    ggml_tensor * norm_ffn_w  = nullptr;
+    ggml_tensor * norm_ffn_b  = nullptr;
+    ggml_tensor * ffn_fc1_w   = nullptr;
+    ggml_tensor * ffn_fc1_b   = nullptr;
+    ggml_tensor * ffn_fc2_w   = nullptr;
+    ggml_tensor * ffn_fc2_b   = nullptr;
 };
 
 // Per-call shape for the SAN-M block. The batch axis rides ne[2] (B derived
@@ -67,7 +67,7 @@ struct SanmBlockView {
 struct SanmBlockParams {
     int n_heads = 0;
     int d_model = 0;
-    int kernel  = 0;       // FSMN depthwise kernel width (sanm_shift=0)
+    int kernel  = 0;  // FSMN depthwise kernel width (sanm_shift=0)
 
     ggml_tensor * attn_pad_mask = nullptr;
     ggml_tensor * conv_pad_mask = nullptr;
@@ -75,10 +75,7 @@ struct SanmBlockParams {
 };
 
 // LayerNorm with kLayerNormEps. `beta` is optional (may be nullptr).
-ggml_tensor * sv_layer_norm(ggml_context * ctx,
-                            ggml_tensor *  x,
-                            ggml_tensor *  gamma,
-                            ggml_tensor *  beta);
+ggml_tensor * sv_layer_norm(ggml_context * ctx, ggml_tensor * x, ggml_tensor * gamma, ggml_tensor * beta);
 
 // FSMN parallel branch: depthwise conv1d on V (kernel-symmetric padding)
 // + V residual. Input layout `v_pre` ne=[d_model, T, B]; output same shape
@@ -98,15 +95,10 @@ ggml_tensor * fsmn_branch(ggml_context * ctx,
 // Variable-length batches supply p.attn_pad_mask / p.conv_pad_mask; a
 // non-null attn_pad_mask forces the manual SDPA path. Same-length batches
 // (and single-shot) run the flash path with no mask.
-ggml_tensor * sanm_attention(ggml_context *          ctx,
-                             ggml_tensor *           x,
-                             const SanmBlockView &   b,
-                             const SanmBlockParams & p);
+ggml_tensor * sanm_attention(ggml_context * ctx, ggml_tensor * x, const SanmBlockView & b, const SanmBlockParams & p);
 
 // 2-layer ReLU FFN (no residual; caller adds it).
-ggml_tensor * sanm_ffn(ggml_context *        ctx,
-                       ggml_tensor *         x,
-                       const SanmBlockView & b);
+ggml_tensor * sanm_ffn(ggml_context * ctx, ggml_tensor * x, const SanmBlockView & b);
 
 // Residual SAN-M block (in==out width). Used by encoders[*] and
 // tp_encoders[*]. Adds attn-branch residual, then ffn residual.
@@ -135,8 +127,6 @@ ggml_tensor * sanm_block_projection(ggml_context *          ctx,
 //
 //   Matches funasr.SinusoidalPositionEncoder.encode (Vaswani-style
 //   additive PE with `torch.cat([sin, cos], dim=2)`).
-void build_sinusoidal_pe(std::vector<float> & out,
-                         int                  depth,
-                         int                  T);
+void build_sinusoidal_pe(std::vector<float> & out, int depth, int T);
 
-} // namespace transcribe::sanm
+}  // namespace transcribe::sanm
diff --git a/src/transcribe-abi.h b/src/transcribe-abi.h
index bdf46770..dc792feb 100644
--- a/src/transcribe-abi.h
+++ b/src/transcribe-abi.h
@@ -38,11 +38,10 @@ inline transcribe_status check_input_struct_size(uint64_t got, uint64_t want) {
 // library never writes past what the caller declared, and never reads
 // past what it staged. caller_size is uint64_t (matches the public
 // struct_size field type); library_size is size_t (always sizeof(T)).
-inline void copy_out_prefix(void * dst, const void * src,
-                            uint64_t caller_size, size_t library_size) {
+inline void copy_out_prefix(void * dst, const void * src, uint64_t caller_size, size_t library_size) {
     const uint64_t lib = static_cast<uint64_t>(library_size);
     const uint64_t n   = caller_size < lib ? caller_size : lib;
     std::memcpy(dst, src, static_cast<size_t>(n));
 }
 
-} // namespace transcribe
+}  // namespace transcribe
diff --git a/src/transcribe-arch.cpp b/src/transcribe-arch.cpp
index 84e72daf..27010ad7 100644
--- a/src/transcribe-arch.cpp
+++ b/src/transcribe-arch.cpp
@@ -11,22 +11,69 @@
 namespace transcribe {
 
 // Per-family Arch instances. Defined in src/arch/<family>/model.cpp.
-namespace parakeet           { extern const Arch arch; }
-namespace cohere             { extern const Arch arch; }
-namespace canary             { extern const Arch arch; }
-namespace qwen3_asr          { extern const Arch arch; }
-namespace voxtral            { extern const Arch arch; }
-namespace voxtral_realtime   { extern const Arch arch; }
-namespace canary_qwen        { extern const Arch arch; }
-namespace whisper            { extern const Arch arch; }
-namespace moonshine          { extern const Arch arch; }
-namespace moonshine_streaming { extern const Arch arch; }
-namespace sensevoice         { extern const Arch arch; }
-namespace funasr_nano        { extern const Arch arch; }
-namespace gigaam             { extern const Arch arch; }
-namespace granite            { extern const Arch arch; }
-namespace granite_nar        { extern const Arch arch; }
-namespace medasr             { extern const Arch arch; }
+namespace parakeet {
+extern const Arch arch;
+}
+
+namespace cohere {
+extern const Arch arch;
+}
+
+namespace canary {
+extern const Arch arch;
+}
+
+namespace qwen3_asr {
+extern const Arch arch;
+}
+
+namespace voxtral {
+extern const Arch arch;
+}
+
+namespace voxtral_realtime {
+extern const Arch arch;
+}
+
+namespace canary_qwen {
+extern const Arch arch;
+}
+
+namespace whisper {
+extern const Arch arch;
+}
+
+namespace moonshine {
+extern const Arch arch;
+}
+
+namespace moonshine_streaming {
+extern const Arch arch;
+}
+
+namespace sensevoice {
+extern const Arch arch;
+}
+
+namespace funasr_nano {
+extern const Arch arch;
+}
+
+namespace gigaam {
+extern const Arch arch;
+}
+
+namespace granite {
+extern const Arch arch;
+}
+
+namespace granite_nar {
+extern const Arch arch;
+}
+
+namespace medasr {
+extern const Arch arch;
+}
 
 const Arch * find_arch(const char * name) {
     if (name == nullptr) {
@@ -34,21 +81,9 @@ const Arch * find_arch(const char * name) {
     }
 
     static const Arch * const k_archs[] = {
-        &parakeet::arch,
-        &cohere::arch,
-        &canary::arch,
-        &qwen3_asr::arch,
-        &voxtral::arch,
-        &voxtral_realtime::arch,
-        &canary_qwen::arch,
-        &whisper::arch,
-        &moonshine::arch,
-        &moonshine_streaming::arch,
-        &sensevoice::arch,
-        &funasr_nano::arch,
-        &gigaam::arch,
-        &granite::arch,
-        &granite_nar::arch,
+        &parakeet::arch,         &cohere::arch,      &canary::arch,  &qwen3_asr::arch, &voxtral::arch,
+        &voxtral_realtime::arch, &canary_qwen::arch, &whisper::arch, &moonshine::arch, &moonshine_streaming::arch,
+        &sensevoice::arch,       &funasr_nano::arch, &gigaam::arch,  &granite::arch,   &granite_nar::arch,
         &medasr::arch,
     };
     constexpr size_t k_n = sizeof(k_archs) / sizeof(k_archs[0]);
@@ -65,4 +100,4 @@ const Arch * find_arch(const char * name) {
     return nullptr;
 }
 
-} // namespace transcribe
+}  // namespace transcribe
diff --git a/src/transcribe-arch.h b/src/transcribe-arch.h
index 99781996..c88d6380 100644
--- a/src/transcribe-arch.h
+++ b/src/transcribe-arch.h
@@ -32,21 +32,18 @@ struct Arch {
     // Must be a NUL-terminated string with static lifetime.
     const char * name;
 
-    transcribe_status (*load)(
-        Loader &                               loader,
-        const transcribe_model_load_params *        params,
-        struct transcribe_model **             out_model);
-
-    transcribe_status (*init_context)(
-        struct transcribe_model *              model,
-        const transcribe_session_params *      params,
-        struct transcribe_session **           out_ctx);
-
-    transcribe_status (*run)(
-        struct transcribe_session *            ctx,
-        const float *                          pcm,
-        int                                    n_samples,
-        const transcribe_run_params *              params);
+    transcribe_status (*load)(Loader &                             loader,
+                              const transcribe_model_load_params * params,
+                              struct transcribe_model **           out_model);
+
+    transcribe_status (*init_context)(struct transcribe_model *         model,
+                                      const transcribe_session_params * params,
+                                      struct transcribe_session **      out_ctx);
+
+    transcribe_status (*run)(struct transcribe_session *   ctx,
+                             const float *                 pcm,
+                             int                           n_samples,
+                             const transcribe_run_params * params);
 
     // Optional offline batch fast path. When non-null, transcribe_run_batch
     // delegates here to process all `n` utterances in one dispatch; when
@@ -67,12 +64,11 @@ struct Arch {
     //   - The return value is the whole-batch status: OK when the dispatch
     //     ran (per-utterance failures live in each ResultSet), non-OK only
     //     for whole-batch faults (OOM, abort, backend error).
-    transcribe_status (*run_batch)(
-        struct transcribe_session *            ctx,
-        const float * const *                  pcm,
-        const int *                            n_samples,
-        int                                    n,
-        const transcribe_run_params *              params);
+    transcribe_status (*run_batch)(struct transcribe_session *   ctx,
+                                   const float * const *         pcm,
+                                   const int *                   n_samples,
+                                   int                           n,
+                                   const transcribe_run_params * params);
 
     // Optional streaming hooks. stream_begin / stream_feed /
     // stream_finalize are a required triple (the dispatcher returns
@@ -96,28 +92,22 @@ struct Arch {
     //     all output committed. Dispatcher -> FINISHED on OK, FAILED else.
     //   stream_reset: release per-utterance state / buffered audio (keeping
     //     allocations); the dispatcher forces state back to IDLE around it.
-    transcribe_status (*stream_validate)(
-        const struct transcribe_session *      ctx,
-        const transcribe_run_params *          run_params,
-        const transcribe_stream_params *       stream_params);
+    transcribe_status (*stream_validate)(const struct transcribe_session * ctx,
+                                         const transcribe_run_params *     run_params,
+                                         const transcribe_stream_params *  stream_params);
 
-    transcribe_status (*stream_begin)(
-        struct transcribe_session *            ctx,
-        const transcribe_run_params *              run_params,
-        const transcribe_stream_params *       stream_params);
+    transcribe_status (*stream_begin)(struct transcribe_session *      ctx,
+                                      const transcribe_run_params *    run_params,
+                                      const transcribe_stream_params * stream_params);
 
-    transcribe_status (*stream_feed)(
-        struct transcribe_session *            ctx,
-        const float *                          pcm,
-        int                                    n_samples,
-        transcribe_stream_update *             update);
+    transcribe_status (*stream_feed)(struct transcribe_session * ctx,
+                                     const float *               pcm,
+                                     int                         n_samples,
+                                     transcribe_stream_update *  update);
 
-    transcribe_status (*stream_finalize)(
-        struct transcribe_session *            ctx,
-        transcribe_stream_update *             update);
+    transcribe_status (*stream_finalize)(struct transcribe_session * ctx, transcribe_stream_update * update);
 
-    void (*stream_reset)(
-        struct transcribe_session *            ctx);
+    void (*stream_reset)(struct transcribe_session * ctx);
 
     // Optional kind+slot probe. Returns true when the loaded model variant
     // accepts the named extension kind on the given slot (run_params::family
@@ -125,10 +115,7 @@ struct Arch {
     // per-loaded-variant AND per-slot. NULL is reserved for "no extension
     // surface at all" — a family with no surface for one slot returns false
     // rather than NULL'ing the hook.
-    bool (*accepts_ext_kind)(
-        const struct transcribe_model *        model,
-        transcribe_ext_slot                    slot,
-        uint32_t                               kind);
+    bool (*accepts_ext_kind)(const struct transcribe_model * model, transcribe_ext_slot slot, uint32_t kind);
 
     // Optional pre-clear validation for the one-shot transcribe_run path,
     // the _RUN-slot analogue of stream_validate. Called as the LAST gate
@@ -141,13 +128,11 @@ struct Arch {
     // hook actually checks (a family that defers checks to run() trades them
     // out of the guarantee). NULL is skipped; the generic header-size + kind
     // checks remain in force.
-    transcribe_status (*run_validate)(
-        const struct transcribe_session *      ctx,
-        const transcribe_run_params *          params);
+    transcribe_status (*run_validate)(const struct transcribe_session * ctx, const transcribe_run_params * params);
 };
 
 // Look up an architecture by name. Returns nullptr if no registered
 // family matches.
 const Arch * find_arch(const char * name);
 
-} // namespace transcribe
+}  // namespace transcribe
diff --git a/src/transcribe-backend.cpp b/src/transcribe-backend.cpp
index 488895a6..2e6d2ab6 100644
--- a/src/transcribe-backend.cpp
+++ b/src/transcribe-backend.cpp
@@ -12,15 +12,23 @@ namespace transcribe {
 
 const char * kind_name(BackendKind kind) {
     switch (kind) {
-        case BackendKind::Cpu:      return "cpu";
-        case BackendKind::Metal:    return "metal";
-        case BackendKind::Vulkan:   return "vulkan";
-        case BackendKind::Cuda:     return "cuda";
-        case BackendKind::Sycl:     return "sycl";
-        case BackendKind::Accel:    return "accel";
-        case BackendKind::OtherGpu: return "gpu";
+        case BackendKind::Cpu:
+            return "cpu";
+        case BackendKind::Metal:
+            return "metal";
+        case BackendKind::Vulkan:
+            return "vulkan";
+        case BackendKind::Cuda:
+            return "cuda";
+        case BackendKind::Sycl:
+            return "sycl";
+        case BackendKind::Accel:
+            return "accel";
+        case BackendKind::OtherGpu:
+            return "gpu";
         case BackendKind::Unknown:
-        default:                    return "unknown";
+        default:
+            return "unknown";
     }
 }
 
@@ -30,45 +38,48 @@ const char * kind_name(BackendKind kind) {
 // intentional: registry names can get version suffixes or device
 // index suffixes in some ggml builds.
 static bool reg_name_is(const char * reg_name, const char * prefix) {
-    if (reg_name == nullptr || prefix == nullptr) return false;
+    if (reg_name == nullptr || prefix == nullptr) {
+        return false;
+    }
     return std::strncmp(reg_name, prefix, std::strlen(prefix)) == 0;
 }
 
-BackendKind classify_backend_type(enum ggml_backend_dev_type dev_type,
-                                  const char * reg_name)
-{
+BackendKind classify_backend_type(enum ggml_backend_dev_type dev_type, const char * reg_name) {
     if (dev_type == GGML_BACKEND_DEVICE_TYPE_CPU) {
         return BackendKind::Cpu;
     }
     if (dev_type == GGML_BACKEND_DEVICE_TYPE_ACCEL) {
         return BackendKind::Accel;
     }
-    if (dev_type != GGML_BACKEND_DEVICE_TYPE_GPU &&
-        dev_type != GGML_BACKEND_DEVICE_TYPE_IGPU)
-    {
+    if (dev_type != GGML_BACKEND_DEVICE_TYPE_GPU && dev_type != GGML_BACKEND_DEVICE_TYPE_IGPU) {
         return BackendKind::Unknown;
     }
 
-    if      (reg_name_is(reg_name, "MTL") ||
-             reg_name_is(reg_name, "Metal"))  return BackendKind::Metal;
-    else if (reg_name_is(reg_name, "Vulkan")) return BackendKind::Vulkan;
-    else if (reg_name_is(reg_name, "CUDA"))   return BackendKind::Cuda;
-    else if (reg_name_is(reg_name, "SYCL"))   return BackendKind::Sycl;
+    if (reg_name_is(reg_name, "MTL") || reg_name_is(reg_name, "Metal")) {
+        return BackendKind::Metal;
+    } else if (reg_name_is(reg_name, "Vulkan")) {
+        return BackendKind::Vulkan;
+    } else if (reg_name_is(reg_name, "CUDA")) {
+        return BackendKind::Cuda;
+    } else if (reg_name_is(reg_name, "SYCL")) {
+        return BackendKind::Sycl;
+    }
 
     return BackendKind::OtherGpu;
 }
 
 BackendKind classify_device(ggml_backend_dev_t dev) {
-    if (dev == nullptr) return BackendKind::Unknown;
+    if (dev == nullptr) {
+        return BackendKind::Unknown;
+    }
 
     // First cut: ggml's device-type classification. This tells us CPU
     // vs GPU vs IGPU vs ACCEL without any name matching. For GPU and
     // IGPU devices, the registry name resolves the vendor-specific kind.
-    const auto dev_type = ggml_backend_dev_type(dev);
-    ggml_backend_reg_t reg = ggml_backend_dev_backend_reg(dev);
-    const char * reg_name =
-        (reg != nullptr) ? ggml_backend_reg_name(reg) : nullptr;
+    const auto         dev_type = ggml_backend_dev_type(dev);
+    ggml_backend_reg_t reg      = ggml_backend_dev_backend_reg(dev);
+    const char *       reg_name = (reg != nullptr) ? ggml_backend_reg_name(reg) : nullptr;
     return classify_backend_type(dev_type, reg_name);
 }
 
-} // namespace transcribe
+}  // namespace transcribe
diff --git a/src/transcribe-backend.h b/src/transcribe-backend.h
index fda433b5..c9a2d2f8 100644
--- a/src/transcribe-backend.h
+++ b/src/transcribe-backend.h
@@ -13,14 +13,13 @@
 
 #pragma once
 
-#include "transcribe.h"
-
 #include "ggml-backend.h"
+#include "transcribe.h"
 
 #include <vector>
 
 struct ggml_backend;
-typedef struct ggml_backend *     ggml_backend_t;
+typedef struct ggml_backend * ggml_backend_t;
 struct ggml_backend_device;
 typedef struct ggml_backend_device * ggml_backend_dev_t;
 
@@ -45,8 +44,7 @@ const char * kind_name(BackendKind kind);
 
 // Unit-testable classification core. Production code normally calls
 // classify_device(), which fetches these two inputs from ggml.
-BackendKind classify_backend_type(enum ggml_backend_dev_type dev_type,
-                                  const char * reg_name);
+BackendKind classify_backend_type(enum ggml_backend_dev_type dev_type, const char * reg_name);
 
 // Classify a backend device into a BackendKind. Uses
 // ggml_backend_dev_type for the GPU/IGPU/ACCEL/CPU dimension and the
@@ -78,4 +76,4 @@ struct BackendPlan {
     std::vector<ggml_backend_t> scheduler_list;
 };
 
-} // namespace transcribe
+}  // namespace transcribe
diff --git a/src/transcribe-batch-util.cpp b/src/transcribe-batch-util.cpp
index 49a9d7c2..b556e805 100644
--- a/src/transcribe-batch-util.cpp
+++ b/src/transcribe-batch-util.cpp
@@ -1,11 +1,11 @@
 // transcribe-batch-util.cpp - see transcribe-batch-util.h.
 
 #include "transcribe-batch-util.h"
-#include "transcribe-log.h"
-#include "transcribe-session.h"
 
-#include "ggml.h"
 #include "ggml-backend.h"
+#include "ggml.h"
+#include "transcribe-log.h"
+#include "transcribe-session.h"
 
 #include <algorithm>
 #include <atomic>
@@ -14,15 +14,15 @@
 #include <vector>
 
 #if defined(__linux__)
-#include <sched.h>
+#    include <sched.h>
 #elif defined(_WIN32)
-#ifndef WIN32_LEAN_AND_MEAN
-#define WIN32_LEAN_AND_MEAN
-#endif
-#ifndef NOMINMAX  // else <windows.h>'s min/max macros clobber std::min/std::max
-#define NOMINMAX
-#endif
-#include <windows.h>
+#    ifndef WIN32_LEAN_AND_MEAN
+#        define WIN32_LEAN_AND_MEAN
+#    endif
+#    ifndef NOMINMAX  // else <windows.h>'s min/max macros clobber std::min/std::max
+#        define NOMINMAX
+#    endif
+#    include <windows.h>
 #endif
 
 namespace transcribe {
@@ -35,15 +35,20 @@ static int usable_cpu_count() {
     CPU_ZERO(&set);
     if (sched_getaffinity(0, sizeof(set), &set) == 0) {
         const int n = CPU_COUNT(&set);
-        if (n > 0) return n;
+        if (n > 0) {
+            return n;
+        }
     }
 #elif defined(_WIN32)
     DWORD_PTR proc_mask = 0, sys_mask = 0;
-    if (GetProcessAffinityMask(GetCurrentProcess(), &proc_mask, &sys_mask) &&
-        proc_mask != 0) {
+    if (GetProcessAffinityMask(GetCurrentProcess(), &proc_mask, &sys_mask) && proc_mask != 0) {
         int n = 0;
-        for (DWORD_PTR m = proc_mask; m != 0; m &= (m - 1)) ++n;  // popcount
-        if (n > 0) return n;
+        for (DWORD_PTR m = proc_mask; m != 0; m &= (m - 1)) {
+            ++n;  // popcount
+        }
+        if (n > 0) {
+            return n;
+        }
     }
 #endif
     const unsigned hw = std::thread::hardware_concurrency();
@@ -52,20 +57,27 @@ static int usable_cpu_count() {
 
 int default_n_threads(int cap) {
     int n = usable_cpu_count();
-    if (n < 1) n = 1;
-    if (cap > 0 && n > cap) n = cap;
+    if (n < 1) {
+        n = 1;
+    }
+    if (cap > 0 && n > cap) {
+        n = cap;
+    }
     return n;
 }
 
-
 int configure_sched_n_threads(ggml_backend_sched_t sched, int requested) {
     const int n_threads = requested > 0 ? requested : default_n_threads();
-    if (sched == nullptr) return n_threads;
+    if (sched == nullptr) {
+        return n_threads;
+    }
     for (int i = 0; i < ggml_backend_sched_get_n_backends(sched); ++i) {
         ggml_backend_t     be  = ggml_backend_sched_get_backend(sched, i);
         ggml_backend_dev_t dev = ggml_backend_get_device(be);
         ggml_backend_reg_t reg = dev ? ggml_backend_dev_backend_reg(dev) : nullptr;
-        if (reg == nullptr) continue;
+        if (reg == nullptr) {
+            continue;
+        }
         auto * fn = reinterpret_cast<ggml_backend_set_n_threads_t>(
             ggml_backend_reg_get_proc_address(reg, "ggml_backend_set_n_threads"));
         if (fn != nullptr) {
@@ -75,10 +87,10 @@ int configure_sched_n_threads(ggml_backend_sched_t sched, int requested) {
     return n_threads;
 }
 
-bool parallel_for_all(int n, int n_threads,
-                      const std::function<bool(int)> & work)
-{
-    if (n <= 0) return true;
+bool parallel_for_all(int n, int n_threads, const std::function<bool(int)> & work) {
+    if (n <= 0) {
+        return true;
+    }
     if (n_threads <= 0) {
         // Affinity-aware, uncapped: use every CPU the process may run on, then
         // clamp to the batch size below. (cap <= 0 disables the per-backend cap.)
@@ -86,53 +98,54 @@ bool parallel_for_all(int n, int n_threads,
     }
     n_threads = std::max(1, std::min(n, n_threads));
 
-    std::atomic<int>  next{0};
-    std::atomic<bool> all_ok{true};
-    auto worker = [&]() {
+    std::atomic<int>  next{ 0 };
+    std::atomic<bool> all_ok{ true };
+    auto              worker = [&]() {
         int i;
         while ((i = next.fetch_add(1, std::memory_order_relaxed)) < n) {
-            if (!work(i)) all_ok.store(false, std::memory_order_relaxed);
+            if (!work(i)) {
+                all_ok.store(false, std::memory_order_relaxed);
+            }
         }
     };
 
     std::vector<std::thread> pool;
     pool.reserve(static_cast<size_t>(n_threads - 1));
-    for (int w = 0; w < n_threads - 1; ++w) pool.emplace_back(worker);
+    for (int w = 0; w < n_threads - 1; ++w) {
+        pool.emplace_back(worker);
+    }
     worker();  // the calling thread participates
-    for (auto & th : pool) th.join();
+    for (auto & th : pool) {
+        th.join();
+    }
 
     return all_ok.load(std::memory_order_relaxed);
 }
 
-void pack_pad_channel_major(
-    std::vector<float> &                    dst,
-    const std::vector<std::vector<float>> & src,
-    const std::vector<int> &                lens,
-    int                                     n_ch,
-    int                                     T_max)
-{
+void pack_pad_channel_major(std::vector<float> &                    dst,
+                            const std::vector<std::vector<float>> & src,
+                            const std::vector<int> &                lens,
+                            int                                     n_ch,
+                            int                                     T_max) {
     const int    n   = static_cast<int>(src.size());
     const size_t per = static_cast<size_t>(n_ch) * static_cast<size_t>(T_max);
     dst.assign(per * static_cast<size_t>(n), 0.0f);
     for (int b = 0; b < n; ++b) {
-        const int     nb  = lens[static_cast<size_t>(b)];
-        const float * s   = src[static_cast<size_t>(b)].data();
-        float *       d   = dst.data() + static_cast<size_t>(b) * per;
+        const int     nb = lens[static_cast<size_t>(b)];
+        const float * s  = src[static_cast<size_t>(b)].data();
+        float *       d  = dst.data() + static_cast<size_t>(b) * per;
         for (int c = 0; c < n_ch; ++c) {
-            std::copy(s + static_cast<size_t>(c) * nb,
-                      s + static_cast<size_t>(c) * nb + nb,
+            std::copy(s + static_cast<size_t>(c) * nb, s + static_cast<size_t>(c) * nb + nb,
                       d + static_cast<size_t>(c) * T_max);
         }
     }
 }
 
-void fill_keypad_mask(ggml_tensor *            mask,
-                      const std::vector<int> & real_lens,
-                      int                      T,
-                      int                      n)
-{
-    if (mask == nullptr) return;
-    const float ninf = -std::numeric_limits<float>::infinity();
+void fill_keypad_mask(ggml_tensor * mask, const std::vector<int> & real_lens, int T, int n) {
+    if (mask == nullptr) {
+        return;
+    }
+    const float        ninf = -std::numeric_limits<float>::infinity();
     std::vector<float> buf(static_cast<size_t>(T) * n);
     for (int b = 0; b < n; ++b) {
         const int real = real_lens[static_cast<size_t>(b)];
@@ -143,12 +156,10 @@ void fill_keypad_mask(ggml_tensor *            mask,
     ggml_backend_tensor_set(mask, buf.data(), 0, buf.size() * sizeof(float));
 }
 
-void fill_valid_frame_mask(ggml_tensor *            mask,
-                           const std::vector<int> & real_lens,
-                           int                      T,
-                           int                      n)
-{
-    if (mask == nullptr) return;
+void fill_valid_frame_mask(ggml_tensor * mask, const std::vector<int> & real_lens, int T, int n) {
+    if (mask == nullptr) {
+        return;
+    }
     std::vector<float> buf(static_cast<size_t>(T) * n);
     for (int b = 0; b < n; ++b) {
         const int real = real_lens[static_cast<size_t>(b)];
@@ -159,74 +170,79 @@ void fill_valid_frame_mask(ggml_tensor *            mask,
     ggml_backend_tensor_set(mask, buf.data(), 0, buf.size() * sizeof(float));
 }
 
-transcribe_status decode_batch_slices(
-    transcribe_session *  session,
-    int                   n,
-    const float *         host_buf,
-    std::size_t           utt_elems,
-    int64_t               total_encode_us,
-    int64_t               total_mel_us,
-    const std::function<transcribe_status(int b, const float * slice)> & decode_fn)
-{
+transcribe_status decode_batch_slices(transcribe_session * session,
+                                      int                  n,
+                                      const float *        host_buf,
+                                      std::size_t          utt_elems,
+                                      int64_t              total_encode_us,
+                                      int64_t              total_mel_us,
+                                      const std::function<transcribe_status(int b, const float * slice)> & decode_fn) {
     const int64_t enc_per_utt = total_encode_us / std::max(1, n);
-    const int64_t mel_per_utt = total_mel_us    / std::max(1, n);
+    const int64_t mel_per_utt = total_mel_us / std::max(1, n);
     for (int b = 0; b < n; ++b) {
-        if (session->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
+        if (session->poll_abort()) {
+            return TRANSCRIBE_ERR_ABORTED;
+        }
         session->clear_result();
-        const float * slice = host_buf + static_cast<size_t>(b) * utt_elems;
-        const transcribe_status st = decode_fn(b, slice);
-        auto rs = session->capture_result(st);
-        rs.t_mel_us    = mel_per_utt;
-        rs.t_encode_us = enc_per_utt;
+        const float *           slice = host_buf + static_cast<size_t>(b) * utt_elems;
+        const transcribe_status st    = decode_fn(b, slice);
+        auto                    rs    = session->capture_result(st);
+        rs.t_mel_us                   = mel_per_utt;
+        rs.t_encode_us                = enc_per_utt;
         session->batch_results.push_back(std::move(rs));
     }
     return TRANSCRIBE_OK;
 }
 
-transcribe_status run_batched_encdec_step_loop(
-    transcribe_session *                session,
-    ggml_backend_sched_t                sched,
-    const EncDecRebuildFn &             rebuild,
-    const std::vector<int32_t> &        prompt_ids,
-    int                                 prompt_len,
-    int                                 init_window,
-    int                                 max_new,
-    int                                 max_n_kv,
-    int32_t                             eos_id,
-    int                                 n_batch,
-    const std::vector<char> &           valid,
-    std::vector<std::vector<int32_t>> & generated,
-    int *                               n_steps_out,
-    std::vector<char> *                 truncated_out)
-{
+transcribe_status run_batched_encdec_step_loop(transcribe_session *                session,
+                                               ggml_backend_sched_t                sched,
+                                               const EncDecRebuildFn &             rebuild,
+                                               const std::vector<int32_t> &        prompt_ids,
+                                               int                                 prompt_len,
+                                               int                                 init_window,
+                                               int                                 max_new,
+                                               int                                 max_n_kv,
+                                               int32_t                             eos_id,
+                                               int                                 n_batch,
+                                               const std::vector<char> &           valid,
+                                               std::vector<std::vector<int32_t>> & generated,
+                                               int *                               n_steps_out,
+                                               std::vector<char> *                 truncated_out) {
     const int         n        = n_batch;
     const ggml_fp16_t f16_zero = ggml_fp32_to_fp16(0.0f);
     const ggml_fp16_t f16_ninf = ggml_fp32_to_fp16(-std::numeric_limits<float>::infinity());
 
     int          kv_window = init_window;
-    EncDecStepIO io {};
-    if (!rebuild(kv_window, io)) return TRANSCRIBE_ERR_GGUF;
+    EncDecStepIO io{};
+    if (!rebuild(kv_window, io)) {
+        return TRANSCRIBE_ERR_GGUF;
+    }
 
     std::vector<ggml_fp16_t> smask(static_cast<size_t>(kv_window) * n, f16_ninf);
-    std::vector<int32_t> tok_buf(n, 0), pos_buf(n, 0), argmax_buf(n, 0);
-    std::vector<int64_t> kvidx_buf(n, 0);
-    std::vector<char>    finished(n, 0);
-    std::vector<int32_t> next_tok(n, 0);
-    for (int b = 0; b < n; ++b) if (!valid[b]) finished[b] = 1;
+    std::vector<int32_t>     tok_buf(n, 0), pos_buf(n, 0), argmax_buf(n, 0);
+    std::vector<int64_t>     kvidx_buf(n, 0);
+    std::vector<char>        finished(n, 0);
+    std::vector<int32_t>     next_tok(n, 0);
+    for (int b = 0; b < n; ++b) {
+        if (!valid[b]) {
+            finished[b] = 1;
+        }
+    }
 
-    int n_steps = 0;
+    int  n_steps  = 0;
     auto run_step = [&](int posv) -> transcribe_status {
         for (int b = 0; b < n; ++b) {
-            pos_buf[b] = posv; kvidx_buf[b] = posv;
+            pos_buf[b]                                       = posv;
+            kvidx_buf[b]                                     = posv;
             smask[static_cast<size_t>(b) * kv_window + posv] = f16_zero;
         }
         ggml_backend_tensor_set(io.token_ids, tok_buf.data(), 0, n * sizeof(int32_t));
-        ggml_backend_tensor_set(io.pos_ids,   pos_buf.data(), 0, n * sizeof(int32_t));
-        ggml_backend_tensor_set(io.kv_idx,    kvidx_buf.data(), 0, n * sizeof(int64_t));
-        ggml_backend_tensor_set(io.self_mask, smask.data(), 0,
-                                smask.size() * sizeof(ggml_fp16_t));
-        if (ggml_backend_sched_graph_compute(sched, io.graph) != GGML_STATUS_SUCCESS)
+        ggml_backend_tensor_set(io.pos_ids, pos_buf.data(), 0, n * sizeof(int32_t));
+        ggml_backend_tensor_set(io.kv_idx, kvidx_buf.data(), 0, n * sizeof(int64_t));
+        ggml_backend_tensor_set(io.self_mask, smask.data(), 0, smask.size() * sizeof(ggml_fp16_t));
+        if (ggml_backend_sched_graph_compute(sched, io.graph) != GGML_STATUS_SUCCESS) {
             return TRANSCRIBE_ERR_GGUF;
+        }
         ggml_backend_tensor_get(io.argmax, argmax_buf.data(), 0, n * sizeof(int32_t));
         ++n_steps;
         return TRANSCRIBE_OK;
@@ -234,15 +250,24 @@ transcribe_status run_batched_encdec_step_loop(
 
     // Grow the read window (rebuild graph + widen mask) so position `posv` fits.
     auto ensure_window = [&](int posv) -> bool {
-        if (posv + 1 <= kv_window) return true;
+        if (posv + 1 <= kv_window) {
+            return true;
+        }
         int win = kv_window;
-        while (win < posv + 1 && win < max_n_kv) win *= 2;
-        if (win > max_n_kv) win = max_n_kv;
-        if (win == kv_window) return true;
+        while (win < posv + 1 && win < max_n_kv) {
+            win *= 2;
+        }
+        if (win > max_n_kv) {
+            win = max_n_kv;
+        }
+        if (win == kv_window) {
+            return true;
+        }
         std::vector<ggml_fp16_t> wider(static_cast<size_t>(win) * n, f16_ninf);
-        for (int b = 0; b < n; ++b)
-            std::fill(wider.data() + static_cast<size_t>(b) * win,
-                      wider.data() + static_cast<size_t>(b) * win + posv, f16_zero);
+        for (int b = 0; b < n; ++b) {
+            std::fill(wider.data() + static_cast<size_t>(b) * win, wider.data() + static_cast<size_t>(b) * win + posv,
+                      f16_zero);
+        }
         smask.swap(wider);
         kv_window = win;
         return rebuild(kv_window, io);
@@ -251,47 +276,78 @@ transcribe_status run_batched_encdec_step_loop(
     // Prompt feed: prompt_len sequential steps (uniform tokens across rows).
     int pos = 0;
     for (; pos < prompt_len; ++pos) {
-        if (session->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
+        if (session->poll_abort()) {
+            return TRANSCRIBE_ERR_ABORTED;
+        }
         if (!ensure_window(pos)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "batched decode: step graph allocation failed — out of memory. "
-                "Lower transcribe_session_params.n_ctx or the batch size.");
+                                "batched decode: step graph allocation failed — out of memory. "
+                                "Lower transcribe_session_params.n_ctx or the batch size.");
             return TRANSCRIBE_ERR_OOM;
         }
-        for (int b = 0; b < n; ++b) tok_buf[b] = prompt_ids[static_cast<size_t>(pos)];
-        if (run_step(pos) != TRANSCRIBE_OK) return TRANSCRIBE_ERR_GGUF;
+        for (int b = 0; b < n; ++b) {
+            tok_buf[b] = prompt_ids[static_cast<size_t>(pos)];
+        }
+        if (run_step(pos) != TRANSCRIBE_OK) {
+            return TRANSCRIBE_ERR_GGUF;
+        }
     }
     // argmax from the last prompt position = first generated token.
     for (int b = 0; b < n; ++b) {
-        if (finished[b]) continue;
+        if (finished[b]) {
+            continue;
+        }
         next_tok[b] = argmax_buf[b];
-        if (next_tok[b] == eos_id) finished[b] = 1;
-        else generated[b].push_back(next_tok[b]);
+        if (next_tok[b] == eos_id) {
+            finished[b] = 1;
+        } else {
+            generated[b].push_back(next_tok[b]);
+        }
     }
 
     // Generation.
     for (int produced = 1; produced < max_new; ++produced, ++pos) {
-        if (session->poll_abort()) return TRANSCRIBE_ERR_ABORTED;
+        if (session->poll_abort()) {
+            return TRANSCRIBE_ERR_ABORTED;
+        }
         bool all_done = true;
-        for (int b = 0; b < n; ++b) if (!finished[b]) { all_done = false; break; }
-        if (all_done || pos + 1 > max_n_kv) break;
+        for (int b = 0; b < n; ++b) {
+            if (!finished[b]) {
+                all_done = false;
+                break;
+            }
+        }
+        if (all_done || pos + 1 > max_n_kv) {
+            break;
+        }
         if (!ensure_window(pos)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "batched decode: step graph allocation failed — out of memory. "
-                "Lower transcribe_session_params.n_ctx or the batch size.");
+                                "batched decode: step graph allocation failed — out of memory. "
+                                "Lower transcribe_session_params.n_ctx or the batch size.");
             return TRANSCRIBE_ERR_OOM;
         }
-        for (int b = 0; b < n; ++b) tok_buf[b] = finished[b] ? eos_id : next_tok[b];
-        if (run_step(pos) != TRANSCRIBE_OK) return TRANSCRIBE_ERR_GGUF;
         for (int b = 0; b < n; ++b) {
-            if (finished[b]) continue;
+            tok_buf[b] = finished[b] ? eos_id : next_tok[b];
+        }
+        if (run_step(pos) != TRANSCRIBE_OK) {
+            return TRANSCRIBE_ERR_GGUF;
+        }
+        for (int b = 0; b < n; ++b) {
+            if (finished[b]) {
+                continue;
+            }
             next_tok[b] = argmax_buf[b];
-            if (next_tok[b] == eos_id) finished[b] = 1;
-            else generated[b].push_back(next_tok[b]);
+            if (next_tok[b] == eos_id) {
+                finished[b] = 1;
+            } else {
+                generated[b].push_back(next_tok[b]);
+            }
         }
     }
 
-    if (n_steps_out != nullptr) *n_steps_out = n_steps;
+    if (n_steps_out != nullptr) {
+        *n_steps_out = n_steps;
+    }
 
     // A valid row that never reached eos was cut off at the generation budget
     // or the context window — report it as truncated so the family can return
@@ -305,4 +361,4 @@ transcribe_status run_batched_encdec_step_loop(
     return TRANSCRIBE_OK;
 }
 
-} // namespace transcribe
+}  // namespace transcribe
diff --git a/src/transcribe-batch-util.h b/src/transcribe-batch-util.h
index c9b84a96..c5379965 100644
--- a/src/transcribe-batch-util.h
+++ b/src/transcribe-batch-util.h
@@ -30,8 +30,7 @@ namespace transcribe {
 // Returns true iff every invocation returned true; a false return does not
 // stop the other indices (the caller handles partial failure — typically by
 // falling back to the per-utterance path).
-bool parallel_for_all(int n, int n_threads,
-                      const std::function<bool(int)> & work);
+bool parallel_for_all(int n, int n_threads, const std::function<bool(int)> & work);
 
 // Default CPU thread count for the ggml backends and the host parallel-for
 // when the caller passes n_threads <= 0. Counts the CPUs the process may
@@ -70,30 +69,23 @@ int configure_sched_n_threads(ggml_backend_sched_t sched, int requested);
 // src[c*lens[b] + t]); `dst` is sized n_ch * T_max * n with slab b laid out as
 // [T_max, n_ch] (element (t,c) at (b*n_ch + c)*T_max + t), matching the
 // conformer mel_in tensor ne = [T_max, n_ch, 1, B]. Padded tail left zero.
-void pack_pad_channel_major(
-    std::vector<float> &                    dst,
-    const std::vector<std::vector<float>> & src,
-    const std::vector<int> &                lens,
-    int                                     n_ch,
-    int                                     T_max);
+void pack_pad_channel_major(std::vector<float> &                    dst,
+                            const std::vector<std::vector<float>> & src,
+                            const std::vector<int> &                lens,
+                            int                                     n_ch,
+                            int                                     T_max);
 
 // Fill an attention key-padding mask (f32) of logical shape [T, .., n] with the
 // host ordering index b*T + k: 0.0 on real keys (k < real_lens[b]), -inf on
 // padded keys. No-op when `mask` is null. The element order is identical for
 // the conformer [T,1,1,n] and SAN-M [T,1,1,n] key-padding tensors.
-void fill_keypad_mask(ggml_tensor *            mask,
-                      const std::vector<int> & real_lens,
-                      int                      T,
-                      int                      n);
+void fill_keypad_mask(ggml_tensor * mask, const std::vector<int> & real_lens, int T, int n);
 
 // Fill a conv valid-frame mask (f32) with host ordering index b*T + t: 1.0 on
 // real frames (t < real_lens[b]), 0.0 on padded. No-op when `mask` is null.
 // The b*T + t order matches both the conformer [T,1,n,1] and SAN-M [1,T,n]
 // valid-frame tensors.
-void fill_valid_frame_mask(ggml_tensor *            mask,
-                           const std::vector<int> & real_lens,
-                           int                      T,
-                           int                      n);
+void fill_valid_frame_mask(ggml_tensor * mask, const std::vector<int> & real_lens, int T, int n);
 
 // Per-utterance decode loop for the batched-encoder fast path. For each
 // utterance b in [0, n): polls abort, resets the scratch result slot, then
@@ -102,14 +94,13 @@ void fill_valid_frame_mask(ggml_tensor *            mask,
 // amortization of the shared encode + total mel cost (so per-utt timings sum to
 // the real batch wall cost); decode_fn's return is the utterance's status.
 // Returns TRANSCRIBE_ERR_ABORTED if abort fires between utterances, else OK.
-transcribe_status decode_batch_slices(
-    transcribe_session *  session,
-    int                   n,
-    const float *         host_buf,
-    std::size_t           utt_elems,
-    int64_t               total_encode_us,
-    int64_t               total_mel_us,
-    const std::function<transcribe_status(int b, const float * slice)> & decode_fn);
+transcribe_status decode_batch_slices(transcribe_session * session,
+                                      int                  n,
+                                      const float *        host_buf,
+                                      std::size_t          utt_elems,
+                                      int64_t              total_encode_us,
+                                      int64_t              total_mel_us,
+                                      const std::function<transcribe_status(int b, const float * slice)> & decode_fn);
 
 // ---------------------------------------------------------------------------
 // Batched encoder-decoder greedy step loop (cohere / canary / moonshine)
@@ -154,20 +145,19 @@ using EncDecRebuildFn = std::function<bool(int win, EncDecStepIO & io)>;
 // (valid) row hit the generation budget (max_new) or the context window
 // (max_n_kv) BEFORE emitting eos_id (transcript truncated), else 0. Lets a
 // family report per-utterance TRANSCRIBE_ERR_OUTPUT_TRUNCATED from run_batch.
-transcribe_status run_batched_encdec_step_loop(
-    transcribe_session *                session,
-    ggml_backend_sched_t                sched,
-    const EncDecRebuildFn &             rebuild,
-    const std::vector<int32_t> &        prompt_ids,
-    int                                 prompt_len,
-    int                                 init_window,
-    int                                 max_new,
-    int                                 max_n_kv,
-    int32_t                             eos_id,
-    int                                 n_batch,
-    const std::vector<char> &           valid,
-    std::vector<std::vector<int32_t>> & generated,
-    int *                               n_steps_out = nullptr,
-    std::vector<char> *                 truncated_out = nullptr);
-
-} // namespace transcribe
+transcribe_status run_batched_encdec_step_loop(transcribe_session *                session,
+                                               ggml_backend_sched_t                sched,
+                                               const EncDecRebuildFn &             rebuild,
+                                               const std::vector<int32_t> &        prompt_ids,
+                                               int                                 prompt_len,
+                                               int                                 init_window,
+                                               int                                 max_new,
+                                               int                                 max_n_kv,
+                                               int32_t                             eos_id,
+                                               int                                 n_batch,
+                                               const std::vector<char> &           valid,
+                                               std::vector<std::vector<int32_t>> & generated,
+                                               int *                               n_steps_out   = nullptr,
+                                               std::vector<char> *                 truncated_out = nullptr);
+
+}  // namespace transcribe
diff --git a/src/transcribe-bin-loader.cpp b/src/transcribe-bin-loader.cpp
index 5375175b..e2a40b42 100644
--- a/src/transcribe-bin-loader.cpp
+++ b/src/transcribe-bin-loader.cpp
@@ -1,10 +1,10 @@
 // transcribe-bin-loader.cpp - whisper.cpp `.bin` parser implementation.
 
 #include "transcribe-bin-loader.h"
-#include "transcribe-log.h"
 
-#include "ggml.h"
 #include "ggml-backend.h"
+#include "ggml.h"
+#include "transcribe-log.h"
 
 #include <sys/stat.h>
 
@@ -25,7 +25,7 @@ constexpr const char * kTag = "whisper-bin";
 // means we couldn't reach the path and the open below should surface
 // the underlying error.
 bool path_is_present(const char * path) {
-    struct stat st {};
+    struct stat st{};
     if (::stat(path, &st) == 0) {
         return true;
     }
@@ -37,8 +37,7 @@ bool path_is_present(const char * path) {
 
 // Read sizeof(T) bytes into `out`. Returns false on short read or
 // stream failure.
-template <typename T>
-bool read_pod(std::ifstream & fin, T & out) {
+template <typename T> bool read_pod(std::ifstream & fin, T & out) {
     fin.read(reinterpret_cast<char *>(&out), sizeof(T));
     return static_cast<bool>(fin);
 }
@@ -75,14 +74,15 @@ bool is_known_ggml_type(int32_t ttype) {
 // block-quant accounting. Mirrors ggml_nbytes for a freshly created
 // tensor: bytes = (n_elements / blck_size) * type_size.
 uint64_t tensor_nbytes(ggml_type type, const int64_t ne[4]) {
-    const int64_t n_elem =
-        ne[0] * (ne[1] > 0 ? ne[1] : 1) *
-        (ne[2] > 0 ? ne[2] : 1) * (ne[3] > 0 ? ne[3] : 1);
-    const int64_t blck = ggml_blck_size(type);
-    if (blck <= 0) return 0;
-    if (n_elem % blck != 0) return 0;
-    return static_cast<uint64_t>(n_elem / blck) *
-           static_cast<uint64_t>(ggml_type_size(type));
+    const int64_t n_elem = ne[0] * (ne[1] > 0 ? ne[1] : 1) * (ne[2] > 0 ? ne[2] : 1) * (ne[3] > 0 ? ne[3] : 1);
+    const int64_t blck   = ggml_blck_size(type);
+    if (blck <= 0) {
+        return 0;
+    }
+    if (n_elem % blck != 0) {
+        return 0;
+    }
+    return static_cast<uint64_t>(n_elem / blck) * static_cast<uint64_t>(ggml_type_size(type));
 }
 
 // Whisper-shape gate. The `ggml` magic byte is shared with non-
@@ -102,30 +102,50 @@ bool hparams_look_whisper(const WhisperBinHParams & hp) {
     auto layer_ok = [](int32_t l) {
         return l > 0 && l <= 64;
     };
-    if (!layer_ok(hp.n_audio_layer)) return false;
-    if (!layer_ok(hp.n_text_layer))  return false;
-    if (hp.n_mels != 80 && hp.n_mels != 128) return false;
+    if (!layer_ok(hp.n_audio_layer)) {
+        return false;
+    }
+    if (!layer_ok(hp.n_text_layer)) {
+        return false;
+    }
+    if (hp.n_mels != 80 && hp.n_mels != 128) {
+        return false;
+    }
     if (hp.n_vocab != 51864 && hp.n_vocab != 51865 && hp.n_vocab != 51866) {
         return false;
     }
-    if (hp.n_audio_state <= 0 || hp.n_audio_head <= 0) return false;
-    if (hp.n_audio_state % hp.n_audio_head != 0) return false;
-    if (hp.n_text_state <= 0 || hp.n_text_head <= 0)  return false;
-    if (hp.n_text_state % hp.n_text_head != 0) return false;
+    if (hp.n_audio_state <= 0 || hp.n_audio_head <= 0) {
+        return false;
+    }
+    if (hp.n_audio_state % hp.n_audio_head != 0) {
+        return false;
+    }
+    if (hp.n_text_state <= 0 || hp.n_text_head <= 0) {
+        return false;
+    }
+    if (hp.n_text_state % hp.n_text_head != 0) {
+        return false;
+    }
     // n_audio_ctx and n_text_ctx are 1500 / 448 across all shipped
     // variants; permit anything plausible to keep the gate from
     // rejecting a hypothetical fine-tune with a different n_text_ctx.
-    if (hp.n_audio_ctx <= 0 || hp.n_audio_ctx > 4096) return false;
-    if (hp.n_text_ctx  <= 0 || hp.n_text_ctx  > 4096) return false;
+    if (hp.n_audio_ctx <= 0 || hp.n_audio_ctx > 4096) {
+        return false;
+    }
+    if (hp.n_text_ctx <= 0 || hp.n_text_ctx > 4096) {
+        return false;
+    }
 
     const int32_t qntvr = hp.ftype / 1000;
     const int32_t base  = hp.ftype % 1000;
-    (void)qntvr;
-    if (base < 0 || base > 30) return false;
+    (void) qntvr;
+    if (base < 0 || base > 30) {
+        return false;
+    }
     return true;
 }
 
-} // namespace
+}  // namespace
 
 transcribe_status parse_whisper_bin(const char * path, WhisperBinModel & out) {
     out = WhisperBinModel{};
@@ -140,8 +160,7 @@ transcribe_status parse_whisper_bin(const char * path, WhisperBinModel & out) {
 
     std::ifstream fin(path, std::ios::binary);
     if (!fin) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "%s: failed to open %s", kTag, path);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: failed to open %s", kTag, path);
         return TRANSCRIBE_ERR_GGUF;
     }
 
@@ -156,26 +175,18 @@ transcribe_status parse_whisper_bin(const char * path, WhisperBinModel & out) {
         // routing GGUF magic to the GGUF loader before reaching here.
         // Anything else with non-`ggml` magic is just unsupported.
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "%s: bad magic 0x%08x (expected 0x%08x for legacy "
-                     "whisper.cpp .bin)",
-                     kTag, magic, k_whisper_bin_magic);
+                "%s: bad magic 0x%08x (expected 0x%08x for legacy "
+                "whisper.cpp .bin)",
+                kTag, magic, k_whisper_bin_magic);
         return TRANSCRIBE_ERR_GGUF;
     }
 
     // ---- hparams (11 × int32) ----
     auto & hp = out.hp;
-    if (!read_pod(fin, hp.n_vocab)        ||
-        !read_pod(fin, hp.n_audio_ctx)    ||
-        !read_pod(fin, hp.n_audio_state)  ||
-        !read_pod(fin, hp.n_audio_head)   ||
-        !read_pod(fin, hp.n_audio_layer)  ||
-        !read_pod(fin, hp.n_text_ctx)     ||
-        !read_pod(fin, hp.n_text_state)   ||
-        !read_pod(fin, hp.n_text_head)    ||
-        !read_pod(fin, hp.n_text_layer)   ||
-        !read_pod(fin, hp.n_mels)         ||
-        !read_pod(fin, hp.ftype))
-    {
+    if (!read_pod(fin, hp.n_vocab) || !read_pod(fin, hp.n_audio_ctx) || !read_pod(fin, hp.n_audio_state) ||
+        !read_pod(fin, hp.n_audio_head) || !read_pod(fin, hp.n_audio_layer) || !read_pod(fin, hp.n_text_ctx) ||
+        !read_pod(fin, hp.n_text_state) || !read_pod(fin, hp.n_text_head) || !read_pod(fin, hp.n_text_layer) ||
+        !read_pod(fin, hp.n_mels) || !read_pod(fin, hp.ftype)) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: short read on hparams", kTag);
         return TRANSCRIBE_ERR_GGUF;
     }
@@ -185,11 +196,10 @@ transcribe_status parse_whisper_bin(const char * path, WhisperBinModel & out) {
         // Silero VAD `.bin` or some other ggml artifact — reject
         // cleanly so the caller surfaces UNSUPPORTED_ARCH.
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "%s: hparams do not match a known Whisper geometry "
-                     "(n_audio_layer=%d n_text_layer=%d n_mels=%d "
-                     "n_vocab=%d) — refusing to load as Whisper",
-                     kTag, hp.n_audio_layer, hp.n_text_layer,
-                     hp.n_mels, hp.n_vocab);
+                "%s: hparams do not match a known Whisper geometry "
+                "(n_audio_layer=%d n_text_layer=%d n_mels=%d "
+                "n_vocab=%d) — refusing to load as Whisper",
+                kTag, hp.n_audio_layer, hp.n_text_layer, hp.n_mels, hp.n_vocab);
         return TRANSCRIBE_ERR_UNSUPPORTED_ARCH;
     }
 
@@ -199,23 +209,20 @@ transcribe_status parse_whisper_bin(const char * path, WhisperBinModel & out) {
     out.num_languages   = hp.n_vocab - 51765 - (out.is_multilingual ? 1 : 0);
 
     // ---- mel filters ----
-    if (!read_pod(fin, out.n_mel_filters) ||
-        !read_pod(fin, out.n_fft_filters))
-    {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "%s: short read on mel filter dims", kTag);
+    if (!read_pod(fin, out.n_mel_filters) || !read_pod(fin, out.n_fft_filters)) {
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: short read on mel filter dims", kTag);
         return TRANSCRIBE_ERR_GGUF;
     }
     if (out.n_mel_filters != hp.n_mels) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "%s: mel filter n_mel=%d disagrees with hparams "
-                     "n_mels=%d", kTag, out.n_mel_filters, hp.n_mels);
+                "%s: mel filter n_mel=%d disagrees with hparams "
+                "n_mels=%d",
+                kTag, out.n_mel_filters, hp.n_mels);
         return TRANSCRIBE_ERR_GGUF;
     }
     if (out.n_fft_filters <= 0 || out.n_mel_filters <= 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "%s: invalid mel filter dims n_mel=%d n_fft=%d",
-                     kTag, out.n_mel_filters, out.n_fft_filters);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: invalid mel filter dims n_mel=%d n_fft=%d", kTag, out.n_mel_filters,
+                out.n_fft_filters);
         return TRANSCRIBE_ERR_GGUF;
     }
     // Whisper's frontend is fixed: n_fft=400 → n_fft/2+1=201 frequency
@@ -225,21 +232,18 @@ transcribe_status parse_whisper_bin(const char * path, WhisperBinModel & out) {
     // later (partial write at best, OOB at worst).
     if (out.n_fft_filters != 201) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "%s: mel filter n_fft=%d is not 201 (whisper "
-                     "canonical n_fft=400 → n_fft/2+1=201); refusing "
-                     "to load", kTag, out.n_fft_filters);
+                "%s: mel filter n_fft=%d is not 201 (whisper "
+                "canonical n_fft=400 → n_fft/2+1=201); refusing "
+                "to load",
+                kTag, out.n_fft_filters);
         return TRANSCRIBE_ERR_GGUF;
     }
-    const size_t fb_elems =
-        static_cast<size_t>(out.n_mel_filters) *
-        static_cast<size_t>(out.n_fft_filters);
+    const size_t fb_elems = static_cast<size_t>(out.n_mel_filters) * static_cast<size_t>(out.n_fft_filters);
     out.mel_filterbank.resize(fb_elems);
     fin.read(reinterpret_cast<char *>(out.mel_filterbank.data()),
              static_cast<std::streamsize>(fb_elems * sizeof(float)));
     if (!fin) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "%s: short read on mel filterbank (%zu floats)",
-                     kTag, fb_elems);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: short read on mel filterbank (%zu floats)", kTag, fb_elems);
         return TRANSCRIBE_ERR_GGUF;
     }
 
@@ -253,9 +257,8 @@ transcribe_status parse_whisper_bin(const char * path, WhisperBinModel & out) {
         // The file's vocab count may legitimately be smaller than
         // hparams.n_vocab (whisper.cpp synthesizes the missing tokens
         // at load), but it should never overshoot by much.
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "%s: implausible vocab count %d (hparams n_vocab=%d)",
-                     kTag, n_vocab_in_file, hp.n_vocab);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: implausible vocab count %d (hparams n_vocab=%d)", kTag,
+                n_vocab_in_file, hp.n_vocab);
         return TRANSCRIBE_ERR_GGUF;
     }
     out.vocab_tokens.reserve(static_cast<size_t>(n_vocab_in_file));
@@ -263,25 +266,19 @@ transcribe_status parse_whisper_bin(const char * path, WhisperBinModel & out) {
     for (int32_t i = 0; i < n_vocab_in_file; ++i) {
         uint32_t len = 0;
         if (!read_pod(fin, len)) {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "%s: short read on vocab token %d length",
-                         kTag, i);
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: short read on vocab token %d length", kTag, i);
             return TRANSCRIBE_ERR_GGUF;
         }
         if (len > 1024) {
             // No legitimate Whisper token is anywhere near this long.
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "%s: vocab token %d claims absurd length %u",
-                         kTag, i, len);
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: vocab token %d claims absurd length %u", kTag, i, len);
             return TRANSCRIBE_ERR_GGUF;
         }
         scratch.assign(static_cast<size_t>(len), '\0');
         if (len > 0) {
             fin.read(scratch.data(), static_cast<std::streamsize>(len));
             if (!fin) {
-                log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                             "%s: short read on vocab token %d body",
-                             kTag, i);
+                log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: short read on vocab token %d body", kTag, i);
                 return TRANSCRIBE_ERR_GGUF;
             }
         }
@@ -302,35 +299,28 @@ transcribe_status parse_whisper_bin(const char * path, WhisperBinModel & out) {
             break;
         }
         if (!fin || fin.gcount() != sizeof(n_dims)) {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "%s: truncated tensor header (after %zu tensors)",
-                         kTag, out.tensors.size());
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: truncated tensor header (after %zu tensors)", kTag,
+                    out.tensors.size());
             return TRANSCRIBE_ERR_GGUF;
         }
 
         int32_t name_len = 0;
         int32_t ttype    = 0;
         if (!read_pod(fin, name_len) || !read_pod(fin, ttype)) {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "%s: truncated tensor header (after %zu tensors)",
-                         kTag, out.tensors.size());
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: truncated tensor header (after %zu tensors)", kTag,
+                    out.tensors.size());
             return TRANSCRIBE_ERR_GGUF;
         }
         if (n_dims < 1 || n_dims > 4) {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "%s: tensor n_dims=%d out of range",
-                         kTag, n_dims);
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: tensor n_dims=%d out of range", kTag, n_dims);
             return TRANSCRIBE_ERR_GGUF;
         }
         if (name_len <= 0 || name_len > 256) {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "%s: tensor name_len=%d out of range",
-                         kTag, name_len);
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: tensor name_len=%d out of range", kTag, name_len);
             return TRANSCRIBE_ERR_GGUF;
         }
         if (!is_known_ggml_type(ttype)) {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "%s: unknown ttype %d", kTag, ttype);
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: unknown ttype %d", kTag, ttype);
             return TRANSCRIBE_ERR_GGUF;
         }
 
@@ -340,21 +330,20 @@ transcribe_status parse_whisper_bin(const char * path, WhisperBinModel & out) {
         // (fastest); the bytes that follow are still C-order, and
         // whisper.cpp's loader reads dims into ne[i] without any
         // reversal (whisper.cpp:1884-1887). We do the same.
-        BinTensorEntry entry {};
+        BinTensorEntry entry{};
         entry.type   = static_cast<ggml_type>(ttype);
         entry.n_dims = n_dims;
-        for (int32_t i = 0; i < 4; ++i) entry.ne[i] = 1;
+        for (int32_t i = 0; i < 4; ++i) {
+            entry.ne[i] = 1;
+        }
         for (int32_t i = 0; i < n_dims; ++i) {
             int32_t v = 0;
             if (!read_pod(fin, v)) {
-                log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                             "%s: truncated tensor dims", kTag);
+                log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: truncated tensor dims", kTag);
                 return TRANSCRIBE_ERR_GGUF;
             }
             if (v <= 0) {
-                log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                             "%s: tensor dim ne[%d]=%d non-positive",
-                             kTag, i, v);
+                log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: tensor dim ne[%d]=%d non-positive", kTag, i, v);
                 return TRANSCRIBE_ERR_GGUF;
             }
             entry.ne[i] = v;
@@ -363,8 +352,7 @@ transcribe_status parse_whisper_bin(const char * path, WhisperBinModel & out) {
         std::string name(static_cast<size_t>(name_len), '\0');
         fin.read(name.data(), name_len);
         if (!fin) {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "%s: truncated tensor name", kTag);
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: truncated tensor name", kTag);
             return TRANSCRIBE_ERR_GGUF;
         }
         entry.name = std::move(name);
@@ -374,27 +362,22 @@ transcribe_status parse_whisper_bin(const char * path, WhisperBinModel & out) {
         entry.nbytes = tensor_nbytes(entry.type, entry.ne);
         if (entry.nbytes == 0) {
             log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "%s: tensor \"%s\" has 0 nbytes (type=%s, "
-                         "ne=[%lld,%lld,%lld,%lld] not a multiple of "
-                         "block size)",
-                         kTag, entry.name.c_str(),
-                         ggml_type_name(entry.type),
-                         (long long)entry.ne[0], (long long)entry.ne[1],
-                         (long long)entry.ne[2], (long long)entry.ne[3]);
+                    "%s: tensor \"%s\" has 0 nbytes (type=%s, "
+                    "ne=[%lld,%lld,%lld,%lld] not a multiple of "
+                    "block size)",
+                    kTag, entry.name.c_str(), ggml_type_name(entry.type), (long long) entry.ne[0],
+                    (long long) entry.ne[1], (long long) entry.ne[2], (long long) entry.ne[3]);
             return TRANSCRIBE_ERR_GGUF;
         }
         entry.offset = static_cast<uint64_t>(fin.tellg());
 
         // Skip the payload to land on the next tensor header.
-        fin.seekg(static_cast<std::streamoff>(entry.nbytes),
-                  std::ios::cur);
+        fin.seekg(static_cast<std::streamoff>(entry.nbytes), std::ios::cur);
         if (!fin) {
             log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "%s: tensor \"%s\" payload runs past end of file "
-                         "(offset=%llu nbytes=%llu) — file is truncated",
-                         kTag, entry.name.c_str(),
-                         (unsigned long long)entry.offset,
-                         (unsigned long long)entry.nbytes);
+                    "%s: tensor \"%s\" payload runs past end of file "
+                    "(offset=%llu nbytes=%llu) — file is truncated",
+                    kTag, entry.name.c_str(), (unsigned long long) entry.offset, (unsigned long long) entry.nbytes);
             return TRANSCRIBE_ERR_GGUF;
         }
 
@@ -409,16 +392,12 @@ transcribe_status parse_whisper_bin(const char * path, WhisperBinModel & out) {
     return TRANSCRIBE_OK;
 }
 
-transcribe_status stream_tensor_data_from_bin(
-    const std::string &                 path,
-    const std::vector<BinStreamSlot> &  slots,
-    const char *                        error_tag)
-{
+transcribe_status stream_tensor_data_from_bin(const std::string &                path,
+                                              const std::vector<BinStreamSlot> & slots,
+                                              const char *                       error_tag) {
     std::ifstream fin(path, std::ios::binary);
     if (!fin) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "%s: failed to reopen %s for tensor data",
-                     error_tag, path.c_str());
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: failed to reopen %s for tensor data", error_tag, path.c_str());
         return TRANSCRIBE_ERR_GGUF;
     }
 
@@ -428,18 +407,15 @@ transcribe_status stream_tensor_data_from_bin(
 
     for (const BinStreamSlot & s : slots) {
         if (s.dst == nullptr) {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "%s: stream slot has null dst tensor",
-                         error_tag);
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: stream slot has null dst tensor", error_tag);
             return TRANSCRIBE_ERR_GGUF;
         }
         const size_t want = ggml_nbytes(s.dst);
         if (s.src_bytes != want) {
             log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "%s: tensor \"%s\" byte-size mismatch "
-                         "(.bin says %llu, ggml expects %zu)",
-                         error_tag, s.dst->name,
-                         (unsigned long long)s.src_bytes, want);
+                    "%s: tensor \"%s\" byte-size mismatch "
+                    "(.bin says %llu, ggml expects %zu)",
+                    error_tag, s.dst->name, (unsigned long long) s.src_bytes, want);
             return TRANSCRIBE_ERR_GGUF;
         }
         if (staging.size() < want) {
@@ -447,17 +423,12 @@ transcribe_status stream_tensor_data_from_bin(
         }
         fin.seekg(static_cast<std::streamoff>(s.src_off));
         if (!fin) {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "%s: seek failed for tensor \"%s\"",
-                         error_tag, s.dst->name);
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: seek failed for tensor \"%s\"", error_tag, s.dst->name);
             return TRANSCRIBE_ERR_GGUF;
         }
-        fin.read(reinterpret_cast<char *>(staging.data()),
-                 static_cast<std::streamsize>(want));
+        fin.read(reinterpret_cast<char *>(staging.data()), static_cast<std::streamsize>(want));
         if (!fin || static_cast<size_t>(fin.gcount()) != want) {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "%s: short read for tensor \"%s\"",
-                         error_tag, s.dst->name);
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: short read for tensor \"%s\"", error_tag, s.dst->name);
             return TRANSCRIBE_ERR_GGUF;
         }
         ggml_backend_tensor_set(s.dst, staging.data(), 0, want);
@@ -466,4 +437,4 @@ transcribe_status stream_tensor_data_from_bin(
     return TRANSCRIBE_OK;
 }
 
-} // namespace transcribe::bin_loader
+}  // namespace transcribe::bin_loader
diff --git a/src/transcribe-bin-loader.h b/src/transcribe-bin-loader.h
index acc33add..f566218d 100644
--- a/src/transcribe-bin-loader.h
+++ b/src/transcribe-bin-loader.h
@@ -32,9 +32,8 @@
 
 #pragma once
 
-#include "transcribe.h"
-
 #include "ggml.h"
+#include "transcribe.h"
 
 #include <cstdint>
 #include <string>
@@ -65,28 +64,28 @@ struct WhisperBinHParams {
 // declared type + ne — validated at parse time so the streamer can
 // trust both fields.
 struct BinTensorEntry {
-    std::string name;       // legacy whisper.cpp tensor name
-    ggml_type   type    = GGML_TYPE_F32;
-    int32_t     n_dims  = 0;
-    int64_t     ne[4]   = {1, 1, 1, 1};  // ggml convention (file-reversed)
-    uint64_t    offset  = 0;
-    uint64_t    nbytes  = 0;
+    std::string name;  // legacy whisper.cpp tensor name
+    ggml_type   type   = GGML_TYPE_F32;
+    int32_t     n_dims = 0;
+    int64_t     ne[4]  = { 1, 1, 1, 1 };  // ggml convention (file-reversed)
+    uint64_t    offset = 0;
+    uint64_t    nbytes = 0;
 };
 
 // Whole-file parse result, sans tensor payload bytes.
 struct WhisperBinModel {
-    std::string                  path;
-    WhisperBinHParams            hp;
-    bool                         is_multilingual = false;
-    int32_t                      num_languages   = 0;
+    std::string       path;
+    WhisperBinHParams hp;
+    bool              is_multilingual = false;
+    int32_t           num_languages   = 0;
 
-    int32_t                      n_mel_filters = 0;   // n_mel from the file
-    int32_t                      n_fft_filters = 0;   // n_fft/2+1
-    std::vector<float>           mel_filterbank;      // size n_mel * n_fft
+    int32_t            n_mel_filters = 0;   // n_mel from the file
+    int32_t            n_fft_filters = 0;   // n_fft/2+1
+    std::vector<float> mel_filterbank;      // size n_mel * n_fft
 
-    std::vector<std::string>     vocab_tokens;        // raw byte strings
+    std::vector<std::string> vocab_tokens;  // raw byte strings
 
-    std::vector<BinTensorEntry>  tensors;
+    std::vector<BinTensorEntry> tensors;
 };
 
 // Parse + validate a whisper.cpp legacy `.bin`.
@@ -111,8 +110,7 @@ struct WhisperBinModel {
 // hparams gate (real Whisper geometry, just truncated). They fail at
 // the tensor-payload completeness check inside the manifest pass and
 // surface as ERR_GGUF with a specific "truncated" diagnostic.
-transcribe_status parse_whisper_bin(const char *       path,
-                                    WhisperBinModel &  out);
+transcribe_status parse_whisper_bin(const char * path, WhisperBinModel & out);
 
 // Stream every tensor in `ctx_meta` (which the caller has already built
 // with canonical names + canonical ne + the source's ggml_type, then
@@ -129,9 +127,8 @@ struct BinStreamSlot {
     uint64_t      src_bytes = 0;
 };
 
-transcribe_status stream_tensor_data_from_bin(
-    const std::string &                 path,
-    const std::vector<BinStreamSlot> &  slots,
-    const char *                        error_tag);
+transcribe_status stream_tensor_data_from_bin(const std::string &                path,
+                                              const std::vector<BinStreamSlot> & slots,
+                                              const char *                       error_tag);
 
-} // namespace transcribe::bin_loader
+}  // namespace transcribe::bin_loader
diff --git a/src/transcribe-debug.cpp b/src/transcribe-debug.cpp
index 30f92a3d..8109dc0f 100644
--- a/src/transcribe-debug.cpp
+++ b/src/transcribe-debug.cpp
@@ -8,10 +8,9 @@
 
 #include "transcribe-debug.h"
 
-#include "transcribe-env.h"
-
-#include "ggml.h"
 #include "ggml-backend.h"
+#include "ggml.h"
+#include "transcribe-env.h"
 
 #include <cmath>
 #include <cstdarg>
@@ -42,7 +41,9 @@ std::string g_dump_dir;
 std::vector<std::string> g_name_prefix_stack;
 
 std::string make_prefixed_name(const char * name) {
-    if (g_name_prefix_stack.empty()) return std::string(name);
+    if (g_name_prefix_stack.empty()) {
+        return std::string(name);
+    }
     return g_name_prefix_stack.back() + name;
 }
 
@@ -79,7 +80,7 @@ bool name_is_safe(const char * name) {
 //   ggml ne = [4, 4, 4, 4]    -> shape = [4, 4, 4, 4]
 std::vector<int64_t> row_major_shape(const ggml_tensor * t) {
     std::vector<int64_t> out;
-    int last = GGML_MAX_DIMS - 1;
+    int                  last = GGML_MAX_DIMS - 1;
     while (last > 0 && t->ne[last] == 1) {
         --last;
     }
@@ -109,7 +110,7 @@ void warn(const char * fmt, ...) {
     va_end(ap);
 }
 
-} // namespace
+}  // namespace
 
 bool init() {
     if (g_initialized) {
@@ -124,9 +125,7 @@ bool init() {
     }
     g_dump_dir = env;
     g_enabled  = true;
-    std::fprintf(stderr,
-                 "transcribe-debug: dumping tensors to %s\n",
-                 g_dump_dir.c_str());
+    std::fprintf(stderr, "transcribe-debug: dumping tensors to %s\n", g_dump_dir.c_str());
     return true;
 }
 
@@ -163,13 +162,19 @@ const char * dump_sub_blocks_spec() {
 }
 
 void push_name_prefix(const char * prefix) {
-    if (!enabled() || prefix == nullptr) return;
+    if (!enabled() || prefix == nullptr) {
+        return;
+    }
     g_name_prefix_stack.emplace_back(prefix);
 }
 
 void pop_name_prefix() {
-    if (!enabled()) return;
-    if (!g_name_prefix_stack.empty()) g_name_prefix_stack.pop_back();
+    if (!enabled()) {
+        return;
+    }
+    if (!g_name_prefix_stack.empty()) {
+        g_name_prefix_stack.pop_back();
+    }
 }
 
 void mark_tensor_for_dump(ggml_tensor * tensor) {
@@ -178,10 +183,7 @@ void mark_tensor_for_dump(ggml_tensor * tensor) {
     }
 }
 
-void dump_tensor(const char *        name,
-                 const ggml_tensor * tensor,
-                 const char *        stage)
-{
+void dump_tensor(const char * name, const ggml_tensor * tensor, const char * stage) {
     if (!enabled()) {
         return;
     }
@@ -190,13 +192,11 @@ void dump_tensor(const char *        name,
         return;
     }
     if (!name_is_safe(name)) {
-        warn("dump_tensor: rejecting unsafe name \"%s\"",
-             name ? name : "(null)");
+        warn("dump_tensor: rejecting unsafe name \"%s\"", name ? name : "(null)");
         return;
     }
     if (tensor->type != GGML_TYPE_F32) {
-        warn("dump_tensor(\"%s\"): only fp32 supported, got %s",
-             name, ggml_type_name(tensor->type));
+        warn("dump_tensor(\"%s\"): only fp32 supported, got %s", name, ggml_type_name(tensor->type));
         return;
     }
 
@@ -213,8 +213,7 @@ void dump_tensor(const char *        name,
         return;
     }
     if (nbytes % sizeof(float) != 0) {
-        warn("dump_tensor(\"%s\"): nbytes (%zu) not a multiple of sizeof(float)",
-             name, nbytes);
+        warn("dump_tensor(\"%s\"): nbytes (%zu) not a multiple of sizeof(float)", name, nbytes);
         return;
     }
 
@@ -225,8 +224,7 @@ void dump_tensor(const char *        name,
     try {
         host.resize(nbytes);
     } catch (const std::bad_alloc &) {
-        warn("dump_tensor(\"%s\"): malloc failed for %zu bytes",
-             name, nbytes);
+        warn("dump_tensor(\"%s\"): malloc failed for %zu bytes", name, nbytes);
         return;
     }
     ggml_backend_tensor_get(tensor, host.data(), 0, nbytes);
@@ -235,15 +233,19 @@ void dump_tensor(const char *        name,
     // aids — the actual numerical comparison is byte-level via the
     // .f32 file. Computed in fp64 to avoid catastrophic cancellation
     // on the mean.
-    const size_t n_elem = nbytes / sizeof(float);
-    const float * fdata = reinterpret_cast<const float *>(host.data());
-    float vmin = std::numeric_limits<float>::infinity();
-    float vmax = -std::numeric_limits<float>::infinity();
-    double vsum = 0.0;
+    const size_t  n_elem = nbytes / sizeof(float);
+    const float * fdata  = reinterpret_cast<const float *>(host.data());
+    float         vmin   = std::numeric_limits<float>::infinity();
+    float         vmax   = -std::numeric_limits<float>::infinity();
+    double        vsum   = 0.0;
     for (size_t i = 0; i < n_elem; ++i) {
         const float v = fdata[i];
-        if (v < vmin) vmin = v;
-        if (v > vmax) vmax = v;
+        if (v < vmin) {
+            vmin = v;
+        }
+        if (v > vmax) {
+            vmax = v;
+        }
         vsum += static_cast<double>(v);
     }
     const double vmean = vsum / static_cast<double>(n_elem);
@@ -261,15 +263,12 @@ void dump_tensor(const char *        name,
     {
         std::ofstream f32(f32_path, std::ios::binary | std::ios::trunc);
         if (!f32) {
-            warn("dump_tensor(\"%s\"): cannot open %s for write",
-                 name, f32_path.c_str());
+            warn("dump_tensor(\"%s\"): cannot open %s for write", name, f32_path.c_str());
             return;
         }
-        f32.write(reinterpret_cast<const char *>(host.data()),
-                  static_cast<std::streamsize>(nbytes));
+        f32.write(reinterpret_cast<const char *>(host.data()), static_cast<std::streamsize>(nbytes));
         if (!f32) {
-            warn("dump_tensor(\"%s\"): write failed for %s",
-                 name, f32_path.c_str());
+            warn("dump_tensor(\"%s\"): write failed for %s", name, f32_path.c_str());
             return;
         }
     }
@@ -279,8 +278,7 @@ void dump_tensor(const char *        name,
     {
         std::ofstream js(json_path, std::ios::trunc);
         if (!js) {
-            warn("dump_tensor(\"%s\"): cannot open %s for write",
-                 name, json_path.c_str());
+            warn("dump_tensor(\"%s\"): cannot open %s for write", name, json_path.c_str());
             return;
         }
         const std::vector<int64_t> shape = row_major_shape(tensor);
@@ -292,7 +290,9 @@ void dump_tensor(const char *        name,
         }
         js << "  \"shape\": [";
         for (size_t i = 0; i < shape.size(); ++i) {
-            if (i) js << ", ";
+            if (i) {
+                js << ", ";
+            }
             js << shape[i];
         }
         js << "],\n";
@@ -302,14 +302,19 @@ void dump_tensor(const char *        name,
         // value round-trips visibly. The .f32 file is the
         // bit-precise source of truth; these are for humans.
         js.precision(9);
-        js << "  \"min\": ";  write_json_float(js, vmin);  js << ",\n";
-        js << "  \"max\": ";  write_json_float(js, vmax);  js << ",\n";
-        js << "  \"mean\": "; write_json_float(js, vmean); js << ",\n";
+        js << "  \"min\": ";
+        write_json_float(js, vmin);
+        js << ",\n";
+        js << "  \"max\": ";
+        write_json_float(js, vmax);
+        js << ",\n";
+        js << "  \"mean\": ";
+        write_json_float(js, vmean);
+        js << ",\n";
         js << "  \"source\": { \"kind\": \"cpp\" }\n";
         js << "}\n";
         if (!js) {
-            warn("dump_tensor(\"%s\"): write failed for %s",
-                 name, json_path.c_str());
+            warn("dump_tensor(\"%s\"): write failed for %s", name, json_path.c_str());
             return;
         }
     }
@@ -320,19 +325,16 @@ void dump_host_f32(const char *      name,
                    long long         n_elem,
                    const long long * shape,
                    int               n_dims,
-                   const char *      stage)
-{
+                   const char *      stage) {
     if (!enabled()) {
         return;
     }
     if (data == nullptr || n_elem <= 0) {
-        warn("dump_host_f32(\"%s\"): null data or zero elements",
-             name ? name : "(null)");
+        warn("dump_host_f32(\"%s\"): null data or zero elements", name ? name : "(null)");
         return;
     }
     if (!name_is_safe(name)) {
-        warn("dump_host_f32: rejecting unsafe name \"%s\"",
-             name ? name : "(null)");
+        warn("dump_host_f32: rejecting unsafe name \"%s\"", name ? name : "(null)");
         return;
     }
     if (shape == nullptr || n_dims <= 0) {
@@ -342,28 +344,30 @@ void dump_host_f32(const char *      name,
     long long shape_product = 1;
     for (int i = 0; i < n_dims; ++i) {
         if (shape[i] <= 0) {
-            warn("dump_host_f32(\"%s\"): non-positive shape[%d]=%lld",
-                 name, i, shape[i]);
+            warn("dump_host_f32(\"%s\"): non-positive shape[%d]=%lld", name, i, shape[i]);
             return;
         }
         shape_product *= shape[i];
     }
     if (shape_product != n_elem) {
-        warn("dump_host_f32(\"%s\"): shape product %lld != n_elem %lld",
-             name, shape_product, n_elem);
+        warn("dump_host_f32(\"%s\"): shape product %lld != n_elem %lld", name, shape_product, n_elem);
         return;
     }
 
     const size_t nbytes = static_cast<size_t>(n_elem) * sizeof(float);
 
     // Stats for the JSON sidecar.
-    float vmin = std::numeric_limits<float>::infinity();
-    float vmax = -std::numeric_limits<float>::infinity();
+    float  vmin = std::numeric_limits<float>::infinity();
+    float  vmax = -std::numeric_limits<float>::infinity();
     double vsum = 0.0;
     for (long long i = 0; i < n_elem; ++i) {
         const float v = data[i];
-        if (v < vmin) vmin = v;
-        if (v > vmax) vmax = v;
+        if (v < vmin) {
+            vmin = v;
+        }
+        if (v > vmax) {
+            vmax = v;
+        }
         vsum += static_cast<double>(v);
     }
     const double vmean = vsum / static_cast<double>(n_elem);
@@ -375,15 +379,12 @@ void dump_host_f32(const char *      name,
     {
         std::ofstream f32(f32_path, std::ios::binary | std::ios::trunc);
         if (!f32) {
-            warn("dump_host_f32(\"%s\"): cannot open %s for write",
-                 name, f32_path.c_str());
+            warn("dump_host_f32(\"%s\"): cannot open %s for write", name, f32_path.c_str());
             return;
         }
-        f32.write(reinterpret_cast<const char *>(data),
-                  static_cast<std::streamsize>(nbytes));
+        f32.write(reinterpret_cast<const char *>(data), static_cast<std::streamsize>(nbytes));
         if (!f32) {
-            warn("dump_host_f32(\"%s\"): write failed for %s",
-                 name, f32_path.c_str());
+            warn("dump_host_f32(\"%s\"): write failed for %s", name, f32_path.c_str());
             return;
         }
     }
@@ -391,8 +392,7 @@ void dump_host_f32(const char *      name,
     {
         std::ofstream js(json_path, std::ios::trunc);
         if (!js) {
-            warn("dump_host_f32(\"%s\"): cannot open %s for write",
-                 name, json_path.c_str());
+            warn("dump_host_f32(\"%s\"): cannot open %s for write", name, json_path.c_str());
             return;
         }
         js << "{\n";
@@ -402,24 +402,31 @@ void dump_host_f32(const char *      name,
         }
         js << "  \"shape\": [";
         for (int i = 0; i < n_dims; ++i) {
-            if (i) js << ", ";
+            if (i) {
+                js << ", ";
+            }
             js << shape[i];
         }
         js << "],\n";
         js << "  \"dtype\": \"f32\",\n";
         js << "  \"layout\": \"row-major\",\n";
         js.precision(9);
-        js << "  \"min\": ";  write_json_float(js, vmin);  js << ",\n";
-        js << "  \"max\": ";  write_json_float(js, vmax);  js << ",\n";
-        js << "  \"mean\": "; write_json_float(js, vmean); js << ",\n";
+        js << "  \"min\": ";
+        write_json_float(js, vmin);
+        js << ",\n";
+        js << "  \"max\": ";
+        write_json_float(js, vmax);
+        js << ",\n";
+        js << "  \"mean\": ";
+        write_json_float(js, vmean);
+        js << ",\n";
         js << "  \"source\": { \"kind\": \"cpp\" }\n";
         js << "}\n";
         if (!js) {
-            warn("dump_host_f32(\"%s\"): write failed for %s",
-                 name, json_path.c_str());
+            warn("dump_host_f32(\"%s\"): write failed for %s", name, json_path.c_str());
             return;
         }
     }
 }
 
-} // namespace transcribe::debug
+}  // namespace transcribe::debug
diff --git a/src/transcribe-debug.h b/src/transcribe-debug.h
index 79c6f8a2..17b2e3fb 100644
--- a/src/transcribe-debug.h
+++ b/src/transcribe-debug.h
@@ -102,9 +102,7 @@ void mark_tensor_for_dump(struct ggml_tensor * tensor);
 // error, malloc error), logs to stderr and returns without throwing.
 // Dumping is debug-only and must never affect compute correctness or
 // propagate errors out of a graph build.
-void dump_tensor(const char *               name,
-                 const struct ggml_tensor * tensor,
-                 const char *               stage = nullptr);
+void dump_tensor(const char * name, const struct ggml_tensor * tensor, const char * stage = nullptr);
 
 // Dump a host-side fp32 buffer to <dump_dir>/<name>.{f32,json}.
 //
@@ -116,11 +114,11 @@ void dump_tensor(const char *               name,
 // product(shape) == n_elem; pass `{n_elem}` for a 1D vector.
 //
 // Same name / stage / failure semantics as the ggml-tensor variant.
-void dump_host_f32(const char *           name,
-                   const float *          data,
-                   long long              n_elem,
-                   const long long *      shape,
-                   int                    n_dims,
-                   const char *           stage = nullptr);
+void dump_host_f32(const char *      name,
+                   const float *     data,
+                   long long         n_elem,
+                   const long long * shape,
+                   int               n_dims,
+                   const char *      stage = nullptr);
 
-} // namespace transcribe::debug
+}  // namespace transcribe::debug
diff --git a/src/transcribe-env.cpp b/src/transcribe-env.cpp
index a1d4a618..477199f6 100644
--- a/src/transcribe-env.cpp
+++ b/src/transcribe-env.cpp
@@ -19,4 +19,4 @@ bool flag(const char * name) {
     return v != nullptr && v[0] != '0';
 }
 
-} // namespace transcribe::env
+}  // namespace transcribe::env
diff --git a/src/transcribe-env.h b/src/transcribe-env.h
index 5bdd56cb..47da5682 100644
--- a/src/transcribe-env.h
+++ b/src/transcribe-env.h
@@ -21,4 +21,4 @@ bool flag(const char * name);
 // setenv/putenv.
 const char * str(const char * name);
 
-} // namespace transcribe::env
+}  // namespace transcribe::env
diff --git a/src/transcribe-flash-policy.cpp b/src/transcribe-flash-policy.cpp
index 168f835f..0cb0ab0b 100644
--- a/src/transcribe-flash-policy.cpp
+++ b/src/transcribe-flash-policy.cpp
@@ -8,8 +8,7 @@
 
 namespace transcribe::flash {
 
-void apply_env_overrides(bool & encoder_use_flash,
-                         bool & decoder_use_flash) {
+void apply_env_overrides(bool & encoder_use_flash, bool & decoder_use_flash) {
     if (transcribe::env::flag("TRANSCRIBE_NO_FLASH")) {
         encoder_use_flash = false;
         decoder_use_flash = false;
@@ -20,4 +19,4 @@ void apply_env_overrides(bool & encoder_use_flash,
     }
 }
 
-} // namespace transcribe::flash
+}  // namespace transcribe::flash
diff --git a/src/transcribe-flash-policy.h b/src/transcribe-flash-policy.h
index 0ebf2df5..b0db8b96 100644
--- a/src/transcribe-flash-policy.h
+++ b/src/transcribe-flash-policy.h
@@ -17,7 +17,6 @@ namespace transcribe::flash {
 // both flags in the same direction; if both are set, FORCE wins. The flags
 // are in/out: updated in-place if an override is set, left untouched
 // otherwise.
-void apply_env_overrides(bool & encoder_use_flash,
-                         bool & decoder_use_flash);
+void apply_env_overrides(bool & encoder_use_flash, bool & decoder_use_flash);
 
-} // namespace transcribe::flash
+}  // namespace transcribe::flash
diff --git a/src/transcribe-kaldi-fbank.cpp b/src/transcribe-kaldi-fbank.cpp
index 571ab8fa..c9a93530 100644
--- a/src/transcribe-kaldi-fbank.cpp
+++ b/src/transcribe-kaldi-fbank.cpp
@@ -15,13 +15,15 @@ namespace transcribe {
 
 namespace {
 
-constexpr float kPreemphasis = 0.97f;     // kaldi default
-constexpr float kMelLowFreq  = 20.0f;     // kaldi default
-constexpr float kMelHighFreq = 0.0f;      // 0 → use sample_rate / 2
+constexpr float kPreemphasis = 0.97f;  // kaldi default
+constexpr float kMelLowFreq  = 20.0f;  // kaldi default
+constexpr float kMelHighFreq = 0.0f;   // 0 → use sample_rate / 2
 
 int next_pow2(int n) {
     int p = 1;
-    while (p < n) p <<= 1;
+    while (p < n) {
+        p <<= 1;
+    }
     return p;
 }
 
@@ -30,6 +32,7 @@ int next_pow2(int n) {
 double hz_to_mel(double f) {
     return 1127.0 * std::log(1.0 + f / 700.0);
 }
+
 double mel_to_hz(double m) {
     return 700.0 * (std::exp(m / 1127.0) - 1.0);
 }
@@ -41,8 +44,7 @@ std::vector<float> build_htk_mel_filterbank(int   sample_rate,
                                             int   padded_n_fft,
                                             int   n_mels,
                                             float low_freq,
-                                            float high_freq)
-{
+                                            float high_freq) {
     const int n_freq = padded_n_fft / 2 + 1;
     if (high_freq <= 0.0f) {
         high_freq = static_cast<float>(sample_rate) * 0.5f;
@@ -52,8 +54,7 @@ std::vector<float> build_htk_mel_filterbank(int   sample_rate,
     const double mel_step = (mel_high - mel_low) / (n_mels + 1);
 
     // kaldi-style fft_bin_width = sample_rate / padded_n_fft.
-    const double fft_bin_width = static_cast<double>(sample_rate) /
-                                 static_cast<double>(padded_n_fft);
+    const double fft_bin_width = static_cast<double>(sample_rate) / static_cast<double>(padded_n_fft);
 
     std::vector<float> fb(static_cast<size_t>(n_mels) * n_freq, 0.0f);
     for (int m = 0; m < n_mels; ++m) {
@@ -66,7 +67,7 @@ std::vector<float> build_htk_mel_filterbank(int   sample_rate,
 
         for (int b = 0; b < n_freq; ++b) {
             const double bin_hz = b * fft_bin_width;
-            double w = 0.0;
+            double       w      = 0.0;
             if (bin_hz > left_hz && bin_hz < right_hz) {
                 if (bin_hz <= center_hz) {
                     w = (bin_hz - left_hz) / (center_hz - left_hz);
@@ -74,7 +75,9 @@ std::vector<float> build_htk_mel_filterbank(int   sample_rate,
                     w = (right_hz - bin_hz) / (right_hz - center_hz);
                 }
             }
-            if (w < 0.0) w = 0.0;
+            if (w < 0.0) {
+                w = 0.0;
+            }
             fb[static_cast<size_t>(m) * n_freq + b] = static_cast<float>(w);
         }
     }
@@ -85,13 +88,14 @@ std::vector<float> build_htk_mel_filterbank(int   sample_rate,
 std::vector<float> build_hamming_window(int N) {
     std::vector<float> w(static_cast<size_t>(N));
     if (N <= 1) {
-        for (auto & v : w) v = 1.0f;
+        for (auto & v : w) {
+            v = 1.0f;
+        }
         return w;
     }
     const double a = 2.0 * M_PI / (N - 1);
     for (int i = 0; i < N; ++i) {
-        w[static_cast<size_t>(i)] =
-            static_cast<float>(0.54 - 0.46 * std::cos(a * i));
+        w[static_cast<size_t>(i)] = static_cast<float>(0.54 - 0.46 * std::cos(a * i));
     }
     return w;
 }
@@ -107,7 +111,7 @@ void fft_radix2(double * data, int n) {
         }
         j ^= bit;
         if (i < j) {
-            std::swap(data[2 * i],     data[2 * j]);
+            std::swap(data[2 * i], data[2 * j]);
             std::swap(data[2 * i + 1], data[2 * j + 1]);
         }
     }
@@ -119,41 +123,35 @@ void fft_radix2(double * data, int n) {
             double w_re = 1.0;
             double w_im = 0.0;
             for (int k = 0; k < len / 2; ++k) {
-                const int a = 2 * (i + k);
-                const int b = 2 * (i + k + len / 2);
-                const double u_re = data[a];
-                const double u_im = data[a + 1];
-                const double v_re = data[b]     * w_re - data[b + 1] * w_im;
-                const double v_im = data[b]     * w_im + data[b + 1] * w_re;
-                data[a]     = u_re + v_re;
-                data[a + 1] = u_im + v_im;
-                data[b]     = u_re - v_re;
-                data[b + 1] = u_im - v_im;
+                const int    a      = 2 * (i + k);
+                const int    b      = 2 * (i + k + len / 2);
+                const double u_re   = data[a];
+                const double u_im   = data[a + 1];
+                const double v_re   = data[b] * w_re - data[b + 1] * w_im;
+                const double v_im   = data[b] * w_im + data[b + 1] * w_re;
+                data[a]             = u_re + v_re;
+                data[a + 1]         = u_im + v_im;
+                data[b]             = u_re - v_re;
+                data[b + 1]         = u_im - v_im;
                 const double tmp_re = w_re * wlen_re - w_im * wlen_im;
                 const double tmp_im = w_re * wlen_im + w_im * wlen_re;
-                w_re = tmp_re;
-                w_im = tmp_im;
+                w_re                = tmp_re;
+                w_im                = tmp_im;
             }
         }
     }
 }
 
-} // namespace
+}  // namespace
 
-KaldiFbankFrontend::KaldiFbankFrontend(KaldiFbankParams params)
-    : params_(std::move(params))
-    , padded_n_fft_(next_pow2(params_.win_length))
-{
-    mel_fb_ = build_htk_mel_filterbank(
-        params_.sample_rate, padded_n_fft_, params_.n_mels,
-        kMelLowFreq, kMelHighFreq);
+KaldiFbankFrontend::KaldiFbankFrontend(KaldiFbankParams params) :
+    params_(std::move(params)),
+    padded_n_fft_(next_pow2(params_.win_length)) {
+    mel_fb_ = build_htk_mel_filterbank(params_.sample_rate, padded_n_fft_, params_.n_mels, kMelLowFreq, kMelHighFreq);
     window_ = build_hamming_window(params_.win_length);
 }
 
-int KaldiFbankFrontend::compute(const float *        pcm,
-                                size_t               n_samples,
-                                std::vector<float> & out_features) const
-{
+int KaldiFbankFrontend::compute(const float * pcm, size_t n_samples, std::vector<float> & out_features) const {
     const int win_length = params_.win_length;
     const int hop_length = params_.hop_length;
     const int n_mels     = params_.n_mels;
@@ -167,9 +165,8 @@ int KaldiFbankFrontend::compute(const float *        pcm,
     }
 
     // Snip-edges framing: T_frames = 1 + floor((N - win_length) / hop).
-    const int T_frames = 1 + static_cast<int>(
-        (n_samples - static_cast<size_t>(win_length)) /
-        static_cast<size_t>(hop_length));
+    const int T_frames =
+        1 + static_cast<int>((n_samples - static_cast<size_t>(win_length)) / static_cast<size_t>(hop_length));
     if (T_frames <= 0) {
         out_features.clear();
         return 0;
@@ -208,22 +205,18 @@ int KaldiFbankFrontend::compute(const float *        pcm,
         // depends on x[i-1] from BEFORE preemph) — kaldi works backward
         // i = N-1 .. 1, then handles i=0.
         for (int i = win_length - 1; i >= 1; --i) {
-            frame_f[static_cast<size_t>(i)] -=
-                kPreemphasis * frame_f[static_cast<size_t>(i - 1)];
+            frame_f[static_cast<size_t>(i)] -= kPreemphasis * frame_f[static_cast<size_t>(i - 1)];
         }
         frame_f[0] *= (1.0f - kPreemphasis);
 
         // Step 4: apply hamming window.
         for (int i = 0; i < win_length; ++i) {
-            frame_f[static_cast<size_t>(i)] *=
-                window_[static_cast<size_t>(i)];
+            frame_f[static_cast<size_t>(i)] *= window_[static_cast<size_t>(i)];
         }
 
         // Step 5: pad to padded_n_fft and FFT.
         for (int i = 0; i < padded_n_fft_; ++i) {
-            const float re = i < win_length
-                ? frame_f[static_cast<size_t>(i)]
-                : 0.0f;
+            const float re   = i < win_length ? frame_f[static_cast<size_t>(i)] : 0.0f;
             frame[2 * i]     = static_cast<double>(re);
             frame[2 * i + 1] = 0.0;
         }
@@ -231,10 +224,9 @@ int KaldiFbankFrontend::compute(const float *        pcm,
 
         // Step 6: power spectrum.
         for (int b = 0; b < n_freq; ++b) {
-            const double re = frame[2 * b];
-            const double im = frame[2 * b + 1];
-            power[static_cast<size_t>(b)] =
-                static_cast<float>(re * re + im * im);
+            const double re               = frame[2 * b];
+            const double im               = frame[2 * b + 1];
+            power[static_cast<size_t>(b)] = static_cast<float>(re * re + im * im);
         }
 
         // Step 7-8: HTK mel filterbank + log with energy_floor. funasr
@@ -243,14 +235,13 @@ int KaldiFbankFrontend::compute(const float *        pcm,
         // the underflow-floor `FLT_MIN`. log of that floor is ~ -15.94.
         float * mel_row = mel.data() + static_cast<size_t>(t) * n_mels;
         for (int m = 0; m < n_mels; ++m) {
-            const float * fb_row =
-                mel_fb_.data() + static_cast<size_t>(m) * n_freq;
-            float acc = 0.0f;
+            const float * fb_row = mel_fb_.data() + static_cast<size_t>(m) * n_freq;
+            float         acc    = 0.0f;
             for (int b = 0; b < n_freq; ++b) {
                 acc += fb_row[b] * power[static_cast<size_t>(b)];
             }
-            constexpr float kMelEpsilon = 1.1920928955078125e-07f;
-            const float floored = std::max(acc, kMelEpsilon);
+            constexpr float kMelEpsilon     = 1.1920928955078125e-07f;
+            const float     floored         = std::max(acc, kMelEpsilon);
             mel_row[static_cast<size_t>(m)] = std::log(floored);
         }
     }
@@ -268,22 +259,21 @@ int KaldiFbankFrontend::compute(const float *        pcm,
     const int T_lfr    = (T_frames + lfr_n - 1) / lfr_n;
     out_features.assign(static_cast<size_t>(T_lfr) * d_input, 0.0f);
     for (int t_lfr = 0; t_lfr < T_lfr; ++t_lfr) {
-        float * out_row =
-            out_features.data() + static_cast<size_t>(t_lfr) * d_input;
+        float * out_row = out_features.data() + static_cast<size_t>(t_lfr) * d_input;
         for (int k = 0; k < lfr_m; ++k) {
             const int padded_idx = t_lfr * lfr_n + k;
             // Map padded index back to real mel frame.
-            int src;
+            int       src;
             if (padded_idx < left_pad) {
                 src = 0;
             } else {
                 src = padded_idx - left_pad;
-                if (src >= T_frames) src = T_frames - 1;
+                if (src >= T_frames) {
+                    src = T_frames - 1;
+                }
             }
-            const float * src_row =
-                mel.data() + static_cast<size_t>(src) * n_mels;
-            std::memcpy(out_row + static_cast<size_t>(k) * n_mels,
-                        src_row, sizeof(float) * n_mels);
+            const float * src_row = mel.data() + static_cast<size_t>(src) * n_mels;
+            std::memcpy(out_row + static_cast<size_t>(k) * n_mels, src_row, sizeof(float) * n_mels);
         }
         // Step 10: optional per-feature CMVN: (x + shift) * scale.
         if (params_.apply_cmvn) {
@@ -298,4 +288,4 @@ int KaldiFbankFrontend::compute(const float *        pcm,
     return T_lfr;
 }
 
-} // namespace transcribe
+}  // namespace transcribe
diff --git a/src/transcribe-kaldi-fbank.h b/src/transcribe-kaldi-fbank.h
index 8106695d..c859c43e 100644
--- a/src/transcribe-kaldi-fbank.h
+++ b/src/transcribe-kaldi-fbank.h
@@ -37,42 +37,43 @@
 namespace transcribe {
 
 struct KaldiFbankParams {
-    int  n_mels          = 0;      // 80
-    int  sample_rate     = 0;      // 16000
-    int  win_length      = 0;      // 400
-    int  hop_length      = 0;      // 160
-    int  lfr_m           = 0;      // 7
-    int  lfr_n           = 0;      // 6
-    int  d_input         = 0;      // n_mels * lfr_m, e.g. 560
-    bool upscale_samples = true;   // ×32768 PCM scale before framing
-    bool apply_cmvn      = false;  // gate the trailing CMVN step
+    int                n_mels          = 0;      // 80
+    int                sample_rate     = 0;      // 16000
+    int                win_length      = 0;      // 400
+    int                hop_length      = 0;      // 160
+    int                lfr_m           = 0;      // 7
+    int                lfr_n           = 0;      // 6
+    int                d_input         = 0;      // n_mels * lfr_m, e.g. 560
+    bool               upscale_samples = true;   // ×32768 PCM scale before framing
+    bool               apply_cmvn      = false;  // gate the trailing CMVN step
     // Required when apply_cmvn=true; ignored otherwise. Length d_input.
     std::vector<float> cmvn_shift;
     std::vector<float> cmvn_scale;
 };
 
 class KaldiFbankFrontend {
-public:
+  public:
     explicit KaldiFbankFrontend(KaldiFbankParams params);
 
     // Compute LFR (+ optional CMVN) features from raw [-1, 1] f32 PCM.
     // Output is row-major [T_lfr, d_input] stored in `out_features`.
     // Returns the number of LFR frames; 0 if the input is too short to
     // produce any LFR output (which means the model cannot run on it).
-    int compute(const float *        pcm,
-                size_t               n_samples,
-                std::vector<float> & out_features) const;
+    int compute(const float * pcm, size_t n_samples, std::vector<float> & out_features) const;
 
-    int  d_input()  const { return params_.d_input; }
-    int  n_mels()   const { return params_.n_mels; }
-    int  lfr_m()    const { return params_.lfr_m; }
-    int  lfr_n()    const { return params_.lfr_n; }
+    int d_input() const { return params_.d_input; }
 
-private:
+    int n_mels() const { return params_.n_mels; }
+
+    int lfr_m() const { return params_.lfr_m; }
+
+    int lfr_n() const { return params_.lfr_n; }
+
+  private:
     KaldiFbankParams   params_;
-    int                padded_n_fft_ = 0;   // next_pow2(win_length)
-    std::vector<float> mel_fb_;             // [n_mels, padded_n_fft/2 + 1]
-    std::vector<float> window_;             // [win_length]
+    int                padded_n_fft_ = 0;  // next_pow2(win_length)
+    std::vector<float> mel_fb_;            // [n_mels, padded_n_fft/2 + 1]
+    std::vector<float> window_;            // [win_length]
 };
 
-} // namespace transcribe
+}  // namespace transcribe
diff --git a/src/transcribe-load-common.cpp b/src/transcribe-load-common.cpp
index 6d5f78a9..52e18123 100644
--- a/src/transcribe-load-common.cpp
+++ b/src/transcribe-load-common.cpp
@@ -5,13 +5,12 @@
 
 #include "transcribe-load-common.h"
 
-#include "transcribe-backend.h"
-#include "transcribe-log.h"
-
-#include "ggml.h"
 #include "ggml-alloc.h"
 #include "ggml-backend.h"
+#include "ggml.h"
 #include "gguf.h"
+#include "transcribe-backend.h"
+#include "transcribe-log.h"
 
 #include <cstdint>
 #include <cstdio>
@@ -36,10 +35,7 @@ namespace {
 // out_kind is derived from the device that actually initialized, not
 // from a separate post-hoc registry walk, so a failing first-GPU
 // followed by a succeeding second-GPU yields the correct kind.
-ggml_backend_t try_init_kind(BackendKind   wanted,
-                             const char *  error_tag,
-                             BackendKind & out_kind)
-{
+ggml_backend_t try_init_kind(BackendKind wanted, const char * error_tag, BackendKind & out_kind) {
     const size_t n = ggml_backend_dev_count();
     for (size_t i = 0; i < n; ++i) {
         ggml_backend_dev_t dev = ggml_backend_dev_get(i);
@@ -48,8 +44,7 @@ ggml_backend_t try_init_kind(BackendKind   wanted,
             // "Any GPU" probe: accept the first GPU/IGPU device,
             // regardless of vendor.
             const auto dev_type = ggml_backend_dev_type(dev);
-            if (dev_type != GGML_BACKEND_DEVICE_TYPE_GPU &&
-                dev_type != GGML_BACKEND_DEVICE_TYPE_IGPU) {
+            if (dev_type != GGML_BACKEND_DEVICE_TYPE_GPU && dev_type != GGML_BACKEND_DEVICE_TYPE_IGPU) {
                 continue;
             }
         } else if (classify_device(dev) != wanted) {
@@ -57,13 +52,13 @@ ggml_backend_t try_init_kind(BackendKind   wanted,
         }
 
         ggml_backend_t be = ggml_backend_dev_init(dev, nullptr);
-        if (be == nullptr) continue;
+        if (be == nullptr) {
+            continue;
+        }
 
         const BackendKind kind = classify_device(dev);
-        log_msg(TRANSCRIBE_LOG_LEVEL_INFO, "%s: using %s backend: %s",
-                     error_tag,
-                     kind_name(kind),
-                     ggml_backend_dev_name(dev));
+        log_msg(TRANSCRIBE_LOG_LEVEL_INFO, "%s: using %s backend: %s", error_tag, kind_name(kind),
+                ggml_backend_dev_name(dev));
         out_kind = kind;
         return be;
     }
@@ -75,9 +70,7 @@ ggml_backend_t try_init_kind(BackendKind   wanted,
 // layer cleanly on top of both CPU and GPU primaries. They are
 // excluded only on strict-CPU requests, where the whole point is to
 // avoid any backend dispatch ambiguity.
-void append_accel_backends(std::vector<ggml_backend_t> & out,
-                           const char *                  error_tag)
-{
+void append_accel_backends(std::vector<ggml_backend_t> & out, const char * error_tag) {
     const size_t n = ggml_backend_dev_count();
     for (size_t i = 0; i < n; ++i) {
         ggml_backend_dev_t dev = ggml_backend_dev_get(i);
@@ -85,10 +78,11 @@ void append_accel_backends(std::vector<ggml_backend_t> & out,
             continue;
         }
         ggml_backend_t be = ggml_backend_dev_init(dev, nullptr);
-        if (be == nullptr) continue;
+        if (be == nullptr) {
+            continue;
+        }
 
-        log_msg(TRANSCRIBE_LOG_LEVEL_INFO, "%s: using accel backend: %s",
-                     error_tag, ggml_backend_dev_name(dev));
+        log_msg(TRANSCRIBE_LOG_LEVEL_INFO, "%s: using accel backend: %s", error_tag, ggml_backend_dev_name(dev));
         out.push_back(be);
     }
 }
@@ -96,11 +90,9 @@ void append_accel_backends(std::vector<ggml_backend_t> & out,
 // Initialize the CPU backend. Always runs — it is the universal
 // fallback and the strict-CPU primary.
 ggml_backend_t init_cpu_backend(const char * error_tag) {
-    ggml_backend_t cpu_be =
-        ggml_backend_init_by_type(GGML_BACKEND_DEVICE_TYPE_CPU, nullptr);
+    ggml_backend_t cpu_be = ggml_backend_init_by_type(GGML_BACKEND_DEVICE_TYPE_CPU, nullptr);
     if (cpu_be == nullptr) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "%s: failed to initialize CPU backend", error_tag);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: failed to initialize CPU backend", error_tag);
     }
     return cpu_be;
 }
@@ -127,24 +119,18 @@ bool valid_backend_request(int raw) {
 transcribe_status init_backends_explicit_index(transcribe_backend_request requested,
                                                int                        dev_index,
                                                const char *               error_tag,
-                                               BackendPlan &              out)
-{
+                                               BackendPlan &              out) {
     const size_t n = ggml_backend_dev_count();
     if (dev_index < 0 || static_cast<size_t>(dev_index) >= n) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "%s: gpu_device %d out of range [0, %zu)",
-                     error_tag, dev_index, n);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: gpu_device %d out of range [0, %zu)", error_tag, dev_index, n);
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
 
-    ggml_backend_dev_t dev = ggml_backend_dev_get(static_cast<size_t>(dev_index));
-    const auto dev_type = ggml_backend_dev_type(dev);
-    if (dev_type != GGML_BACKEND_DEVICE_TYPE_GPU &&
-        dev_type != GGML_BACKEND_DEVICE_TYPE_IGPU)
-    {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "%s: gpu_device %d (%s) is not a GPU device",
-                     error_tag, dev_index, ggml_backend_dev_name(dev));
+    ggml_backend_dev_t dev      = ggml_backend_dev_get(static_cast<size_t>(dev_index));
+    const auto         dev_type = ggml_backend_dev_type(dev);
+    if (dev_type != GGML_BACKEND_DEVICE_TYPE_GPU && dev_type != GGML_BACKEND_DEVICE_TYPE_IGPU) {
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: gpu_device %d (%s) is not a GPU device", error_tag, dev_index,
+                ggml_backend_dev_name(dev));
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
 
@@ -153,32 +139,36 @@ transcribe_status init_backends_explicit_index(transcribe_backend_request reques
     // A specific vendor request pins the kind; AUTO accepts any GPU.
     BackendKind wanted = BackendKind::Unknown;  // Unknown == "any GPU" (AUTO)
     switch (requested) {
-        case TRANSCRIBE_BACKEND_METAL:  wanted = BackendKind::Metal;  break;
-        case TRANSCRIBE_BACKEND_VULKAN: wanted = BackendKind::Vulkan; break;
-        case TRANSCRIBE_BACKEND_CUDA:   wanted = BackendKind::Cuda;   break;
-        case TRANSCRIBE_BACKEND_AUTO:   break;
+        case TRANSCRIBE_BACKEND_METAL:
+            wanted = BackendKind::Metal;
+            break;
+        case TRANSCRIBE_BACKEND_VULKAN:
+            wanted = BackendKind::Vulkan;
+            break;
+        case TRANSCRIBE_BACKEND_CUDA:
+            wanted = BackendKind::Cuda;
+            break;
+        case TRANSCRIBE_BACKEND_AUTO:
+            break;
         default:
             // CPU / CPU_ACCEL never reach here (caller rejects nonzero
             // gpu_device for them); anything else is a programming error.
             return TRANSCRIBE_ERR_INVALID_ARG;
     }
     if (wanted != BackendKind::Unknown && got != wanted) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "%s: gpu_device %d is a %s device but %s was requested",
-                     error_tag, dev_index, kind_name(got), kind_name(wanted));
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: gpu_device %d is a %s device but %s was requested", error_tag,
+                dev_index, kind_name(got), kind_name(wanted));
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
 
     ggml_backend_t gpu_be = ggml_backend_dev_init(dev, nullptr);
     if (gpu_be == nullptr) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "%s: failed to initialize gpu_device %d (%s)",
-                     error_tag, dev_index, ggml_backend_dev_name(dev));
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: failed to initialize gpu_device %d (%s)", error_tag, dev_index,
+                ggml_backend_dev_name(dev));
         return TRANSCRIBE_ERR_BACKEND;
     }
-    log_msg(TRANSCRIBE_LOG_LEVEL_INFO,
-                 "%s: using %s backend (gpu_device %d): %s",
-                 error_tag, kind_name(got), dev_index, ggml_backend_dev_name(dev));
+    log_msg(TRANSCRIBE_LOG_LEVEL_INFO, "%s: using %s backend (gpu_device %d): %s", error_tag, kind_name(got), dev_index,
+            ggml_backend_dev_name(dev));
 
     out.primary      = gpu_be;
     out.primary_kind = got;
@@ -187,18 +177,19 @@ transcribe_status init_backends_explicit_index(transcribe_backend_request reques
     append_accel_backends(out.scheduler_list, error_tag);
 
     ggml_backend_t cpu_be = init_cpu_backend(error_tag);
-    if (cpu_be == nullptr) return TRANSCRIBE_ERR_BACKEND;
+    if (cpu_be == nullptr) {
+        return TRANSCRIBE_ERR_BACKEND;
+    }
     out.scheduler_list.push_back(cpu_be);
     return TRANSCRIBE_OK;
 }
 
-} // namespace
+}  // namespace
 
 transcribe_status init_backends(transcribe_backend_request requested,
                                 int                        gpu_device,
                                 const char *               error_tag,
-                                BackendPlan &              out)
-{
+                                BackendPlan &              out) {
     // Read the request as raw bytes before any enum-typed load: a C caller
     // can pass any int here, and loading an out-of-range value through the
     // enum lvalue is UB in C++ (UBSan traps). The raw value is validated by
@@ -206,38 +197,30 @@ transcribe_status init_backends(transcribe_backend_request requested,
     int requested_raw = TRANSCRIBE_BACKEND_AUTO;
     std::memcpy(&requested_raw, &requested, sizeof(requested_raw));
 
-    out = BackendPlan{};
+    out           = BackendPlan{};
     out.requested = static_cast<transcribe_backend_request>(
-        valid_backend_request(requested_raw) ? requested_raw
-                                             : TRANSCRIBE_BACKEND_AUTO);
+        valid_backend_request(requested_raw) ? requested_raw : TRANSCRIBE_BACKEND_AUTO);
 
     // Explicit device selection. 0 is "auto / first of kind" and falls
     // through to the per-request logic below; a negative index is always
     // invalid; a positive index pins a specific GPU/IGPU device.
     if (gpu_device < 0) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "%s: gpu_device must be >= 0 (got %d)",
-                     error_tag, gpu_device);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: gpu_device must be >= 0 (got %d)", error_tag, gpu_device);
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
     if (gpu_device > 0) {
         if (!valid_backend_request(requested_raw)) {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "%s: invalid transcribe_backend_request value %d",
-                         error_tag, requested_raw);
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: invalid transcribe_backend_request value %d", error_tag,
+                    requested_raw);
             return TRANSCRIBE_ERR_INVALID_ARG;
         }
         // gpu_device names a GPU; a CPU-only request has nothing to select.
-        if (requested_raw == TRANSCRIBE_BACKEND_CPU ||
-            requested_raw == TRANSCRIBE_BACKEND_CPU_ACCEL)
-        {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "%s: gpu_device %d is invalid for a CPU backend request",
-                         error_tag, gpu_device);
+        if (requested_raw == TRANSCRIBE_BACKEND_CPU || requested_raw == TRANSCRIBE_BACKEND_CPU_ACCEL) {
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: gpu_device %d is invalid for a CPU backend request", error_tag,
+                    gpu_device);
             return TRANSCRIBE_ERR_INVALID_ARG;
         }
-        return init_backends_explicit_index(out.requested, gpu_device,
-                                            error_tag, out);
+        return init_backends_explicit_index(out.requested, gpu_device, error_tag, out);
     }
 
     // Explicit switch over the enum so an unknown / garbage value
@@ -245,167 +228,164 @@ transcribe_status init_backends(transcribe_backend_request requested,
     // values are a programming error on the caller's side, not a
     // fallback we want to tolerate.
     switch (requested_raw) {
-    case TRANSCRIBE_BACKEND_CPU:
-    case TRANSCRIBE_BACKEND_CPU_ACCEL: {
-        // CPU primary. CPU_ACCEL additionally layers the host-memory
-        // accelerators (BLAS/AMX/…, GGML_BACKEND_DEVICE_TYPE_ACCEL) onto the
-        // scheduler. Both set primary_kind == Cpu so CPU-keyed policy (e.g.
-        // F16→F32 conv pointwise promotion) triggers identically.
-        //
-        // ggml requires the CPU backend to sit last in the scheduler list,
-        // so accel backends (when included) go in first.
-        const bool with_accel = (requested == TRANSCRIBE_BACKEND_CPU_ACCEL);
-        ggml_backend_t cpu_be = init_cpu_backend(error_tag);
-        if (cpu_be == nullptr) return TRANSCRIBE_ERR_BACKEND;
-        log_msg(TRANSCRIBE_LOG_LEVEL_INFO, "%s: using cpu backend (%s)",
-                     error_tag, with_accel ? "with accel" : "strict");
-        out.primary      = cpu_be;
-        out.primary_kind = BackendKind::Cpu;
-        if (with_accel) {
-            append_accel_backends(out.scheduler_list, error_tag);
-        }
-        out.scheduler_list.push_back(cpu_be);
-        return TRANSCRIBE_OK;
-    }
-
-    case TRANSCRIBE_BACKEND_METAL:
-    case TRANSCRIBE_BACKEND_VULKAN:
-    case TRANSCRIBE_BACKEND_CUDA: {
-        // Specific GPU backend request: must find a matching device
-        // or fail. ACCEL is still layered on because it's host-memory
-        // and orthogonal to the GPU/CPU split.
-        BackendKind wanted = BackendKind::Unknown;
-        switch (requested) {
-            case TRANSCRIBE_BACKEND_METAL:  wanted = BackendKind::Metal;  break;
-            case TRANSCRIBE_BACKEND_VULKAN: wanted = BackendKind::Vulkan; break;
-            case TRANSCRIBE_BACKEND_CUDA:   wanted = BackendKind::Cuda;   break;
-            default: break;
-        }
-        BackendKind got_kind = BackendKind::Unknown;
-        ggml_backend_t gpu_be = try_init_kind(wanted, error_tag, got_kind);
-        if (gpu_be == nullptr) {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "%s: %s backend requested but not available",
-                         error_tag, kind_name(wanted));
-            return TRANSCRIBE_ERR_BACKEND;
-        }
-        out.primary      = gpu_be;
-        out.primary_kind = got_kind;
-        out.scheduler_list.push_back(gpu_be);
-
-        append_accel_backends(out.scheduler_list, error_tag);
-
-        ggml_backend_t cpu_be = init_cpu_backend(error_tag);
-        if (cpu_be == nullptr) return TRANSCRIBE_ERR_BACKEND;
-        out.scheduler_list.push_back(cpu_be);
-        return TRANSCRIBE_OK;
-    }
-
-    case TRANSCRIBE_BACKEND_AUTO: {
-        // AUTO: take the first GPU/IGPU device that successfully
-        // initializes, regardless of vendor. ggml registers devices
-        // in build-time priority order (Metal on Apple, Vulkan on
-        // Linux, etc.), which matches the documented preference.
-        // If every GPU fails init or none is compiled in, fall
-        // through to CPU + ACCEL.
-        //
-        // try_init_kind yields the classified kind of the device
-        // that actually succeeded, so a failing-then-succeeding probe
-        // can't misclassify primary_kind.
-        BackendKind got_kind = BackendKind::Unknown;
-        ggml_backend_t gpu_be =
-            try_init_kind(BackendKind::OtherGpu, error_tag, got_kind);
-        if (gpu_be != nullptr) {
-            out.primary      = gpu_be;
-            out.primary_kind = got_kind;
-            out.scheduler_list.push_back(gpu_be);
-        }
-
-        append_accel_backends(out.scheduler_list, error_tag);
+        case TRANSCRIBE_BACKEND_CPU:
+        case TRANSCRIBE_BACKEND_CPU_ACCEL:
+            {
+                // CPU primary. CPU_ACCEL additionally layers the host-memory
+                // accelerators (BLAS/AMX/…, GGML_BACKEND_DEVICE_TYPE_ACCEL) onto the
+                // scheduler. Both set primary_kind == Cpu so CPU-keyed policy (e.g.
+                // F16→F32 conv pointwise promotion) triggers identically.
+                //
+                // ggml requires the CPU backend to sit last in the scheduler list,
+                // so accel backends (when included) go in first.
+                const bool     with_accel = (requested == TRANSCRIBE_BACKEND_CPU_ACCEL);
+                ggml_backend_t cpu_be     = init_cpu_backend(error_tag);
+                if (cpu_be == nullptr) {
+                    return TRANSCRIBE_ERR_BACKEND;
+                }
+                log_msg(TRANSCRIBE_LOG_LEVEL_INFO, "%s: using cpu backend (%s)", error_tag,
+                        with_accel ? "with accel" : "strict");
+                out.primary      = cpu_be;
+                out.primary_kind = BackendKind::Cpu;
+                if (with_accel) {
+                    append_accel_backends(out.scheduler_list, error_tag);
+                }
+                out.scheduler_list.push_back(cpu_be);
+                return TRANSCRIBE_OK;
+            }
 
-        ggml_backend_t cpu_be = init_cpu_backend(error_tag);
-        if (cpu_be == nullptr) {
-            // If we already have at least a GPU or ACCEL backend,
-            // losing CPU is catastrophic — the scheduler needs CPU
-            // as a fallback for every op it can't dispatch
-            // elsewhere. Fail hard.
-            return TRANSCRIBE_ERR_BACKEND;
-        }
+        case TRANSCRIBE_BACKEND_METAL:
+        case TRANSCRIBE_BACKEND_VULKAN:
+        case TRANSCRIBE_BACKEND_CUDA:
+            {
+                // Specific GPU backend request: must find a matching device
+                // or fail. ACCEL is still layered on because it's host-memory
+                // and orthogonal to the GPU/CPU split.
+                BackendKind wanted = BackendKind::Unknown;
+                switch (requested) {
+                    case TRANSCRIBE_BACKEND_METAL:
+                        wanted = BackendKind::Metal;
+                        break;
+                    case TRANSCRIBE_BACKEND_VULKAN:
+                        wanted = BackendKind::Vulkan;
+                        break;
+                    case TRANSCRIBE_BACKEND_CUDA:
+                        wanted = BackendKind::Cuda;
+                        break;
+                    default:
+                        break;
+                }
+                BackendKind    got_kind = BackendKind::Unknown;
+                ggml_backend_t gpu_be   = try_init_kind(wanted, error_tag, got_kind);
+                if (gpu_be == nullptr) {
+                    log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: %s backend requested but not available", error_tag,
+                            kind_name(wanted));
+                    return TRANSCRIBE_ERR_BACKEND;
+                }
+                out.primary      = gpu_be;
+                out.primary_kind = got_kind;
+                out.scheduler_list.push_back(gpu_be);
+
+                append_accel_backends(out.scheduler_list, error_tag);
+
+                ggml_backend_t cpu_be = init_cpu_backend(error_tag);
+                if (cpu_be == nullptr) {
+                    return TRANSCRIBE_ERR_BACKEND;
+                }
+                out.scheduler_list.push_back(cpu_be);
+                return TRANSCRIBE_OK;
+            }
 
-        // If the GPU probe failed and AUTO picked nothing so far, CPU
-        // becomes the primary.
-        if (out.primary == nullptr) {
-            out.primary      = cpu_be;
-            out.primary_kind = BackendKind::Cpu;
-        }
-        out.scheduler_list.push_back(cpu_be);
-        return TRANSCRIBE_OK;
-    }
+        case TRANSCRIBE_BACKEND_AUTO:
+            {
+                // AUTO: take the first GPU/IGPU device that successfully
+                // initializes, regardless of vendor. ggml registers devices
+                // in build-time priority order (Metal on Apple, Vulkan on
+                // Linux, etc.), which matches the documented preference.
+                // If every GPU fails init or none is compiled in, fall
+                // through to CPU + ACCEL.
+                //
+                // try_init_kind yields the classified kind of the device
+                // that actually succeeded, so a failing-then-succeeding probe
+                // can't misclassify primary_kind.
+                BackendKind    got_kind = BackendKind::Unknown;
+                ggml_backend_t gpu_be   = try_init_kind(BackendKind::OtherGpu, error_tag, got_kind);
+                if (gpu_be != nullptr) {
+                    out.primary      = gpu_be;
+                    out.primary_kind = got_kind;
+                    out.scheduler_list.push_back(gpu_be);
+                }
+
+                append_accel_backends(out.scheduler_list, error_tag);
+
+                ggml_backend_t cpu_be = init_cpu_backend(error_tag);
+                if (cpu_be == nullptr) {
+                    // If we already have at least a GPU or ACCEL backend,
+                    // losing CPU is catastrophic — the scheduler needs CPU
+                    // as a fallback for every op it can't dispatch
+                    // elsewhere. Fail hard.
+                    return TRANSCRIBE_ERR_BACKEND;
+                }
+
+                // If the GPU probe failed and AUTO picked nothing so far, CPU
+                // becomes the primary.
+                if (out.primary == nullptr) {
+                    out.primary      = cpu_be;
+                    out.primary_kind = BackendKind::Cpu;
+                }
+                out.scheduler_list.push_back(cpu_be);
+                return TRANSCRIBE_OK;
+            }
     }
 
     // Unknown enumerator: reject loudly so callers catch ABI drift
     // during development. Do not let "everything else" silently map
     // to AUTO — that hides bugs.
-    log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                 "%s: invalid transcribe_backend_request value %d",
-                 error_tag, requested_raw);
+    log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: invalid transcribe_backend_request value %d", error_tag, requested_raw);
     return TRANSCRIBE_ERR_INVALID_ARG;
 }
 
-transcribe_status stream_tensor_data(const std::string &   path,
-                                     const gguf_context *  gguf_data,
-                                     ggml_context *        ctx_meta,
-                                     const char *          error_tag)
-{
+transcribe_status stream_tensor_data(const std::string &  path,
+                                     const gguf_context * gguf_data,
+                                     ggml_context *       ctx_meta,
+                                     const char *         error_tag) {
     // std::ifstream rather than going through gguf's loader a third
     // time: ifstream::seekg takes a streamoff (signed 64-bit on every
     // platform we target), so multi-GB tensor offsets work without
     // #ifdef'ing fseeko vs _fseeki64.
     std::ifstream fin(path, std::ios::binary);
     if (!fin) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "%s: failed to reopen %s for tensor data",
-                     error_tag, path.c_str());
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: failed to reopen %s for tensor data", error_tag, path.c_str());
         return TRANSCRIBE_ERR_GGUF;
     }
 
-    const size_t data_offset = gguf_get_data_offset(gguf_data);
+    const size_t         data_offset = gguf_get_data_offset(gguf_data);
     std::vector<uint8_t> staging;
 
-    for (ggml_tensor * t = ggml_get_first_tensor(ctx_meta);
-         t != nullptr;
-         t = ggml_get_next_tensor(ctx_meta, t))
-    {
+    for (ggml_tensor * t = ggml_get_first_tensor(ctx_meta); t != nullptr; t = ggml_get_next_tensor(ctx_meta, t)) {
         const int64_t idx = gguf_find_tensor(gguf_data, t->name);
         if (idx < 0) {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "%s: tensor \"%s\" not in gguf data",
-                         error_tag, t->name);
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: tensor \"%s\" not in gguf data", error_tag, t->name);
             return TRANSCRIBE_ERR_GGUF;
         }
         const size_t toffset = gguf_get_tensor_offset(gguf_data, idx);
         const size_t nbytes  = ggml_nbytes(t);
 
         const std::streamoff abs_offset =
-            static_cast<std::streamoff>(data_offset) +
-            static_cast<std::streamoff>(toffset);
+            static_cast<std::streamoff>(data_offset) + static_cast<std::streamoff>(toffset);
         fin.seekg(abs_offset);
         if (!fin) {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "%s: seek failed for tensor \"%s\"",
-                         error_tag, t->name);
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: seek failed for tensor \"%s\"", error_tag, t->name);
             return TRANSCRIBE_ERR_GGUF;
         }
 
         if (staging.size() < nbytes) {
             staging.resize(nbytes);
         }
-        fin.read(reinterpret_cast<char *>(staging.data()),
-                 static_cast<std::streamsize>(nbytes));
+        fin.read(reinterpret_cast<char *>(staging.data()), static_cast<std::streamsize>(nbytes));
         if (!fin) {
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "%s: short read for tensor \"%s\" (%zu bytes)",
-                         error_tag, t->name, nbytes);
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: short read for tensor \"%s\" (%zu bytes)", error_tag, t->name,
+                    nbytes);
             return TRANSCRIBE_ERR_GGUF;
         }
 
@@ -419,36 +399,41 @@ transcribe_status stream_tensor_data(const std::string &   path,
     return TRANSCRIBE_OK;
 }
 
-transcribe_status promote_conv_pw_f16_to_f32_on_cpu(
-    const BackendPlan &                plan,
-    const std::vector<ConvPwF32Slot> & slots,
-    const char *                       error_tag,
-    ggml_context **                    out_ctx,
-    ggml_backend_buffer_t *            out_buffer)
-{
+transcribe_status promote_conv_pw_f16_to_f32_on_cpu(const BackendPlan &                plan,
+                                                    const std::vector<ConvPwF32Slot> & slots,
+                                                    const char *                       error_tag,
+                                                    ggml_context **                    out_ctx,
+                                                    ggml_backend_buffer_t *            out_buffer) {
     // Key off the classified primary kind, not off ACCEL/CPU ordering in
     // the backend list, so a strict-CPU request reliably triggers promotion
     // even when an ACCEL backend sorts ahead of CPU.
-    if (plan.primary_kind != BackendKind::Cpu) return TRANSCRIBE_OK;
-    if (plan.primary == nullptr)               return TRANSCRIBE_OK;
+    if (plan.primary_kind != BackendKind::Cpu) {
+        return TRANSCRIBE_OK;
+    }
+    if (plan.primary == nullptr) {
+        return TRANSCRIBE_OK;
+    }
 
-    if (slots.empty()) return TRANSCRIBE_OK;
+    if (slots.empty()) {
+        return TRANSCRIBE_OK;
+    }
 
     // New ctx sized for exactly the replacement tensors plus a small
     // slack. no_alloc=true — ggml_backend_alloc_ctx_tensors will
     // allocate the storage buffer separately below.
-    const size_t ctx_size = slots.size() * ggml_tensor_overhead() + 256;
-    ggml_init_params params = {ctx_size, nullptr, true};
-    ggml_context * ctx = ggml_init(params);
-    if (ctx == nullptr) return TRANSCRIBE_ERR_BACKEND;
+    const size_t     ctx_size = slots.size() * ggml_tensor_overhead() + 256;
+    ggml_init_params params   = { ctx_size, nullptr, true };
+    ggml_context *   ctx      = ggml_init(params);
+    if (ctx == nullptr) {
+        return TRANSCRIBE_ERR_BACKEND;
+    }
 
     // Allocate F32 replacements in the new ctx, matching each source's
     // full n-d shape. Names are copied so debug dumps still find them.
     std::vector<ggml_tensor *> replacements;
     replacements.reserve(slots.size());
     for (const auto & s : slots) {
-        ggml_tensor * r = ggml_new_tensor(
-            ctx, GGML_TYPE_F32, ggml_n_dims(s.src), s.src->ne);
+        ggml_tensor * r = ggml_new_tensor(ctx, GGML_TYPE_F32, ggml_n_dims(s.src), s.src->ne);
         if (r == nullptr) {
             ggml_free(ctx);
             return TRANSCRIBE_ERR_BACKEND;
@@ -457,11 +442,9 @@ transcribe_status promote_conv_pw_f16_to_f32_on_cpu(
         replacements.push_back(r);
     }
 
-    ggml_backend_buffer_t buffer =
-        ggml_backend_alloc_ctx_tensors(ctx, plan.primary);
+    ggml_backend_buffer_t buffer = ggml_backend_alloc_ctx_tensors(ctx, plan.primary);
     if (buffer == nullptr) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "%s: conv_pw f32 promotion buffer alloc failed", error_tag);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: conv_pw f32 promotion buffer alloc failed", error_tag);
         ggml_free(ctx);
         return TRANSCRIBE_ERR_BACKEND;
     }
@@ -470,9 +453,7 @@ transcribe_status promote_conv_pw_f16_to_f32_on_cpu(
     // Dequantize each F16 tensor into its F32 replacement.
     const auto * f16_traits = ggml_get_type_traits(GGML_TYPE_F16);
     if (f16_traits == nullptr || f16_traits->to_float == nullptr) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_WARN,
-            "%s: no f16 to_float trait — skipping conv pw promotion",
-            error_tag);
+        log_msg(TRANSCRIBE_LOG_LEVEL_WARN, "%s: no f16 to_float trait — skipping conv pw promotion", error_tag);
         // Partial success: the ctx + buffer are already allocated but
         // unused. Free them so the caller's outparams stay nullptr,
         // matching the "do nothing" contract.
@@ -484,13 +465,15 @@ transcribe_status promote_conv_pw_f16_to_f32_on_cpu(
     std::vector<uint8_t> f16_staging;
     std::vector<float>   f32_staging;
     for (size_t i = 0; i < slots.size(); ++i) {
-        ggml_tensor * src = slots[i].src;
-        ggml_tensor * dst = replacements[i];
-        const int64_t n_elem = ggml_nelements(src);
-        const size_t f16_bytes = ggml_nbytes(src);
-        const size_t f32_bytes = static_cast<size_t>(n_elem) * sizeof(float);
-
-        if (f16_staging.size() < f16_bytes) f16_staging.resize(f16_bytes);
+        ggml_tensor * src       = slots[i].src;
+        ggml_tensor * dst       = replacements[i];
+        const int64_t n_elem    = ggml_nelements(src);
+        const size_t  f16_bytes = ggml_nbytes(src);
+        const size_t  f32_bytes = static_cast<size_t>(n_elem) * sizeof(float);
+
+        if (f16_staging.size() < f16_bytes) {
+            f16_staging.resize(f16_bytes);
+        }
         if (f32_staging.size() < static_cast<size_t>(n_elem)) {
             f32_staging.resize(n_elem);
         }
@@ -506,19 +489,18 @@ transcribe_status promote_conv_pw_f16_to_f32_on_cpu(
     *out_buffer = buffer;
 
     log_msg(TRANSCRIBE_LOG_LEVEL_INFO,
-        "%s: promoted %zu conv pointwise weights from F16 → F32 "
-        "for CPU backend", error_tag, slots.size());
+            "%s: promoted %zu conv pointwise weights from F16 → F32 "
+            "for CPU backend",
+            error_tag, slots.size());
     return TRANSCRIBE_OK;
 }
 
-ReadF32Result read_f32_tensor_checked(
-    gguf_context *        gguf_ctx,
-    const std::string &   gguf_path,
-    const char *          tensor_name,
-    size_t                expected_elems,
-    const char *          error_tag,
-    std::vector<float> &  out)
-{
+ReadF32Result read_f32_tensor_checked(gguf_context *       gguf_ctx,
+                                      const std::string &  gguf_path,
+                                      const char *         tensor_name,
+                                      size_t               expected_elems,
+                                      const char *         error_tag,
+                                      std::vector<float> & out) {
     // Clear on entry so stale data cannot leak on any return path.
     out.clear();
 
@@ -530,23 +512,19 @@ ReadF32Result read_f32_tensor_checked(
     // Validate type is F32.
     const enum ggml_type ttype = gguf_get_tensor_type(gguf_ctx, idx);
     if (ttype != GGML_TYPE_F32) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "%s: tensor \"%s\" has type %d, expected F32 (%d)",
-                     error_tag, tensor_name,
-                     static_cast<int>(ttype),
-                     static_cast<int>(GGML_TYPE_F32));
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: tensor \"%s\" has type %d, expected F32 (%d)", error_tag, tensor_name,
+                static_cast<int>(ttype), static_cast<int>(GGML_TYPE_F32));
         return ReadF32Result::BadType;
     }
 
-    const size_t nbytes = static_cast<size_t>(
-        gguf_get_tensor_size(gguf_ctx, idx));
+    const size_t nbytes = static_cast<size_t>(gguf_get_tensor_size(gguf_ctx, idx));
 
     // Validate alignment: byte count must be a multiple of sizeof(float).
     if (nbytes == 0 || (nbytes % sizeof(float)) != 0) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "%s: tensor \"%s\" has %zu bytes "
-                     "(not a multiple of %zu)",
-                     error_tag, tensor_name, nbytes, sizeof(float));
+                "%s: tensor \"%s\" has %zu bytes "
+                "(not a multiple of %zu)",
+                error_tag, tensor_name, nbytes, sizeof(float));
         return ReadF32Result::BadSize;
     }
 
@@ -554,9 +532,8 @@ ReadF32Result read_f32_tensor_checked(
 
     // Validate expected element count when the caller knows the shape.
     if (expected_elems > 0 && n_elems != expected_elems) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "%s: tensor \"%s\" has %zu elements, expected %zu",
-                     error_tag, tensor_name, n_elems, expected_elems);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: tensor \"%s\" has %zu elements, expected %zu", error_tag, tensor_name,
+                n_elems, expected_elems);
         return ReadF32Result::BadSize;
     }
 
@@ -570,33 +547,26 @@ ReadF32Result read_f32_tensor_checked(
 
     std::ifstream fin(gguf_path, std::ios::binary);
     if (!fin) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "%s: failed to open %s for tensor \"%s\"",
-                     error_tag, gguf_path.c_str(), tensor_name);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: failed to open %s for tensor \"%s\"", error_tag, gguf_path.c_str(),
+                tensor_name);
         return ReadF32Result::ReadErr;
     }
 
-    const std::streamoff abs_offset =
-        static_cast<std::streamoff>(data_off) +
-        static_cast<std::streamoff>(t_off);
+    const std::streamoff abs_offset = static_cast<std::streamoff>(data_off) + static_cast<std::streamoff>(t_off);
     fin.seekg(abs_offset);
     if (!fin) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "%s: seek failed for tensor \"%s\"",
-                     error_tag, tensor_name);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: seek failed for tensor \"%s\"", error_tag, tensor_name);
         return ReadF32Result::ReadErr;
     }
 
     out.resize(n_elems);
-    fin.read(reinterpret_cast<char *>(out.data()),
-             static_cast<std::streamsize>(nbytes));
+    fin.read(reinterpret_cast<char *>(out.data()), static_cast<std::streamsize>(nbytes));
 
     if (!fin || static_cast<size_t>(fin.gcount()) != nbytes) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "%s: short read for tensor \"%s\" "
-                     "(got %zu of %zu bytes)",
-                     error_tag, tensor_name,
-                     static_cast<size_t>(fin.gcount()), nbytes);
+                "%s: short read for tensor \"%s\" "
+                "(got %zu of %zu bytes)",
+                error_tag, tensor_name, static_cast<size_t>(fin.gcount()), nbytes);
         out.clear();
         return ReadF32Result::ReadErr;
     }
@@ -604,4 +574,4 @@ ReadF32Result read_f32_tensor_checked(
     return ReadF32Result::Ok;
 }
 
-} // namespace transcribe::load_common
+}  // namespace transcribe::load_common
diff --git a/src/transcribe-load-common.h b/src/transcribe-load-common.h
index c6fdd4ce..1d548fef 100644
--- a/src/transcribe-load-common.h
+++ b/src/transcribe-load-common.h
@@ -16,8 +16,8 @@
 
 #pragma once
 
-#include "transcribe.h"
 #include "transcribe-backend.h"
+#include "transcribe.h"
 
 #include <string>
 #include <vector>
@@ -95,10 +95,10 @@ transcribe_status init_backends(transcribe_backend_request requested,
 // I/O or tensor-not-found failure. On failure ctx_meta's tensors
 // may be partially populated; the caller should discard the
 // whole model state on error.
-transcribe_status stream_tensor_data(const std::string &   path,
-                                     const gguf_context *  gguf_data,
-                                     ggml_context *        ctx_meta,
-                                     const char *          error_tag);
+transcribe_status stream_tensor_data(const std::string &  path,
+                                     const gguf_context * gguf_data,
+                                     ggml_context *       ctx_meta,
+                                     const char *         error_tag);
 
 // A single F16 → F32 promotion target: `dst_slot` is a pointer into a
 // family weights struct (e.g. &block.conv_pw1_w) that currently holds
@@ -134,12 +134,11 @@ struct ConvPwF32Slot {
 //     returns TRANSCRIBE_OK without modifying anything.
 //
 // error_tag: log prefix, e.g. "parakeet" or "cohere".
-transcribe_status promote_conv_pw_f16_to_f32_on_cpu(
-    const BackendPlan &                plan,
-    const std::vector<ConvPwF32Slot> & slots,
-    const char *                       error_tag,
-    ggml_context **                    out_ctx,
-    ggml_backend_buffer_t *            out_buffer);
+transcribe_status promote_conv_pw_f16_to_f32_on_cpu(const BackendPlan &                plan,
+                                                    const std::vector<ConvPwF32Slot> & slots,
+                                                    const char *                       error_tag,
+                                                    ggml_context **                    out_ctx,
+                                                    ggml_backend_buffer_t *            out_buffer);
 
 // Read a small F32 tensor from the GGUF file into a std::vector<float>.
 //
@@ -163,12 +162,11 @@ enum class ReadF32Result {
     ReadErr,  // I/O error during read
 };
 
-ReadF32Result read_f32_tensor_checked(
-    gguf_context *        gguf_ctx,
-    const std::string &   gguf_path,
-    const char *          tensor_name,
-    size_t                expected_elems,  // 0 = skip size check
-    const char *          error_tag,
-    std::vector<float> &  out);
+ReadF32Result read_f32_tensor_checked(gguf_context *       gguf_ctx,
+                                      const std::string &  gguf_path,
+                                      const char *         tensor_name,
+                                      size_t               expected_elems,  // 0 = skip size check
+                                      const char *         error_tag,
+                                      std::vector<float> & out);
 
-} // namespace transcribe::load_common
+}  // namespace transcribe::load_common
diff --git a/src/transcribe-loader.cpp b/src/transcribe-loader.cpp
index d944bdf9..6973783f 100644
--- a/src/transcribe-loader.cpp
+++ b/src/transcribe-loader.cpp
@@ -7,9 +7,8 @@
 
 #include "transcribe-loader.h"
 
-#include "transcribe-meta.h"
-
 #include "gguf.h"
+#include "transcribe-meta.h"
 
 #include <sys/stat.h>
 
@@ -26,7 +25,7 @@ Loader::~Loader() {
 
 gguf_context * Loader::release_gguf() {
     gguf_context * out = gguf_;
-    gguf_ = nullptr;
+    gguf_              = nullptr;
     return out;
 }
 
@@ -52,7 +51,7 @@ namespace {
 // doesn't (in which case the caller should hand off to
 // gguf_init_from_file unchanged).
 bool path_is_present(const char * path) {
-    struct stat st {};
+    struct stat st{};
     if (::stat(path, &st) == 0) {
         return true;
     }
@@ -66,7 +65,7 @@ bool path_is_present(const char * path) {
     return true;
 }
 
-} // namespace
+}  // namespace
 
 transcribe_status Loader::open(const char * path) {
     if (path == nullptr) {
@@ -83,7 +82,7 @@ transcribe_status Loader::open(const char * path) {
     // gguf_init_from_file skips the entire tensor-allocation block; with
     // no_alloc=true any future code path that does pass a ctx will not
     // read the data blob.
-    gguf_init_params init_params {};
+    gguf_init_params init_params{};
     init_params.no_alloc = true;
     init_params.ctx      = nullptr;
 
@@ -139,4 +138,4 @@ transcribe_status Loader::open(const char * path) {
     return TRANSCRIBE_OK;
 }
 
-} // namespace transcribe
+}  // namespace transcribe
diff --git a/src/transcribe-loader.h b/src/transcribe-loader.h
index bc4ebf70..1f18eb78 100644
--- a/src/transcribe-loader.h
+++ b/src/transcribe-loader.h
@@ -19,7 +19,7 @@ struct gguf_context;
 namespace transcribe {
 
 class Loader {
-public:
+  public:
     Loader() = default;
     ~Loader();
 
@@ -56,8 +56,10 @@ class Loader {
     // Identification fields, populated on a successful open(). The arch
     // string is required by the GGUF schema we accept; the variant string
     // is optional and may be empty for older or partial files.
-    const std::string & path()    const { return path_; }
-    const std::string & arch()    const { return arch_; }
+    const std::string & path() const { return path_; }
+
+    const std::string & arch() const { return arch_; }
+
     const std::string & variant() const { return variant_; }
 
     // All scalar-string metadata KVs read on open(), keyed by GGUF key.
@@ -75,12 +77,12 @@ class Loader {
     // gguf_free() it. The Loader is still safe to destroy.
     gguf_context * release_gguf();
 
-private:
-    std::string    path_;
-    std::string    arch_;
-    std::string    variant_;
+  private:
+    std::string                        path_;
+    std::string                        arch_;
+    std::string                        variant_;
     std::map<std::string, std::string> meta_;
-    gguf_context * gguf_ = nullptr;
+    gguf_context *                     gguf_ = nullptr;
 };
 
-} // namespace transcribe
+}  // namespace transcribe
diff --git a/src/transcribe-log.h b/src/transcribe-log.h
index ebca527e..d3e745b2 100644
--- a/src/transcribe-log.h
+++ b/src/transcribe-log.h
@@ -25,4 +25,4 @@ void log_msg(transcribe_log_level level, const char * fmt, ...)
 #endif
     ;
 
-} // namespace transcribe
+}  // namespace transcribe
diff --git a/src/transcribe-mel.cpp b/src/transcribe-mel.cpp
index 111438fb..eb60d63e 100644
--- a/src/transcribe-mel.cpp
+++ b/src/transcribe-mel.cpp
@@ -28,9 +28,9 @@
 #include "transcribe-batch-util.h"
 
 #ifdef __APPLE__
-#  include <Accelerate/Accelerate.h>
+#    include <Accelerate/Accelerate.h>
 #elif TRANSCRIBE_HAS_BLAS
-#  include <cblas.h>
+#    include <cblas.h>
 #endif
 
 #include <algorithm>
@@ -42,7 +42,7 @@
 #include <vector>
 
 #ifndef M_PI
-#  define M_PI 3.14159265358979323846
+#    define M_PI 3.14159265358979323846
 #endif
 
 namespace transcribe {
@@ -51,12 +51,13 @@ namespace {
 
 // Hardcoded NeMo numerical constants. See file-level comment.
 constexpr float kLogEps  = 5.9604644775390625e-08f;  // 2^-24
-constexpr float kNormEps = 1.0e-05f;                  // NeMo CONSTANT
+constexpr float kNormEps = 1.0e-05f;                 // NeMo CONSTANT
 
 // ---------- Slaney mel scale (matches librosa.filters.mel) ----------
 
-constexpr double kSlaneyFsp        = 200.0 / 3.0;
-constexpr double kSlaneyMinLogHz   = 1000.0;
+constexpr double kSlaneyFsp      = 200.0 / 3.0;
+constexpr double kSlaneyMinLogHz = 1000.0;
+
 // kSlaneyLogStep = log(6.4) / 27.0; not constexpr because std::log
 // isn't constexpr in C++17. Computed inline below.
 
@@ -84,10 +85,7 @@ inline double slaney_mel_to_hz(double mel) {
 //                              norm='slaney') to within ~3e-7 in
 // fp32 (verified against the ONNX-baked filterbank in
 // nemo128.onnx).
-void build_mel_filterbank_slaney(
-    int sr, int n_fft, int n_mels, double fmin, double fmax,
-    std::vector<float> & out)
-{
+void build_mel_filterbank_slaney(int sr, int n_fft, int n_mels, double fmin, double fmax, std::vector<float> & out) {
     const int n_freq = n_fft / 2 + 1;
     out.assign(static_cast<size_t>(n_mels) * n_freq, 0.0f);
 
@@ -101,13 +99,12 @@ void build_mel_filterbank_slaney(
     // Mel boundary frequencies: n_mels + 2 points spaced uniformly in mel
     // scale. The first and last bound the entire bank; the middle n_mels
     // are the centers of the triangular filters.
-    const double mel_min = slaney_hz_to_mel(fmin);
-    const double mel_max = slaney_hz_to_mel(fmax);
+    const double        mel_min = slaney_hz_to_mel(fmin);
+    const double        mel_max = slaney_hz_to_mel(fmax);
     std::vector<double> hz_freqs(n_mels + 2);
     for (int m = 0; m < n_mels + 2; ++m) {
-        const double mel = mel_min +
-            (mel_max - mel_min) * m / static_cast<double>(n_mels + 1);
-        hz_freqs[m] = slaney_mel_to_hz(mel);
+        const double mel = mel_min + (mel_max - mel_min) * m / static_cast<double>(n_mels + 1);
+        hz_freqs[m]      = slaney_mel_to_hz(mel);
     }
 
     // Triangular filters with Slaney area normalization.
@@ -122,11 +119,10 @@ void build_mel_filterbank_slaney(
     for (int m = 0; m < n_mels; ++m) {
         const double enorm = 2.0 / (hz_freqs[m + 2] - hz_freqs[m]);
         for (int k = 0; k < n_freq; ++k) {
-            const double lower = (fft_freqs[k]   - hz_freqs[m])     / fdiff[m];
-            const double upper = (hz_freqs[m + 2] - fft_freqs[k])   / fdiff[m + 1];
-            const double w     = std::max(0.0, std::min(lower, upper));
-            out[static_cast<size_t>(m) * n_freq + k] =
-                static_cast<float>(w * enorm);
+            const double lower                       = (fft_freqs[k] - hz_freqs[m]) / fdiff[m];
+            const double upper                       = (hz_freqs[m + 2] - fft_freqs[k]) / fdiff[m + 1];
+            const double w                           = std::max(0.0, std::min(lower, upper));
+            out[static_cast<size_t>(m) * n_freq + k] = static_cast<float>(w * enorm);
         }
     }
 }
@@ -135,17 +131,12 @@ void build_mel_filterbank_slaney(
 // both sides. `periodic` selects between torch.hann_window(N, periodic=
 // False) (symmetric, default — cos(2πk/(N-1))) and periodic=True
 // (Whisper — cos(2πk/N)).
-void build_hann_window_symmetric_padded(
-    int win_length, int n_fft, bool periodic, std::vector<double> & out)
-{
+void build_hann_window_symmetric_padded(int win_length, int n_fft, bool periodic, std::vector<double> & out) {
     out.assign(n_fft, 0.0);
-    const int pad_each = (n_fft - win_length) / 2;
-    const double denom = periodic
-                       ? static_cast<double>(win_length)
-                       : static_cast<double>(win_length - 1);
+    const int    pad_each = (n_fft - win_length) / 2;
+    const double denom    = periodic ? static_cast<double>(win_length) : static_cast<double>(win_length - 1);
     for (int k = 0; k < win_length; ++k) {
-        out[pad_each + k] =
-            0.5 - 0.5 * std::cos(2.0 * M_PI * k / denom);
+        out[pad_each + k] = 0.5 - 0.5 * std::cos(2.0 * M_PI * k / denom);
     }
 }
 
@@ -169,9 +160,7 @@ void build_hann_window_symmetric_padded(
 // odd factor during recursive halving (e.g. N=400 → 200 → 100 → 50 → 25
 // odd → leaf). Uses the per-frontend fp32 LUT (lut_size divisible by N
 // by construction).
-void dft_naive_f32(const float * in, int N,
-                   const float * cos_lut, const float * sin_lut, int lut_size,
-                   float * out) {
+void dft_naive_f32(const float * in, int N, const float * cos_lut, const float * sin_lut, int lut_size, float * out) {
     const int stride = lut_size / N;
     for (int k = 0; k < N; ++k) {
         float re = 0.0f;
@@ -181,7 +170,7 @@ void dft_naive_f32(const float * in, int N,
             re += in[n] * cos_lut[idx];
             im -= in[n] * sin_lut[idx];
         }
-        out[2 * k    ] = re;
+        out[2 * k]     = re;
         out[2 * k + 1] = im;
     }
 }
@@ -197,9 +186,7 @@ void dft_naive_f32(const float * in, int N,
 //           used as scratch for the even/odd split at this level.
 //   out   : 8*N floats. The top-level result lands in the first 2*N;
 //           recursion uses the remainder as intermediate output.
-void mixed_radix_fft_f32(float * in, int N,
-                         const float * cos_lut, const float * sin_lut, int lut_size,
-                         float * out) {
+void mixed_radix_fft_f32(float * in, int N, const float * cos_lut, const float * sin_lut, int lut_size, float * out) {
     if (N == 1) {
         out[0] = in[0];
         out[1] = 0.0f;
@@ -210,26 +197,30 @@ void mixed_radix_fft_f32(float * in, int N,
         return;
     }
     const int half_N = N / 2;
-    float * even = in + N;
-    for (int i = 0; i < half_N; ++i) even[i] = in[2 * i];
+    float *   even   = in + N;
+    for (int i = 0; i < half_N; ++i) {
+        even[i] = in[2 * i];
+    }
     float * even_fft = out + 2 * N;
     mixed_radix_fft_f32(even, half_N, cos_lut, sin_lut, lut_size, even_fft);
 
     float * odd = even;
-    for (int i = 0; i < half_N; ++i) odd[i] = in[2 * i + 1];
+    for (int i = 0; i < half_N; ++i) {
+        odd[i] = in[2 * i + 1];
+    }
     float * odd_fft = even_fft + N;
     mixed_radix_fft_f32(odd, half_N, cos_lut, sin_lut, lut_size, odd_fft);
 
     const int step = lut_size / N;
     for (int k = 0; k < half_N; ++k) {
-        const int idx = k * step;
-        const float w_re =  cos_lut[idx];
-        const float w_im = -sin_lut[idx];
-        const float re_odd = odd_fft[2 * k    ];
-        const float im_odd = odd_fft[2 * k + 1];
-        out[2 * k    ]            = even_fft[2 * k    ] + w_re * re_odd - w_im * im_odd;
+        const int   idx           = k * step;
+        const float w_re          = cos_lut[idx];
+        const float w_im          = -sin_lut[idx];
+        const float re_odd        = odd_fft[2 * k];
+        const float im_odd        = odd_fft[2 * k + 1];
+        out[2 * k]                = even_fft[2 * k] + w_re * re_odd - w_im * im_odd;
         out[2 * k + 1]            = even_fft[2 * k + 1] + w_re * im_odd + w_im * re_odd;
-        out[2 * (k + half_N)    ] = even_fft[2 * k    ] - w_re * re_odd + w_im * im_odd;
+        out[2 * (k + half_N)]     = even_fft[2 * k] - w_re * re_odd + w_im * im_odd;
         out[2 * (k + half_N) + 1] = even_fft[2 * k + 1] - w_re * im_odd - w_im * re_odd;
     }
 }
@@ -244,7 +235,7 @@ void fft_radix2(double * data, int n) {
         }
         j ^= bit;
         if (i < j) {
-            std::swap(data[2 * i],     data[2 * j]);
+            std::swap(data[2 * i], data[2 * j]);
             std::swap(data[2 * i + 1], data[2 * j + 1]);
         }
     }
@@ -259,26 +250,26 @@ void fft_radix2(double * data, int n) {
             double w_re = 1.0;
             double w_im = 0.0;
             for (int k = 0; k < len / 2; ++k) {
-                const int a = 2 * (i + k);
-                const int b = 2 * (i + k + len / 2);
-                const double u_re = data[a];
-                const double u_im = data[a + 1];
-                const double v_re = data[b]     * w_re - data[b + 1] * w_im;
-                const double v_im = data[b]     * w_im + data[b + 1] * w_re;
-                data[a]     = u_re + v_re;
-                data[a + 1] = u_im + v_im;
-                data[b]     = u_re - v_re;
-                data[b + 1] = u_im - v_im;
+                const int    a      = 2 * (i + k);
+                const int    b      = 2 * (i + k + len / 2);
+                const double u_re   = data[a];
+                const double u_im   = data[a + 1];
+                const double v_re   = data[b] * w_re - data[b + 1] * w_im;
+                const double v_im   = data[b] * w_im + data[b + 1] * w_re;
+                data[a]             = u_re + v_re;
+                data[a + 1]         = u_im + v_im;
+                data[b]             = u_re - v_re;
+                data[b + 1]         = u_im - v_im;
                 const double tmp_re = w_re * wlen_re - w_im * wlen_im;
                 const double tmp_im = w_re * wlen_im + w_im * wlen_re;
-                w_re = tmp_re;
-                w_im = tmp_im;
+                w_re                = tmp_re;
+                w_im                = tmp_im;
             }
         }
     }
 }
 
-} // namespace
+}  // namespace
 
 // ---------- MelFrontend ----------
 
@@ -300,26 +291,21 @@ MelFrontend::MelFrontend(const MelConfig & cfg) : cfg_(cfg) {
         }
     } else {
         const bool periodic = (cfg.window_type == "hann_periodic");
-        build_hann_window_symmetric_padded(cfg.win_length, cfg.n_fft,
-                                           periodic, window_);
+        build_hann_window_symmetric_padded(cfg.win_length, cfg.n_fft, periodic, window_);
     }
 
     // Use checkpoint-provided mel filterbank if available, else compute.
     if (!cfg.filterbank.empty()) {
         mel_fb_ = cfg.filterbank;
     } else {
-        build_mel_filterbank_slaney(
-            cfg.sample_rate, cfg.n_fft, cfg.num_mels,
-            static_cast<double>(cfg.f_min),
-            static_cast<double>(cfg.f_max),
-            mel_fb_);
+        build_mel_filterbank_slaney(cfg.sample_rate, cfg.n_fft, cfg.num_mels, static_cast<double>(cfg.f_min),
+                                    static_cast<double>(cfg.f_max), mel_fb_);
     }
 
     // Sin/cos LUT for the mixed-radix FFT. Only the non-pow2 path
     // consumes it; pow2 sizes go through fft_radix2 (Linux) or vDSP
     // (Apple), both of which carry their own twiddle factors.
-    const bool n_fft_is_pow2 =
-        ((cfg.n_fft > 0) && ((cfg.n_fft & (cfg.n_fft - 1)) == 0));
+    const bool n_fft_is_pow2 = ((cfg.n_fft > 0) && ((cfg.n_fft & (cfg.n_fft - 1)) == 0));
     if (!n_fft_is_pow2) {
         cos_lut_.resize(cfg.n_fft);
         sin_lut_.resize(cfg.n_fft);
@@ -327,8 +313,8 @@ MelFrontend::MelFrontend(const MelConfig & cfg) : cfg_(cfg) {
             // Compute in fp64 for accuracy, store as fp32 to match the
             // FFT precision. The downcast is one-time per construction.
             const double theta = 2.0 * M_PI * i / cfg.n_fft;
-            cos_lut_[i] = static_cast<float>(std::cos(theta));
-            sin_lut_[i] = static_cast<float>(std::sin(theta));
+            cos_lut_[i]        = static_cast<float>(std::cos(theta));
+            sin_lut_[i]        = static_cast<float>(std::sin(theta));
         }
     }
 }
@@ -336,50 +322,47 @@ MelFrontend::MelFrontend(const MelConfig & cfg) : cfg_(cfg) {
 int MelFrontend::n_frames_for(size_t n_samples) const {
     if (cfg_.pad_mode == "none") {
         // PyTorch center=False: n_frames = (n - win)/hop + 1.
-        if (static_cast<int>(n_samples) < cfg_.win_length) return 0;
-        return static_cast<int>(
-            (n_samples - static_cast<size_t>(cfg_.win_length)) /
-            static_cast<size_t>(cfg_.hop_length)) + 1;
+        if (static_cast<int>(n_samples) < cfg_.win_length) {
+            return 0;
+        }
+        return static_cast<int>((n_samples - static_cast<size_t>(cfg_.win_length)) /
+                                static_cast<size_t>(cfg_.hop_length)) +
+               1;
     }
     // Matches NeMo features_lens = (waveforms_lens / hop_length) + 1.
     // The +1 accounts for the centered first frame.
     return static_cast<int>(n_samples / static_cast<size_t>(cfg_.hop_length)) + 1;
 }
 
-transcribe_status MelFrontend::compute(
-    const float * pcm,
-    size_t n_samples,
-    std::vector<float> & out_mel,
-    int & out_n_mels,
-    int & out_n_frames,
-    int n_threads) const
-{
+transcribe_status MelFrontend::compute(const float *        pcm,
+                                       size_t               n_samples,
+                                       std::vector<float> & out_mel,
+                                       int &                out_n_mels,
+                                       int &                out_n_frames,
+                                       int                  n_threads) const {
     if (pcm == nullptr) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
-    const int n_fft  = cfg_.n_fft;
-    const int hop    = cfg_.hop_length;
-    const int n_mels = cfg_.num_mels;
-    const int n_freq = n_freq_;
-    const int win    = cfg_.win_length;
-    const int pad    = n_fft / 2;
+    const int  n_fft  = cfg_.n_fft;
+    const int  hop    = cfg_.hop_length;
+    const int  n_mels = cfg_.num_mels;
+    const int  n_freq = n_freq_;
+    const int  win    = cfg_.win_length;
+    const int  pad    = n_fft / 2;
     const bool no_pad = (cfg_.pad_mode == "none");
 
-    const int n_frames = no_pad
-        ? (static_cast<int>(n_samples) < win
-               ? 0
-               : static_cast<int>(
-                     (n_samples - static_cast<size_t>(win)) /
-                     static_cast<size_t>(hop)) + 1)
-        : static_cast<int>(n_samples / static_cast<size_t>(hop)) + 1;
+    const int n_frames =
+        no_pad ? (static_cast<int>(n_samples) < win ?
+                      0 :
+                      static_cast<int>((n_samples - static_cast<size_t>(win)) / static_cast<size_t>(hop)) + 1) :
+                 static_cast<int>(n_samples / static_cast<size_t>(hop)) + 1;
 
     // Per-feature normalize divides by (n_frames - 1) and the
     // reflect pad needs at least pad+1 input samples to reflect
     // without going off the end. pad_mode="none" requires at least one
     // full window in the input.
     const bool use_reflect = (!no_pad && cfg_.pad_mode != "constant");
-    if (n_frames < (no_pad ? 1 : 2) ||
-        (use_reflect && n_samples < static_cast<size_t>(pad + 1)) ||
+    if (n_frames < (no_pad ? 1 : 2) || (use_reflect && n_samples < static_cast<size_t>(pad + 1)) ||
         (no_pad && static_cast<int>(n_samples) < win)) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
@@ -403,7 +386,7 @@ transcribe_status MelFrontend::compute(
         padded_f32.resize(n_samples + 2 * static_cast<size_t>(pad));
         if (cfg_.pre_emphasis != 0.0f) {
             const float alpha = cfg_.pre_emphasis;
-            padded_f32[pad] = pcm[0];
+            padded_f32[pad]   = pcm[0];
             for (size_t i = 1; i < n_samples; ++i) {
                 padded_f32[pad + i] = pcm[i] - alpha * pcm[i - 1];
             }
@@ -422,10 +405,8 @@ transcribe_status MelFrontend::compute(
                     padded_f32[static_cast<size_t>(pad) + n_samples - 2 - i];
             }
         } else {
-            std::memset(padded_f32.data(), 0,
-                        static_cast<size_t>(pad) * sizeof(float));
-            std::memset(padded_f32.data() + pad + n_samples, 0,
-                        static_cast<size_t>(pad) * sizeof(float));
+            std::memset(padded_f32.data(), 0, static_cast<size_t>(pad) * sizeof(float));
+            std::memset(padded_f32.data() + pad + n_samples, 0, static_cast<size_t>(pad) * sizeof(float));
         }
 
         window_f32.resize(n_fft);
@@ -438,10 +419,9 @@ transcribe_status MelFrontend::compute(
         std::vector<double> emph(n_samples);
         if (cfg_.pre_emphasis != 0.0f) {
             const double alpha = static_cast<double>(cfg_.pre_emphasis);
-            emph[0] = static_cast<double>(pcm[0]);
+            emph[0]            = static_cast<double>(pcm[0]);
             for (size_t i = 1; i < n_samples; ++i) {
-                emph[i] = static_cast<double>(pcm[i]) -
-                          alpha * static_cast<double>(pcm[i - 1]);
+                emph[i] = static_cast<double>(pcm[i]) - alpha * static_cast<double>(pcm[i - 1]);
             }
         } else {
             for (size_t i = 0; i < n_samples; ++i) {
@@ -463,23 +443,14 @@ transcribe_status MelFrontend::compute(
                 for (int i = 0; i < pad; ++i) {
                     padded[i] = emph[static_cast<size_t>(pad - i)];
                 }
-                std::memcpy(
-                    padded.data() + pad,
-                    emph.data(),
-                    n_samples * sizeof(double));
+                std::memcpy(padded.data() + pad, emph.data(), n_samples * sizeof(double));
                 for (int i = 0; i < pad; ++i) {
-                    padded[static_cast<size_t>(pad) + n_samples + i] =
-                        emph[n_samples - 2 - static_cast<size_t>(i)];
+                    padded[static_cast<size_t>(pad) + n_samples + i] = emph[n_samples - 2 - static_cast<size_t>(i)];
                 }
             } else {
-                std::memset(padded.data(), 0,
-                            static_cast<size_t>(pad) * sizeof(double));
-                std::memcpy(
-                    padded.data() + pad,
-                    emph.data(),
-                    n_samples * sizeof(double));
-                std::memset(padded.data() + pad + n_samples, 0,
-                            static_cast<size_t>(pad) * sizeof(double));
+                std::memset(padded.data(), 0, static_cast<size_t>(pad) * sizeof(double));
+                std::memcpy(padded.data() + pad, emph.data(), n_samples * sizeof(double));
+                std::memset(padded.data() + pad + n_samples, 0, static_cast<size_t>(pad) * sizeof(double));
             }
         }
     }
@@ -501,11 +472,9 @@ transcribe_status MelFrontend::compute(
     // log mode (whisper_mode): per_utterance writes log10(max(x, 1e-10));
     // per_feature writes log(x + 2^-24) (natural log; base is irrelevant
     // to the per-bin mean/std normalize that follows).
-    std::vector<float> log_mel(
-        static_cast<size_t>(n_mels) * static_cast<size_t>(n_frames));
+    std::vector<float> log_mel(static_cast<size_t>(n_mels) * static_cast<size_t>(n_frames));
 
-    const bool whisper_mode =
-        (cfg_.normalize == "per_utterance" || cfg_.normalize == "global");
+    const bool whisper_mode = (cfg_.normalize == "per_utterance" || cfg_.normalize == "global");
 
     int stft_threads = n_threads;
     if (stft_threads <= 0) {
@@ -529,7 +498,9 @@ transcribe_status MelFrontend::compute(
             pool.emplace_back(worker, tid);
         }
         worker(0);
-        for (auto & th : pool) th.join();
+        for (auto & th : pool) {
+            th.join();
+        }
     };
 
     if (!n_fft_is_pow2) {
@@ -542,37 +513,35 @@ transcribe_status MelFrontend::compute(
             std::vector<float> fft_out(8 * static_cast<size_t>(n_fft), 0.0f);
             std::vector<float> power_scratch(static_cast<size_t>(n_freq));
             for (int t = tid; t < n_frames; t += stft_threads) {
-                const size_t start =
-                    static_cast<size_t>(t) * static_cast<size_t>(hop);
+                const size_t start = static_cast<size_t>(t) * static_cast<size_t>(hop);
                 for (int n = 0; n < n_fft; ++n) {
                     fft_in[n] = padded_f32[start + n] * window_f32[n];
                 }
-                mixed_radix_fft_f32(fft_in.data(), n_fft,
-                                    cos_lut_.data(), sin_lut_.data(),
-                                    static_cast<int>(cos_lut_.size()),
-                                    fft_out.data());
+                mixed_radix_fft_f32(fft_in.data(), n_fft, cos_lut_.data(), sin_lut_.data(),
+                                    static_cast<int>(cos_lut_.size()), fft_out.data());
                 for (int k = 0; k < n_freq; ++k) {
-                    const float re = fft_out[2 * k    ];
-                    const float im = fft_out[2 * k + 1];
+                    const float re   = fft_out[2 * k];
+                    const float im   = fft_out[2 * k + 1];
                     power_scratch[k] = re * re + im * im;
                 }
                 for (int m = 0; m < n_mels; ++m) {
-                    const float * fb_row =
-                        mel_fb_.data() + static_cast<size_t>(m) * n_freq;
-                    double sum = 0.0;
-                    int k = 0;
+                    const float * fb_row = mel_fb_.data() + static_cast<size_t>(m) * n_freq;
+                    double        sum    = 0.0;
+                    int           k      = 0;
                     for (; k < n_freq - 3; k += 4) {
-                        sum += static_cast<double>(fb_row[k    ]) * static_cast<double>(power_scratch[k    ])
-                             + static_cast<double>(fb_row[k + 1]) * static_cast<double>(power_scratch[k + 1])
-                             + static_cast<double>(fb_row[k + 2]) * static_cast<double>(power_scratch[k + 2])
-                             + static_cast<double>(fb_row[k + 3]) * static_cast<double>(power_scratch[k + 3]);
+                        sum += static_cast<double>(fb_row[k]) * static_cast<double>(power_scratch[k]) +
+                               static_cast<double>(fb_row[k + 1]) * static_cast<double>(power_scratch[k + 1]) +
+                               static_cast<double>(fb_row[k + 2]) * static_cast<double>(power_scratch[k + 2]) +
+                               static_cast<double>(fb_row[k + 3]) * static_cast<double>(power_scratch[k + 3]);
                     }
                     for (; k < n_freq; ++k) {
                         sum += static_cast<double>(fb_row[k]) * static_cast<double>(power_scratch[k]);
                     }
                     float result;
                     if (whisper_mode) {
-                        if (sum < 1.0e-10) sum = 1.0e-10;
+                        if (sum < 1.0e-10) {
+                            sum = 1.0e-10;
+                        }
                         result = static_cast<float>(std::log10(sum));
                     } else {
                         result = static_cast<float>(std::log(sum + static_cast<double>(kLogEps)));
@@ -586,43 +555,46 @@ transcribe_status MelFrontend::compute(
         // pow2 paths (Parakeet, Cohere): unchanged structure. FFT
         // worker writes shared power[]; post-pass does the matmul +
         // log.
-        std::vector<float> power(
-            static_cast<size_t>(n_frames) * static_cast<size_t>(n_freq));
+        std::vector<float> power(static_cast<size_t>(n_frames) * static_cast<size_t>(n_freq));
 
 #ifdef __APPLE__
         // vDSP real-input FFT (fp64, vectorized via Accelerate SIMD).
         int log2n = 0;
-        { int tmp = n_fft; while (tmp > 1) { tmp >>= 1; ++log2n; } }
+        {
+            int tmp = n_fft;
+            while (tmp > 1) {
+                tmp >>= 1;
+                ++log2n;
+            }
+        }
 
         // A single FFTSetupD is shared across threads: it stores
         // precomputed twiddle factors, not transient state. vDSP's
         // forward FFT is thread-safe given per-thread split-complex
         // buffers.
-        FFTSetupD fft_setup = vDSP_create_fftsetupD(log2n, FFT_RADIX2);
-        const size_t half_n = static_cast<size_t>(n_fft / 2);
+        FFTSetupD    fft_setup = vDSP_create_fftsetupD(log2n, FFT_RADIX2);
+        const size_t half_n    = static_cast<size_t>(n_fft / 2);
 
         auto worker = [&](int tid) {
-            std::vector<double> fft_real(half_n);
-            std::vector<double> fft_imag(half_n);
+            std::vector<double>   fft_real(half_n);
+            std::vector<double>   fft_imag(half_n);
             DSPDoubleSplitComplex split = { fft_real.data(), fft_imag.data() };
 
             for (int t = tid; t < n_frames; t += stft_threads) {
                 const size_t start = static_cast<size_t>(t) * static_cast<size_t>(hop);
                 for (size_t k = 0; k < half_n; ++k) {
-                    fft_real[k] = padded[start + 2 * k]     * window_[2 * k];
+                    fft_real[k] = padded[start + 2 * k] * window_[2 * k];
                     fft_imag[k] = padded[start + 2 * k + 1] * window_[2 * k + 1];
                 }
                 vDSP_fft_zripD(fft_setup, &split, 1, log2n, FFT_FORWARD);
                 // vDSP output is 2x the standard DFT, so power is 4x.
                 // realp[0]=DC*2, imagp[0]=Nyquist*2, otherwise complex
                 // pairs in (realp[k], imagp[k]).
-                float * pwr_row =
-                    power.data() + static_cast<size_t>(t) * n_freq;
+                float * pwr_row    = power.data() + static_cast<size_t>(t) * n_freq;
                 pwr_row[0]         = static_cast<float>(fft_real[0] * fft_real[0] * 0.25);
                 pwr_row[n_fft / 2] = static_cast<float>(fft_imag[0] * fft_imag[0] * 0.25);
                 for (size_t k = 1; k < half_n; ++k) {
-                    pwr_row[k] = static_cast<float>(
-                        (fft_real[k] * fft_real[k] + fft_imag[k] * fft_imag[k]) * 0.25);
+                    pwr_row[k] = static_cast<float>((fft_real[k] * fft_real[k] + fft_imag[k] * fft_imag[k]) * 0.25);
                 }
             }
         };
@@ -635,17 +607,15 @@ transcribe_status MelFrontend::compute(
             for (int t = tid; t < n_frames; t += stft_threads) {
                 const size_t start = static_cast<size_t>(t) * static_cast<size_t>(hop);
                 for (int k = 0; k < n_fft; ++k) {
-                    frame[2 * static_cast<size_t>(k)]     =
-                        padded[start + static_cast<size_t>(k)] * window_[k];
+                    frame[2 * static_cast<size_t>(k)]     = padded[start + static_cast<size_t>(k)] * window_[k];
                     frame[2 * static_cast<size_t>(k) + 1] = 0.0;
                 }
                 fft_radix2(frame.data(), n_fft);
-                float * pwr_row =
-                    power.data() + static_cast<size_t>(t) * n_freq;
+                float * pwr_row = power.data() + static_cast<size_t>(t) * n_freq;
                 for (int k = 0; k < n_freq; ++k) {
                     const double re = frame[2 * static_cast<size_t>(k)];
                     const double im = frame[2 * static_cast<size_t>(k) + 1];
-                    pwr_row[k] = static_cast<float>(re * re + im * im);
+                    pwr_row[k]      = static_cast<float>(re * re + im * im);
                 }
             }
         };
@@ -655,17 +625,16 @@ transcribe_status MelFrontend::compute(
         // pow2 post-pass matmul + log → log_mel.
 #if defined(__APPLE__) || TRANSCRIBE_HAS_BLAS
         // C = A @ B^T  where A=[n_mels, n_freq], B=[n_frames, n_freq].
-        cblas_sgemm(CblasRowMajor, CblasNoTrans, CblasTrans,
-                    n_mels, n_frames, n_freq,
-                    1.0f, mel_fb_.data(), n_freq,
-                    power.data(), n_freq,
-                    0.0f, log_mel.data(), n_frames);
+        cblas_sgemm(CblasRowMajor, CblasNoTrans, CblasTrans, n_mels, n_frames, n_freq, 1.0f, mel_fb_.data(), n_freq,
+                    power.data(), n_freq, 0.0f, log_mel.data(), n_frames);
         {
             const size_t total = static_cast<size_t>(n_mels) * static_cast<size_t>(n_frames);
             if (whisper_mode) {
                 for (size_t i = 0; i < total; ++i) {
                     double v = static_cast<double>(log_mel[i]);
-                    if (v < 1.0e-10) v = 1.0e-10;
+                    if (v < 1.0e-10) {
+                        v = 1.0e-10;
+                    }
                     log_mel[i] = static_cast<float>(std::log10(v));
                 }
             } else if (cfg_.log_clamp_min > 0.0f) {
@@ -676,7 +645,9 @@ transcribe_status MelFrontend::compute(
                 const float clamp = cfg_.log_clamp_min;
                 for (size_t i = 0; i < total; ++i) {
                     float v = log_mel[i];
-                    if (v < clamp) v = clamp;
+                    if (v < clamp) {
+                        v = clamp;
+                    }
                     log_mel[i] = std::log(v);
                 }
             } else {
@@ -690,26 +661,29 @@ transcribe_status MelFrontend::compute(
         for (int t = 0; t < n_frames; ++t) {
             const float * pwr = power.data() + static_cast<size_t>(t) * n_freq;
             for (int m = 0; m < n_mels; ++m) {
-                const float * fb_row =
-                    mel_fb_.data() + static_cast<size_t>(m) * n_freq;
-                double sum = 0.0;
-                int k = 0;
+                const float * fb_row = mel_fb_.data() + static_cast<size_t>(m) * n_freq;
+                double        sum    = 0.0;
+                int           k      = 0;
                 for (; k < n_freq - 3; k += 4) {
-                    sum += static_cast<double>(fb_row[k    ]) * static_cast<double>(pwr[k    ])
-                         + static_cast<double>(fb_row[k + 1]) * static_cast<double>(pwr[k + 1])
-                         + static_cast<double>(fb_row[k + 2]) * static_cast<double>(pwr[k + 2])
-                         + static_cast<double>(fb_row[k + 3]) * static_cast<double>(pwr[k + 3]);
+                    sum += static_cast<double>(fb_row[k]) * static_cast<double>(pwr[k]) +
+                           static_cast<double>(fb_row[k + 1]) * static_cast<double>(pwr[k + 1]) +
+                           static_cast<double>(fb_row[k + 2]) * static_cast<double>(pwr[k + 2]) +
+                           static_cast<double>(fb_row[k + 3]) * static_cast<double>(pwr[k + 3]);
                 }
                 for (; k < n_freq; ++k) {
                     sum += static_cast<double>(fb_row[k]) * static_cast<double>(pwr[k]);
                 }
                 float result;
                 if (whisper_mode) {
-                    if (sum < 1.0e-10) sum = 1.0e-10;
+                    if (sum < 1.0e-10) {
+                        sum = 1.0e-10;
+                    }
                     result = static_cast<float>(std::log10(sum));
                 } else if (cfg_.log_clamp_min > 0.0f) {
                     const double clamp = static_cast<double>(cfg_.log_clamp_min);
-                    if (sum < clamp) sum = clamp;
+                    if (sum < clamp) {
+                        sum = clamp;
+                    }
                     result = static_cast<float>(std::log(sum));
                 } else {
                     result = static_cast<float>(std::log(sum + static_cast<double>(kLogEps)));
@@ -738,7 +712,7 @@ transcribe_status MelFrontend::compute(
     // sees a real log-mel value there and the drift dominates the early
     // pre_encode output (max_abs ~13 on that single frame).
     if (cfg_.normalize == "none") {
-        out_mel = std::move(log_mel);
+        out_mel      = std::move(log_mel);
         out_n_mels   = n_mels;
         out_n_frames = n_frames;
         // pad_mode="none" emits exactly (n - win)/hop + 1 frames with no
@@ -746,11 +720,9 @@ transcribe_status MelFrontend::compute(
         // legitimate final frame). NeMo-style reflect/constant padding
         // needs the mask — see the trailing-frame rationale above.
         if (!no_pad) {
-            const int valid = static_cast<int>(
-                n_samples / static_cast<size_t>(cfg_.hop_length));
+            const int valid = static_cast<int>(n_samples / static_cast<size_t>(cfg_.hop_length));
             for (int m = 0; m < n_mels; ++m) {
-                float * row =
-                    out_mel.data() + static_cast<size_t>(m) * n_frames;
+                float * row = out_mel.data() + static_cast<size_t>(m) * n_frames;
                 for (int t = valid; t < n_frames; ++t) {
                     row[t] = 0.0f;
                 }
@@ -765,28 +737,31 @@ transcribe_status MelFrontend::compute(
     // center-pad STFT frame (output has n_samples / hop_length frames).
     if (cfg_.normalize == "per_utterance") {
         const int n_out = n_frames - 1;
-        if (n_out <= 0) return TRANSCRIBE_ERR_INVALID_ARG;
+        if (n_out <= 0) {
+            return TRANSCRIBE_ERR_INVALID_ARG;
+        }
 
         double global_max = -std::numeric_limits<double>::infinity();
         for (int m = 0; m < n_mels; ++m) {
-            const float * src =
-                log_mel.data() + static_cast<size_t>(m) * n_frames;
+            const float * src = log_mel.data() + static_cast<size_t>(m) * n_frames;
             for (int t = 0; t < n_out; ++t) {
                 const double v = static_cast<double>(src[t]);
-                if (v > global_max) global_max = v;
+                if (v > global_max) {
+                    global_max = v;
+                }
             }
         }
         const double floor_val = global_max - 8.0;
 
-        out_mel.resize(
-            static_cast<size_t>(n_mels) * static_cast<size_t>(n_out));
+        out_mel.resize(static_cast<size_t>(n_mels) * static_cast<size_t>(n_out));
         for (int m = 0; m < n_mels; ++m) {
-            const float * src =
-                log_mel.data() + static_cast<size_t>(m) * n_frames;
-            float * dst = out_mel.data() + static_cast<size_t>(m) * n_out;
+            const float * src = log_mel.data() + static_cast<size_t>(m) * n_frames;
+            float *       dst = out_mel.data() + static_cast<size_t>(m) * n_out;
             for (int t = 0; t < n_out; ++t) {
                 double v = static_cast<double>(src[t]);
-                if (v < floor_val) v = floor_val;
+                if (v < floor_val) {
+                    v = floor_val;
+                }
                 dst[t] = static_cast<float>((v + 4.0) / 4.0);
             }
         }
@@ -802,17 +777,20 @@ transcribe_status MelFrontend::compute(
     // streaming-safe. Drops the trailing center-pad frame.
     if (cfg_.normalize == "global") {
         const int n_out = n_frames - 1;
-        if (n_out <= 0) return TRANSCRIBE_ERR_INVALID_ARG;
-        const double floor_val =
-            static_cast<double>(cfg_.global_log_mel_max) - 8.0;
+        if (n_out <= 0) {
+            return TRANSCRIBE_ERR_INVALID_ARG;
+        }
+        const double floor_val = static_cast<double>(cfg_.global_log_mel_max) - 8.0;
 
         out_mel.resize(static_cast<size_t>(n_mels) * static_cast<size_t>(n_out));
         for (int m = 0; m < n_mels; ++m) {
             const float * src = log_mel.data() + static_cast<size_t>(m) * n_frames;
-            float * dst = out_mel.data() + static_cast<size_t>(m) * n_out;
+            float *       dst = out_mel.data() + static_cast<size_t>(m) * n_out;
             for (int t = 0; t < n_out; ++t) {
                 double v = static_cast<double>(src[t]);
-                if (v < floor_val) v = floor_val;
+                if (v < floor_val) {
+                    v = floor_val;
+                }
                 dst[t] = static_cast<float>((v + 4.0) / 4.0);
             }
         }
@@ -843,12 +821,10 @@ transcribe_status MelFrontend::compute(
     const bool mask_last = (cfg_.pad_mode == "constant");
     const int  n_norm    = mask_last ? (n_frames - 1) : n_frames;
 
-    out_mel.resize(
-        static_cast<size_t>(n_mels) * static_cast<size_t>(n_frames));
+    out_mel.resize(static_cast<size_t>(n_mels) * static_cast<size_t>(n_frames));
     for (int m = 0; m < n_mels; ++m) {
-        const float * src =
-            log_mel.data() + static_cast<size_t>(m) * n_frames;
-        float * dst = out_mel.data() + static_cast<size_t>(m) * n_frames;
+        const float * src = log_mel.data() + static_cast<size_t>(m) * n_frames;
+        float *       dst = out_mel.data() + static_cast<size_t>(m) * n_frames;
 
         double sum = 0.0;
         for (int t = 0; t < n_norm; ++t) {
@@ -866,8 +842,7 @@ transcribe_status MelFrontend::compute(
         const double inv    = 1.0 / (stddev + static_cast<double>(kNormEps));
 
         for (int t = 0; t < n_norm; ++t) {
-            dst[t] = static_cast<float>(
-                (static_cast<double>(src[t]) - mean) * inv);
+            dst[t] = static_cast<float>((static_cast<double>(src[t]) - mean) * inv);
         }
 
         // Zero the last frame when it's a padding artifact.
@@ -881,4 +856,4 @@ transcribe_status MelFrontend::compute(
     return TRANSCRIBE_OK;
 }
 
-} // namespace transcribe
+}  // namespace transcribe
diff --git a/src/transcribe-mel.h b/src/transcribe-mel.h
index d310eabb..9d2a19c7 100644
--- a/src/transcribe-mel.h
+++ b/src/transcribe-mel.h
@@ -33,14 +33,14 @@ namespace transcribe {
 // nemo128.onnx). Constructing a default-initialized MelConfig and
 // calling MelFrontend(cfg) gives a working extractor for v2 / v3.
 struct MelConfig {
-    int   sample_rate    = 16000;
-    int   num_mels       = 128;
-    int   n_fft          = 512;
-    int   win_length     = 400;
-    int   hop_length     = 160;
-    float pre_emphasis   = 0.97f;     // 0.0 disables
-    float f_min          = 0.0f;
-    float f_max          = 8000.0f;
+    int   sample_rate  = 16000;
+    int   num_mels     = 128;
+    int   n_fft        = 512;
+    int   win_length   = 400;
+    int   hop_length   = 160;
+    float pre_emphasis = 0.97f;  // 0.0 disables
+    float f_min        = 0.0f;
+    float f_max        = 8000.0f;
 
     // STFT input padding mode:
     //   "reflect"  — symmetric reflect-pad by n_fft/2 on both sides
@@ -104,7 +104,7 @@ struct MelConfig {
 // number of times. Thread-safety: const after construction; multiple
 // threads may call compute() concurrently.
 class MelFrontend {
-public:
+  public:
     explicit MelFrontend(const MelConfig & cfg);
 
     // Run the full pipeline. pcm must be 16 kHz mono float32 in
@@ -124,13 +124,12 @@ class MelFrontend {
     //                              short to produce >= 2 frames
     //                              (per-feature normalize divides by
     //                              n_frames - 1, which would NaN).
-    transcribe_status compute(
-        const float * pcm,
-        size_t n_samples,
-        std::vector<float> & out_mel,
-        int & out_n_mels,
-        int & out_n_frames,
-        int n_threads = 0) const;
+    transcribe_status compute(const float *        pcm,
+                              size_t               n_samples,
+                              std::vector<float> & out_mel,
+                              int &                out_n_mels,
+                              int &                out_n_frames,
+                              int                  n_threads = 0) const;
 
     // Number of mel bins (matches MelConfig::num_mels).
     int num_mels() const { return cfg_.num_mels; }
@@ -142,16 +141,19 @@ class MelFrontend {
     // Read-only accessors for unit tests. Not part of the runtime
     // API; the goal is to validate the precomputed buffers in
     // isolation without running the full pipeline.
-    const std::vector<double> & window()     const { return window_; }
-    const std::vector<float>  & filterbank() const { return mel_fb_; }
-    const MelConfig            & config()     const { return cfg_; }
-    int                          n_freq()     const { return n_freq_; }
+    const std::vector<double> & window() const { return window_; }
 
-private:
-    MelConfig cfg_;
-    int n_freq_;                      // n_fft/2 + 1
-    std::vector<double> window_;      // [n_fft], periodic hann zero-padded
-    std::vector<float>  mel_fb_;      // [num_mels * n_freq] row-major, Slaney
+    const std::vector<float> & filterbank() const { return mel_fb_; }
+
+    const MelConfig & config() const { return cfg_; }
+
+    int n_freq() const { return n_freq_; }
+
+  private:
+    MelConfig           cfg_;
+    int                 n_freq_;  // n_fft/2 + 1
+    std::vector<double> window_;  // [n_fft], periodic hann zero-padded
+    std::vector<float>  mel_fb_;  // [num_mels * n_freq] row-major, Slaney
 
     // sin/cos LUT for the mixed-radix FFT. Sized to n_fft so that every
     // recursion-level N (n_fft, n_fft/2, n_fft/4, ..., odd leaf) divides
@@ -164,4 +166,4 @@ class MelFrontend {
     std::vector<float> sin_lut_;
 };
 
-} // namespace transcribe
+}  // namespace transcribe
diff --git a/src/transcribe-meta.cpp b/src/transcribe-meta.cpp
index 5eaf110c..a5ff5aa3 100644
--- a/src/transcribe-meta.cpp
+++ b/src/transcribe-meta.cpp
@@ -10,10 +10,9 @@
 
 #include "transcribe-meta.h"
 
-#include "transcribe-model.h"
-#include "transcribe-log.h"
-
 #include "gguf.h"
+#include "transcribe-log.h"
+#include "transcribe-model.h"
 
 #include <cstring>
 #include <utility>
@@ -24,9 +23,7 @@ namespace transcribe {
 // Low-level scalar / string / string-array readers
 // ---------------------------------------------------------------------------
 
-KvResult read_string_kv(const gguf_context * ctx, const char * key,
-                        std::string & out)
-{
+KvResult read_string_kv(const gguf_context * ctx, const char * key, std::string & out) {
     const int64_t key_id = gguf_find_key(ctx, key);
     if (key_id < 0) {
         return KvResult::Absent;
@@ -58,9 +55,7 @@ KvResult read_bool_kv(const gguf_context * ctx, const char * key, bool & out) {
     return KvResult::Ok;
 }
 
-KvResult read_uint32_kv(const gguf_context * ctx, const char * key,
-                        uint32_t & out)
-{
+KvResult read_uint32_kv(const gguf_context * ctx, const char * key, uint32_t & out) {
     const int64_t key_id = gguf_find_key(ctx, key);
     if (key_id < 0) {
         return KvResult::Absent;
@@ -72,9 +67,7 @@ KvResult read_uint32_kv(const gguf_context * ctx, const char * key,
     return KvResult::Ok;
 }
 
-KvResult read_int32_kv(const gguf_context * ctx, const char * key,
-                       int32_t & out)
-{
+KvResult read_int32_kv(const gguf_context * ctx, const char * key, int32_t & out) {
     const int64_t key_id = gguf_find_key(ctx, key);
     if (key_id < 0) {
         return KvResult::Absent;
@@ -86,9 +79,7 @@ KvResult read_int32_kv(const gguf_context * ctx, const char * key,
     return KvResult::Ok;
 }
 
-KvResult read_float32_kv(const gguf_context * ctx, const char * key,
-                         float & out)
-{
+KvResult read_float32_kv(const gguf_context * ctx, const char * key, float & out) {
     const int64_t key_id = gguf_find_key(ctx, key);
     if (key_id < 0) {
         return KvResult::Absent;
@@ -100,9 +91,7 @@ KvResult read_float32_kv(const gguf_context * ctx, const char * key,
     return KvResult::Ok;
 }
 
-KvResult read_token_id_kv(const gguf_context * ctx, const char * key,
-                          int & out)
-{
+KvResult read_token_id_kv(const gguf_context * ctx, const char * key, int & out) {
     const int64_t key_id = gguf_find_key(ctx, key);
     if (key_id < 0) {
         return KvResult::Absent;
@@ -121,9 +110,7 @@ KvResult read_token_id_kv(const gguf_context * ctx, const char * key,
     return KvResult::BadType;
 }
 
-KvResult read_string_array_kv(const gguf_context * ctx, const char * key,
-                              std::vector<std::string> & out)
-{
+KvResult read_string_array_kv(const gguf_context * ctx, const char * key, std::vector<std::string> & out) {
     const int64_t key_id = gguf_find_key(ctx, key);
     if (key_id < 0) {
         return KvResult::Absent;
@@ -135,7 +122,7 @@ KvResult read_string_array_kv(const gguf_context * ctx, const char * key,
         return KvResult::BadType;
     }
 
-    const size_t n = gguf_get_arr_n(ctx, key_id);
+    const size_t             n = gguf_get_arr_n(ctx, key_id);
     std::vector<std::string> tmp;
     tmp.reserve(n);
     for (size_t i = 0; i < n; ++i) {
@@ -151,9 +138,7 @@ KvResult read_string_array_kv(const gguf_context * ctx, const char * key,
     return KvResult::Ok;
 }
 
-KvResult read_int32_array_kv(const gguf_context * ctx, const char * key,
-                             std::vector<int32_t> & out)
-{
+KvResult read_int32_array_kv(const gguf_context * ctx, const char * key, std::vector<int32_t> & out) {
     const int64_t key_id = gguf_find_key(ctx, key);
     if (key_id < 0) {
         return KvResult::Absent;
@@ -164,7 +149,7 @@ KvResult read_int32_array_kv(const gguf_context * ctx, const char * key,
     if (gguf_get_arr_type(ctx, key_id) != GGUF_TYPE_INT32) {
         return KvResult::BadType;
     }
-    const size_t n = gguf_get_arr_n(ctx, key_id);
+    const size_t n    = gguf_get_arr_n(ctx, key_id);
     // gguf_get_arr_data returns a pointer to the contiguous flat data
     // for scalar arrays. We memcpy into the destination so the caller
     // owns its own storage and the gguf_context can be freed
@@ -190,8 +175,7 @@ KvResult read_int32_array_kv(const gguf_context * ctx, const char * key,
 transcribe_status read_required_u32_kv(const gguf_context * gguf,
                                        const char *         key,
                                        const char *         error_tag,
-                                       int32_t &            out)
-{
+                                       int32_t &            out) {
     uint32_t v = 0;
     switch (read_uint32_kv(gguf, key, v)) {
         case KvResult::Ok:
@@ -199,9 +183,7 @@ transcribe_status read_required_u32_kv(const gguf_context * gguf,
             return TRANSCRIBE_OK;
         case KvResult::Absent:
         case KvResult::BadType:
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "%s: required KV \"%s\" missing or wrong type",
-                         error_tag, key);
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: required KV \"%s\" missing or wrong type", error_tag, key);
             return TRANSCRIBE_ERR_GGUF;
     }
     return TRANSCRIBE_ERR_GGUF;
@@ -210,8 +192,7 @@ transcribe_status read_required_u32_kv(const gguf_context * gguf,
 transcribe_status read_required_f32_kv(const gguf_context * gguf,
                                        const char *         key,
                                        const char *         error_tag,
-                                       float &              out)
-{
+                                       float &              out) {
     float v = 0.0f;
     switch (read_float32_kv(gguf, key, v)) {
         case KvResult::Ok:
@@ -219,9 +200,7 @@ transcribe_status read_required_f32_kv(const gguf_context * gguf,
             return TRANSCRIBE_OK;
         case KvResult::Absent:
         case KvResult::BadType:
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "%s: required KV \"%s\" missing or wrong type",
-                         error_tag, key);
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: required KV \"%s\" missing or wrong type", error_tag, key);
             return TRANSCRIBE_ERR_GGUF;
     }
     return TRANSCRIBE_ERR_GGUF;
@@ -230,8 +209,7 @@ transcribe_status read_required_f32_kv(const gguf_context * gguf,
 transcribe_status read_required_string_kv(const gguf_context * gguf,
                                           const char *         key,
                                           const char *         error_tag,
-                                          std::string &        out)
-{
+                                          std::string &        out) {
     std::string v;
     switch (read_string_kv(gguf, key, v)) {
         case KvResult::Ok:
@@ -239,9 +217,7 @@ transcribe_status read_required_string_kv(const gguf_context * gguf,
             return TRANSCRIBE_OK;
         case KvResult::Absent:
         case KvResult::BadType:
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "%s: required KV \"%s\" missing or wrong type",
-                         error_tag, key);
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: required KV \"%s\" missing or wrong type", error_tag, key);
             return TRANSCRIBE_ERR_GGUF;
     }
     return TRANSCRIBE_ERR_GGUF;
@@ -251,8 +227,7 @@ transcribe_status read_optional_bool_kv(const gguf_context * gguf,
                                         const char *         key,
                                         const char *         error_tag,
                                         bool                 default_value,
-                                        bool &               out)
-{
+                                        bool &               out) {
     bool tmp = default_value;
     switch (read_bool_kv(gguf, key, tmp)) {
         case KvResult::Absent:
@@ -262,9 +237,7 @@ transcribe_status read_optional_bool_kv(const gguf_context * gguf,
             out = tmp;
             return TRANSCRIBE_OK;
         case KvResult::BadType:
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "%s: optional KV \"%s\" has wrong type",
-                         error_tag, key);
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: optional KV \"%s\" has wrong type", error_tag, key);
             return TRANSCRIBE_ERR_GGUF;
     }
     return TRANSCRIBE_ERR_GGUF;
@@ -274,8 +247,7 @@ transcribe_status read_optional_string_kv(const gguf_context * gguf,
                                           const char *         key,
                                           const char *         error_tag,
                                           const char *         default_value,
-                                          std::string &        out)
-{
+                                          std::string &        out) {
     std::string v;
     switch (read_string_kv(gguf, key, v)) {
         case KvResult::Absent:
@@ -285,9 +257,7 @@ transcribe_status read_optional_string_kv(const gguf_context * gguf,
             out = std::move(v);
             return TRANSCRIBE_OK;
         case KvResult::BadType:
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "%s: optional KV \"%s\" has wrong type",
-                         error_tag, key);
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: optional KV \"%s\" has wrong type", error_tag, key);
             return TRANSCRIBE_ERR_GGUF;
     }
     return TRANSCRIBE_ERR_GGUF;
@@ -297,8 +267,7 @@ transcribe_status read_optional_int32_kv(const gguf_context * gguf,
                                          const char *         key,
                                          const char *         error_tag,
                                          int32_t              default_value,
-                                         int32_t &            out)
-{
+                                         int32_t &            out) {
     int32_t tmp = default_value;
     switch (read_int32_kv(gguf, key, tmp)) {
         case KvResult::Absent:
@@ -308,9 +277,7 @@ transcribe_status read_optional_int32_kv(const gguf_context * gguf,
             out = tmp;
             return TRANSCRIBE_OK;
         case KvResult::BadType:
-            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "%s: optional KV \"%s\" has wrong type",
-                         error_tag, key);
+            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: optional KV \"%s\" has wrong type", error_tag, key);
             return TRANSCRIBE_ERR_GGUF;
     }
     return TRANSCRIBE_ERR_GGUF;
@@ -326,23 +293,21 @@ namespace {
 // the strict-now contract. Absent leaves `field` alone (so the caller
 // can pre-populate a family default), Ok updates it, BadType returns
 // TRANSCRIBE_ERR_GGUF.
-transcribe_status read_capability_bool(const gguf_context * gguf,
-                                       const char *         key,
-                                       bool &               field)
-{
+transcribe_status read_capability_bool(const gguf_context * gguf, const char * key, bool & field) {
     switch (read_bool_kv(gguf, key, field)) {
-        case KvResult::Absent:  return TRANSCRIBE_OK;
-        case KvResult::Ok:      return TRANSCRIBE_OK;
-        case KvResult::BadType: return TRANSCRIBE_ERR_GGUF;
+        case KvResult::Absent:
+            return TRANSCRIBE_OK;
+        case KvResult::Ok:
+            return TRANSCRIBE_OK;
+        case KvResult::BadType:
+            return TRANSCRIBE_ERR_GGUF;
     }
-    return TRANSCRIBE_ERR_GGUF; // unreachable; placates -Wreturn-type
+    return TRANSCRIBE_ERR_GGUF;  // unreachable; placates -Wreturn-type
 }
 
-} // namespace
+}  // namespace
 
-transcribe_status read_capability_kv(const gguf_context *      gguf,
-                                     transcribe_capabilities & caps)
-{
+transcribe_status read_capability_kv(const gguf_context * gguf, transcribe_capabilities & caps) {
     if (gguf == nullptr) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
@@ -351,31 +316,23 @@ transcribe_status read_capability_kv(const gguf_context *      gguf,
     // here: every family has a fixed, code-set ceiling and no converter
     // emits stt.capability.timestamps. A KV-driven override (which could
     // only lower the ceiling, never raise it) is a future change.
-    if (auto st = read_capability_bool(gguf, "stt.capability.translate",
-                                       caps.supports_translate);
-        st != TRANSCRIBE_OK)
-    {
+    if (auto st = read_capability_bool(gguf, "stt.capability.translate", caps.supports_translate);
+        st != TRANSCRIBE_OK) {
         return st;
     }
-    if (auto st = read_capability_bool(gguf, "stt.capability.lang_detect",
-                                       caps.supports_language_detect);
-        st != TRANSCRIBE_OK)
-    {
+    if (auto st = read_capability_bool(gguf, "stt.capability.lang_detect", caps.supports_language_detect);
+        st != TRANSCRIBE_OK) {
         return st;
     }
-    if (auto st = read_capability_bool(gguf, "stt.capability.streaming",
-                                       caps.supports_streaming);
-        st != TRANSCRIBE_OK)
-    {
+    if (auto st = read_capability_bool(gguf, "stt.capability.streaming", caps.supports_streaming);
+        st != TRANSCRIBE_OK) {
         return st;
     }
 
     return TRANSCRIBE_OK;
 }
 
-transcribe_status read_languages_kv(const gguf_context * gguf,
-                                    transcribe_model &   model)
-{
+transcribe_status read_languages_kv(const gguf_context * gguf, transcribe_model & model) {
     if (gguf == nullptr) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
@@ -423,4 +380,4 @@ transcribe_status read_languages_kv(const gguf_context * gguf,
     return TRANSCRIBE_OK;
 }
 
-} // namespace transcribe
+}  // namespace transcribe
diff --git a/src/transcribe-meta.h b/src/transcribe-meta.h
index d8d1e589..4d490db8 100644
--- a/src/transcribe-meta.h
+++ b/src/transcribe-meta.h
@@ -31,10 +31,10 @@ namespace transcribe {
 // Tri-state result for a single GGUF KV read. Consumers must handle
 // BadType explicitly rather than fall back silently.
 enum class KvResult {
-    Absent,    // Key not present in the gguf.
-    Ok,        // Key present, type matches expectation, value extracted.
-    BadType,   // Key present but the GGUF type does not match. Always a
-               // converter bug; callers should surface as TRANSCRIBE_ERR_GGUF.
+    Absent,   // Key not present in the gguf.
+    Ok,       // Key present, type matches expectation, value extracted.
+    BadType,  // Key present but the GGUF type does not match. Always a
+              // converter bug; callers should surface as TRANSCRIBE_ERR_GGUF.
 };
 
 // ---------------------------------------------------------------------------
@@ -46,42 +46,34 @@ enum class KvResult {
 // safely pre-populate a default and rely on the read leaving it alone
 // when the key is missing.
 
-KvResult read_string_kv(const gguf_context * ctx, const char * key,
-                        std::string & out);
+KvResult read_string_kv(const gguf_context * ctx, const char * key, std::string & out);
 
-KvResult read_bool_kv  (const gguf_context * ctx, const char * key,
-                        bool & out);
+KvResult read_bool_kv(const gguf_context * ctx, const char * key, bool & out);
 
-KvResult read_uint32_kv(const gguf_context * ctx, const char * key,
-                        uint32_t & out);
+KvResult read_uint32_kv(const gguf_context * ctx, const char * key, uint32_t & out);
 
-KvResult read_int32_kv (const gguf_context * ctx, const char * key,
-                        int32_t & out);
+KvResult read_int32_kv(const gguf_context * ctx, const char * key, int32_t & out);
 
-KvResult read_float32_kv(const gguf_context * ctx, const char * key,
-                         float & out);
+KvResult read_float32_kv(const gguf_context * ctx, const char * key, float & out);
 
 // Convenience: special-token id KV. The GGUF tokenizer schema has not
 // standardized whether token ids are uint32 or int32 (different
 // converters in the wider ecosystem use different types). This helper
 // accepts either and casts to int. BadType only fires when the key is
 // present and is neither uint32 nor int32.
-KvResult read_token_id_kv(const gguf_context * ctx, const char * key,
-                          int & out);
+KvResult read_token_id_kv(const gguf_context * ctx, const char * key, int & out);
 
 // String array. The destination vector is cleared and replaced with
 // the parsed contents only on Ok. On Absent / BadType the destination
 // is left untouched (caller's responsibility to pre-populate or
 // post-validate).
-KvResult read_string_array_kv(const gguf_context * ctx, const char * key,
-                              std::vector<std::string> & out);
+KvResult read_string_array_kv(const gguf_context * ctx, const char * key, std::vector<std::string> & out);
 
 // int32 scalar array. Same Absent/Ok/BadType semantics as the other
 // readers; the destination vector is replaced only on Ok. Used by the
 // Parakeet TDT durations KV (`stt.parakeet.tdt.durations`); generic
 // enough to live alongside the other low-level readers.
-KvResult read_int32_array_kv(const gguf_context * ctx, const char * key,
-                             std::vector<int32_t> & out);
+KvResult read_int32_array_kv(const gguf_context * ctx, const char * key, std::vector<int32_t> & out);
 
 // ---------------------------------------------------------------------------
 // Higher-level required / optional KV helpers
@@ -144,8 +136,7 @@ transcribe_status read_optional_int32_kv(const gguf_context * gguf,
 //   TRANSCRIBE_ERR_INVALID_ARG if gguf is null.
 //   TRANSCRIBE_ERR_GGUF        if any recognized key is present with
 //                              the wrong type.
-transcribe_status read_capability_kv(const gguf_context *      gguf,
-                                     transcribe_capabilities & caps);
+transcribe_status read_capability_kv(const gguf_context * gguf, transcribe_capabilities & caps);
 
 // Read general.languages (string array of BCP-47-ish short codes) and
 // install it on the model via transcribe_model::set_languages(); then
@@ -160,7 +151,6 @@ transcribe_status read_capability_kv(const gguf_context *      gguf,
 //   TRANSCRIBE_ERR_INVALID_ARG if gguf is null.
 //   TRANSCRIBE_ERR_GGUF        if a recognized array is present but is
 //                              not a string array, or any element is null.
-transcribe_status read_languages_kv(const gguf_context * gguf,
-                                    transcribe_model &   model);
+transcribe_status read_languages_kv(const gguf_context * gguf, transcribe_model & model);
 
-} // namespace transcribe
+}  // namespace transcribe
diff --git a/src/transcribe-model.cpp b/src/transcribe-model.cpp
index 909249f0..8900a3e1 100644
--- a/src/transcribe-model.cpp
+++ b/src/transcribe-model.cpp
@@ -3,11 +3,12 @@
 // (avoids -Wweak-vtables) and holds set_languages().
 
 #include "transcribe-model.h"
+
 #include "transcribe-session.h"
 
 #include <utility>
 
-transcribe_model::~transcribe_model() = default;
+transcribe_model::~transcribe_model()     = default;
 transcribe_session::~transcribe_session() = default;
 
 void transcribe_session::clear_result() {
@@ -23,14 +24,14 @@ void transcribe_session::clear_result() {
     // the streaming dispatcher manages IDLE/ACTIVE/FINISHED/FAILED
     // explicitly. Everything else is per-utterance bookkeeping that
     // belongs with the result it describes.
-    stream_revision           = 0;
-    n_committed_segments      = 0;
-    n_committed_words         = 0;
-    n_committed_tokens        = 0;
-    stream_last_status        = TRANSCRIBE_OK;
-    stream_audio_input_us     = 0;
-    stream_audio_committed_us = 0;
-    stream_commit_policy      = TRANSCRIBE_STREAM_COMMIT_AUTO;
+    stream_revision                  = 0;
+    n_committed_segments             = 0;
+    n_committed_words                = 0;
+    n_committed_tokens               = 0;
+    stream_last_status               = TRANSCRIBE_OK;
+    stream_audio_input_us            = 0;
+    stream_audio_committed_us        = 0;
+    stream_commit_policy             = TRANSCRIBE_STREAM_COMMIT_AUTO;
     stream_stable_prefix_agreement_n = 0;
     stream_committed_text.clear();
     stream_tentative_text.clear();
@@ -67,18 +68,15 @@ void transcribe_model::set_translate_target_languages(std::vector<std::string> l
         translate_target_ptrs_.push_back(s.c_str());
     }
 
-    caps.n_translate_target_languages =
-        static_cast<int>(translate_target_storage_.size());
-    caps.translate_target_languages =
-        translate_target_ptrs_.empty() ? nullptr : translate_target_ptrs_.data();
+    caps.n_translate_target_languages = static_cast<int>(translate_target_storage_.size());
+    caps.translate_target_languages   = translate_target_ptrs_.empty() ? nullptr : translate_target_ptrs_.data();
 }
 
 void transcribe_model::set_translation_pairs(std::vector<std::string> pairs) {
     translation_pair_storage_ = std::move(pairs);
 }
 
-bool transcribe_model::allows_translation_pair(const char * src,
-                                               const char * dst) const {
+bool transcribe_model::allows_translation_pair(const char * src, const char * dst) const {
     if (translation_pair_storage_.empty()) {
         return true;
     }
diff --git a/src/transcribe-model.h b/src/transcribe-model.h
index 1d69940c..13837f7d 100644
--- a/src/transcribe-model.h
+++ b/src/transcribe-model.h
@@ -22,7 +22,7 @@
 namespace transcribe {
 struct Arch;
 class Tokenizer;
-} // namespace transcribe
+}  // namespace transcribe
 
 // Forward declaration for the resolved primary backend handle stored below.
 // The full type comes from ggml-backend.h in the .cpp that fills it.
@@ -93,7 +93,7 @@ struct transcribe_model {
         // n_ctx cap applies to (qwen3_asr, granite, voxtral, cohere, canary,
         // ...). When false the family has no decoder context cap and the
         // fields below stay zero.
-        bool    has_context_cap = false;
+        bool    has_context_cap        = false;
         // When true, effective_max_audio_ms comes straight from
         // caps.max_audio_ms rather than being derived from effective_n_ctx.
         // Set by families whose AUDIO bound is the encoder positional table
@@ -103,16 +103,16 @@ struct transcribe_model {
         // come from the decoder (n_ctx-sensitive). Left false by families
         // whose audio tokens consume the decoder context (qwen3_asr, granite,
         // voxtral, ...), where the audio bound legitimately scales with n_ctx.
-        bool    audio_from_caps = false;
+        bool    audio_from_caps        = false;
         // The model's trained decoder context window, in tokens.
-        int32_t model_max_ctx   = 0;
+        int32_t model_max_ctx          = 0;
         // Representative non-audio prompt token overhead (chat affixes etc.).
-        int32_t prompt_overhead = 0;
+        int32_t prompt_overhead        = 0;
         // Generation budget reserved when sizing the input bound.
-        int32_t gen_reserve     = 0;
+        int32_t gen_reserve            = 0;
         // Milliseconds of 16 kHz audio per audio token (inverse encoder rate),
         // used to turn an audio-token budget into effective_max_audio_ms.
-        double  ms_per_audio_token = 0.0;
+        double  ms_per_audio_token     = 0.0;
         // KV elements per context token (n_kv_heads * head_dim * n_layers * 2,
         // for K and V). The query multiplies by the session kv_type byte size
         // and effective_n_ctx to estimate max_kv_bytes.
@@ -160,7 +160,7 @@ struct transcribe_model {
     void set_translation_pairs(std::vector<std::string> pairs);
     bool allows_translation_pair(const char * src, const char * dst) const;
 
-private:
+  private:
     // Backing storage for the languages chain. Kept private so the only
     // way to mutate it is through set_languages(), which guarantees the
     // capability struct's pointer + count stay in sync.
@@ -186,9 +186,13 @@ namespace transcribe {
 // caller can pass any int, and loading an out-of-range value through the
 // enum type is UB in C++. Enum constants convert implicitly.
 inline void set_feature(transcribe_model * m, int f, bool on) {
-    if (m == nullptr) return;
+    if (m == nullptr) {
+        return;
+    }
     const unsigned bit = static_cast<unsigned>(f);
-    if (bit >= 64) return;
+    if (bit >= 64) {
+        return;
+    }
     const uint64_t mask = (uint64_t) 1 << bit;
     if (on) {
         m->feature_bits |= mask;
@@ -198,10 +202,14 @@ inline void set_feature(transcribe_model * m, int f, bool on) {
 }
 
 inline bool has_feature(const transcribe_model * m, int f) {
-    if (m == nullptr) return false;
+    if (m == nullptr) {
+        return false;
+    }
     const unsigned bit = static_cast<unsigned>(f);
-    if (bit >= 64) return false;
+    if (bit >= 64) {
+        return false;
+    }
     return (m->feature_bits & ((uint64_t) 1 << bit)) != 0;
 }
 
-} // namespace transcribe
+}  // namespace transcribe
diff --git a/src/transcribe-session.h b/src/transcribe-session.h
index 524b9159..7d769eaf 100644
--- a/src/transcribe-session.h
+++ b/src/transcribe-session.h
@@ -27,14 +27,11 @@ struct transcribe_model;
 // honors n_ctx should cache the result onto the base session's n_ctx field.
 // The negative-value rejection happens once, generically, in
 // transcribe_session_init().
-inline int32_t transcribe_session_params_n_ctx(
-    const struct transcribe_session_params * params) {
+inline int32_t transcribe_session_params_n_ctx(const struct transcribe_session_params * params) {
     if (params == nullptr) {
         return 0;
     }
-    const size_t field_end =
-        offsetof(struct transcribe_session_params, n_ctx) +
-        sizeof(params->n_ctx);
+    const size_t field_end = offsetof(struct transcribe_session_params, n_ctx) + sizeof(params->n_ctx);
     if (params->struct_size < static_cast<uint64_t>(field_end)) {
         return 0;
     }
@@ -90,13 +87,13 @@ struct transcribe_session {
     // sentinels ("", 0, NAN).
 
     struct TokenEntry {
-        int         id            = 0;
-        std::string text;            // decoded fragment (▁ → space)
-        float       p             = 0.0f;
-        int64_t     t0_ms         = 0;
-        int64_t     t1_ms         = 0;
-        int         seg_index     = 0;
-        int         word_index    = -1;
+        int         id = 0;
+        std::string text;  // decoded fragment (▁ → space)
+        float       p          = 0.0f;
+        int64_t     t0_ms      = 0;
+        int64_t     t1_ms      = 0;
+        int         seg_index  = 0;
+        int         word_index = -1;
     };
 
     struct WordEntry {
@@ -118,10 +115,10 @@ struct transcribe_session {
         int         n_tokens    = 0;
     };
 
-    std::vector<TokenEntry>      tokens;
-    std::vector<WordEntry>       words;
-    std::vector<SegmentEntry>    segments;
-    std::string                  full_text;
+    std::vector<TokenEntry>   tokens;
+    std::vector<WordEntry>    words;
+    std::vector<SegmentEntry> segments;
+    std::string               full_text;
 
     // Offline batch results (transcribe_run_batch). The scratch fields
     // above are the single "current result" slot every run() writes into
@@ -146,19 +143,19 @@ struct transcribe_session {
         std::string               full_text;
         std::string               detected_language;
         transcribe_timestamp_kind result_kind = TRANSCRIBE_TIMESTAMPS_NONE;
-        bool                      has_result   = false;
-        transcribe_status         status       = TRANSCRIBE_OK;
+        bool                      has_result  = false;
+        transcribe_status         status      = TRANSCRIBE_OK;
         // Per-utterance timings (us). For a batched run the encoder is one
         // shared dispatch, so a family amortizes its total encode time across
         // the batch (sum over utterances == the real batch encode time);
         // decode is genuinely per-utterance. Lets transcribe_batch_get_timings
         // expose where time goes (encoder vs host decode) per utterance.
-        int64_t                   t_mel_us     = 0;
-        int64_t                   t_encode_us  = 0;
-        int64_t                   t_decode_us  = 0;
+        int64_t                   t_mel_us    = 0;
+        int64_t                   t_encode_us = 0;
+        int64_t                   t_decode_us = 0;
     };
 
-    std::vector<ResultSet>       batch_results;
+    std::vector<ResultSet> batch_results;
 
     // Snapshot the current scratch result slot (the fields above that a
     // per-family run() populates) into a standalone ResultSet. Used by the
@@ -187,9 +184,9 @@ struct transcribe_session {
     // "unknown" — either no detection ran (English-only model, user
     // supplied a hint, family doesn't support LID) or detection produced
     // a non-language sentinel (e.g. SenseVoice's <|nospeech|>).
-    std::string                  detected_language;
-    transcribe_timestamp_kind    result_kind = TRANSCRIBE_TIMESTAMPS_NONE;
-    bool                         has_result  = false;
+    std::string               detected_language;
+    transcribe_timestamp_kind result_kind = TRANSCRIBE_TIMESTAMPS_NONE;
+    bool                      has_result  = false;
 
     // Abort / cancellation (set via transcribe_set_abort_callback).
     // run() drivers call poll_abort() at chunk / decode-step boundaries;
@@ -197,9 +194,9 @@ struct transcribe_session {
     // TRANSCRIBE_ERR_ABORTED with partial segments preserved. was_aborted
     // is cleared at the top of every transcribe_run, NOT by clear_result
     // (the partial result may be deliberately retained).
-    transcribe_abort_callback    abort_cb        = nullptr;
-    void *                       abort_userdata  = nullptr;
-    bool                         was_aborted     = false;
+    transcribe_abort_callback abort_cb       = nullptr;
+    void *                    abort_userdata = nullptr;
+    bool                      was_aborted    = false;
 
     bool poll_abort() {
         if (abort_cb != nullptr && abort_cb(abort_userdata)) {
@@ -215,7 +212,7 @@ struct transcribe_session {
     // top of every transcribe_run, NOT by clear_result. Distinct from the
     // up-front TRANSCRIBE_ERR_INPUT_TOO_LONG rejection (couldn't finish vs
     // couldn't start). See docs/input-limits.md.
-    bool                         was_truncated   = false;
+    bool was_truncated = false;
 
     // Streaming state. Lifecycle (stream_state) is separated from the
     // result snapshot so clear_result() can wipe per-call data without
@@ -224,17 +221,16 @@ struct transcribe_session {
     // committed counts, last_status, audio cursors) ARE cleared by
     // clear_result. Audio cursors are us-precision; the public
     // stream_update struct exposes them as ms.
-    transcribe_stream_state      stream_state          = TRANSCRIBE_STREAM_IDLE;
-    int32_t                      stream_revision      = 0;
-    int                          n_committed_segments = 0;
-    int                          n_committed_words    = 0;
-    int                          n_committed_tokens   = 0;
-    transcribe_status            stream_last_status   = TRANSCRIBE_OK;
-    int64_t                      stream_audio_input_us     = 0;
-    int64_t                      stream_audio_committed_us = 0;
-    transcribe_stream_commit_policy stream_commit_policy =
-        TRANSCRIBE_STREAM_COMMIT_AUTO;
-    uint32_t                     stream_stable_prefix_agreement_n = 0;
+    transcribe_stream_state         stream_state                     = TRANSCRIBE_STREAM_IDLE;
+    int32_t                         stream_revision                  = 0;
+    int                             n_committed_segments             = 0;
+    int                             n_committed_words                = 0;
+    int                             n_committed_tokens               = 0;
+    transcribe_status               stream_last_status               = TRANSCRIBE_OK;
+    int64_t                         stream_audio_input_us            = 0;
+    int64_t                         stream_audio_committed_us        = 0;
+    transcribe_stream_commit_policy stream_commit_policy             = TRANSCRIBE_STREAM_COMMIT_AUTO;
+    uint32_t                        stream_stable_prefix_agreement_n = 0;
 
     // Session-owned copies of the caller's run-params strings, refreshed
     // on every transcribe_stream_begin. The dispatcher hands the family
@@ -243,18 +239,18 @@ struct transcribe_session {
     // storage (the public contract lets the caller free its params pointers
     // the moment begin returns). Stable for the stream's lifetime; only the
     // next begin mutates them.
-    std::string                  stream_language_owned;
-    std::string                  stream_target_language_owned;
+    std::string stream_language_owned;
+    std::string stream_target_language_owned;
 
     // UI-facing streaming text state. `full_text` above remains the raw
     // model hypothesis. `stream_committed_text` is the append-only public
     // display/input prefix; `stream_tentative_text` is the current raw
     // suffix after `stream_raw_tentative_start_bytes`. The raw history is
     // used by the generic STABLE_PREFIX policy.
-    std::string                  stream_committed_text;
-    std::string                  stream_tentative_text;
-    uint64_t                     stream_raw_tentative_start_bytes = 0;
-    std::deque<std::string>      stream_raw_history;
+    std::string             stream_committed_text;
+    std::string             stream_tentative_text;
+    uint64_t                stream_raw_tentative_start_bytes = 0;
+    std::deque<std::string> stream_raw_history;
 
     void clear_result();
 
diff --git a/src/transcribe-tokenizer.cpp b/src/transcribe-tokenizer.cpp
index fdc01636..b46c5647 100644
--- a/src/transcribe-tokenizer.cpp
+++ b/src/transcribe-tokenizer.cpp
@@ -12,15 +12,14 @@
 
 #include "transcribe-tokenizer.h"
 
+#include "gguf.h"
+#include "transcribe-log.h"
 #include "transcribe-meta.h"
 #include "transcribe-unicode.h"
-#include "transcribe-log.h"
-
-#include "gguf.h"
 
 #include <algorithm>
-#include <cstring>
 #include <cstdio>
+#include <cstring>
 #include <queue>
 #include <string>
 #include <vector>
@@ -51,8 +50,7 @@ template <typename T>
 KvResult read_typed_array_kv(const gguf_context * ctx,
                              const char *         key,
                              gguf_type            expected_element_type,
-                             std::vector<T> &     out)
-{
+                             std::vector<T> &     out) {
     const int64_t key_id = gguf_find_key(ctx, key);
     if (key_id < 0) {
         return KvResult::Absent;
@@ -64,7 +62,7 @@ KvResult read_typed_array_kv(const gguf_context * ctx,
         return KvResult::BadType;
     }
 
-    const size_t n = gguf_get_arr_n(ctx, key_id);
+    const size_t   n = gguf_get_arr_n(ctx, key_id);
     std::vector<T> tmp(n);
     if (n > 0) {
         const void * data = gguf_get_arr_data(ctx, key_id);
@@ -77,7 +75,7 @@ KvResult read_typed_array_kv(const gguf_context * ctx,
     return KvResult::Ok;
 }
 
-} // namespace
+}  // namespace
 
 // ---------------------------------------------------------------------------
 // Vocabulary accessors.
@@ -124,8 +122,12 @@ bool Tokenizer::has_encoder() const {
     // GGUF "gpt2" with merges → HF byte-unicode + merge-rank encoder.
     // Decode-only raw-bytes (whisper.cpp .bin) → tiktoken-style
     // encoder using piece_to_id_ as the rank table.
-    if (model_ == "gpt2" && !merge_rank_.empty()) return true;
-    if (decode_mode_ == DecodeMode::RawBytes && !tokens_.empty()) return true;
+    if (model_ == "gpt2" && !merge_rank_.empty()) {
+        return true;
+    }
+    if (decode_mode_ == DecodeMode::RawBytes && !tokens_.empty()) {
+        return true;
+    }
     return false;
 }
 
@@ -147,22 +149,31 @@ namespace {
 // it (Vietnamese diacritics, all CJK, Cyrillic outside the base set,
 // etc.). Without this reassembly the model output contains literal
 // "<0xE1><0xBB><0x95>" instead of the intended Unicode character.
-std::string decode_sentencepiece(const std::vector<std::string> & tokens,
-                                 const int *                       ids,
-                                 int                               n)
-{
+std::string decode_sentencepiece(const std::vector<std::string> & tokens, const int * ids, int n) {
     auto hex_nibble = [](char c) -> int {
-        if (c >= '0' && c <= '9') return c - '0';
-        if (c >= 'A' && c <= 'F') return 10 + (c - 'A');
-        if (c >= 'a' && c <= 'f') return 10 + (c - 'a');
+        if (c >= '0' && c <= '9') {
+            return c - '0';
+        }
+        if (c >= 'A' && c <= 'F') {
+            return 10 + (c - 'A');
+        }
+        if (c >= 'a' && c <= 'f') {
+            return 10 + (c - 'a');
+        }
         return -1;
     };
     auto try_byte_fallback = [&](const std::string & p) -> int {
-        if (p.size() != 6) return -1;
-        if (p[0] != '<' || p[1] != '0' || p[2] != 'x' || p[5] != '>') return -1;
+        if (p.size() != 6) {
+            return -1;
+        }
+        if (p[0] != '<' || p[1] != '0' || p[2] != 'x' || p[5] != '>') {
+            return -1;
+        }
         const int hi = hex_nibble(p[3]);
         const int lo = hex_nibble(p[4]);
-        if (hi < 0 || lo < 0) return -1;
+        if (hi < 0 || lo < 0) {
+            return -1;
+        }
         return (hi << 4) | lo;
     };
 
@@ -173,17 +184,15 @@ std::string decode_sentencepiece(const std::vector<std::string> & tokens,
         if (id < 0 || static_cast<size_t>(id) >= tokens.size()) {
             continue;
         }
-        const std::string & p = tokens[static_cast<size_t>(id)];
-        const int byte = try_byte_fallback(p);
+        const std::string & p    = tokens[static_cast<size_t>(id)];
+        const int           byte = try_byte_fallback(p);
         if (byte >= 0) {
             out.push_back(static_cast<char>(byte));
             continue;
         }
         size_t j = 0;
         while (j < p.size()) {
-            if (j + k_sp_space_len <= p.size() &&
-                std::memcmp(p.data() + j, k_sp_space, k_sp_space_len) == 0)
-            {
+            if (j + k_sp_space_len <= p.size() && std::memcmp(p.data() + j, k_sp_space, k_sp_space_len) == 0) {
                 out.push_back(' ');
                 j += k_sp_space_len;
             } else {
@@ -197,10 +206,7 @@ std::string decode_sentencepiece(const std::vector<std::string> & tokens,
 
 // Raw-byte decode: tokens already contain raw UTF-8 byte sequences
 // (legacy whisper.cpp .bin tiktoken-style vocab). Concatenate verbatim.
-std::string decode_raw_bytes(const std::vector<std::string> & tokens,
-                             const int *                       ids,
-                             int                               n)
-{
+std::string decode_raw_bytes(const std::vector<std::string> & tokens, const int * ids, int n) {
     std::string out;
     out.reserve(static_cast<size_t>(n) * 2);
     for (int i = 0; i < n; ++i) {
@@ -215,10 +221,7 @@ std::string decode_raw_bytes(const std::vector<std::string> & tokens,
 
 // GPT-2 byte-level decode: invert the bytes_to_unicode mapping per
 // codepoint to recover raw UTF-8 bytes.
-std::string decode_gpt2_bytes(const std::vector<std::string> & tokens,
-                              const int *                       ids,
-                              int                               n)
-{
+std::string decode_gpt2_bytes(const std::vector<std::string> & tokens, const int * ids, int n) {
     std::string out;
     out.reserve(static_cast<size_t>(n) * 2);
     std::string one_cpt;
@@ -229,10 +232,9 @@ std::string decode_gpt2_bytes(const std::vector<std::string> & tokens,
             continue;
         }
         const std::string & p = tokens[static_cast<size_t>(id)];
-        size_t j = 0;
+        size_t              j = 0;
         while (j < p.size()) {
-            const size_t w = std::min(p.size() - j,
-                                      unicode::len_utf8(p[j]));
+            const size_t w = std::min(p.size() - j, unicode::len_utf8(p[j]));
             one_cpt.assign(p.data() + j, w);
             const int byte = unicode::unicode_to_byte(one_cpt);
             if (byte >= 0) {
@@ -250,7 +252,7 @@ std::string decode_gpt2_bytes(const std::vector<std::string> & tokens,
     return out;
 }
 
-} // namespace
+}  // namespace
 
 std::string Tokenizer::decode(const int * ids, int n) const {
     if (ids == nullptr || n <= 0) {
@@ -293,20 +295,22 @@ struct Bigram {
     int         left  = -1;
     int         right = -1;
     std::string text;
-    int         rank  = 0;
-    size_t      size  = 0;
+    int         rank = 0;
+    size_t      size = 0;
 };
 
 struct BigramGreater {
     bool operator()(const Bigram & a, const Bigram & b) const {
         // Lower rank wins; on ties, lower `left` index wins (same
         // tiebreaker as llama.cpp's comparator).
-        if (a.rank != b.rank) return a.rank > b.rank;
+        if (a.rank != b.rank) {
+            return a.rank > b.rank;
+        }
         return a.left > b.left;
     }
 };
 
-} // namespace
+}  // namespace
 
 // Tiktoken-style encoder for raw-bytes vocabularies (whisper.cpp .bin):
 //   - pretokens are pure UTF-8 byte sequences (no GPT-2 byte-unicode remap),
@@ -323,12 +327,10 @@ struct BigramGreater {
 // dispatch into it cleanly.
 namespace {
 
-transcribe_status encode_tiktoken_raw_bytes(
-    const std::string &                                     text,
-    const std::string &                                     pre,
-    const std::unordered_map<std::string, int32_t> &        piece_to_id,
-    std::vector<int32_t> &                                  out_ids)
-{
+transcribe_status encode_tiktoken_raw_bytes(const std::string &                              text,
+                                            const std::string &                              pre,
+                                            const std::unordered_map<std::string, int32_t> & piece_to_id,
+                                            std::vector<int32_t> &                           out_ids) {
     out_ids.clear();
     if (text.empty()) {
         return TRANSCRIBE_OK;
@@ -342,15 +344,13 @@ transcribe_status encode_tiktoken_raw_bytes(
         // raw bytes without a regex would produce a different
         // tokenization. Reject loudly.
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "tokenizer.encode: pretokenizer \"%s\" not "
-                     "supported with raw-bytes vocab",
-                     pre.c_str());
+                "tokenizer.encode: pretokenizer \"%s\" not "
+                "supported with raw-bytes vocab",
+                pre.c_str());
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
 
-    auto rank_of_concat = [&](const std::string & left,
-                              const std::string & right) -> int
-    {
+    auto rank_of_concat = [&](const std::string & left, const std::string & right) -> int {
         std::string key;
         key.reserve(left.size() + right.size());
         key.append(left);
@@ -364,11 +364,15 @@ transcribe_status encode_tiktoken_raw_bytes(
     std::priority_queue<Bigram, std::vector<Bigram>, BigramGreater> queue;
 
     auto push_bigram = [&](int l, int r) {
-        if (l < 0 || r < 0) return;
-        const std::string left (symbols[l].text, symbols[l].n);
+        if (l < 0 || r < 0) {
+            return;
+        }
+        const std::string left(symbols[l].text, symbols[l].n);
         const std::string right(symbols[r].text, symbols[r].n);
-        const int rank = rank_of_concat(left, right);
-        if (rank < 0) return;
+        const int         rank = rank_of_concat(left, right);
+        if (rank < 0) {
+            return;
+        }
         Bigram bg;
         bg.left  = l;
         bg.right = r;
@@ -380,7 +384,9 @@ transcribe_status encode_tiktoken_raw_bytes(
 
     out_ids.reserve(words.size() * 2);
     for (const auto & word : words) {
-        while (!queue.empty()) queue.pop();
+        while (!queue.empty()) {
+            queue.pop();
+        }
         symbols.clear();
 
         // Seed: one symbol per BYTE (not codepoint). Tiktoken-style
@@ -391,9 +397,7 @@ transcribe_status encode_tiktoken_raw_bytes(
             s.text = word.data() + off;
             s.n    = 1;
             s.prev = static_cast<int>(off) - 1;
-            s.next = (off + 1 == word.size())
-                         ? -1
-                         : static_cast<int>(off) + 1;
+            s.next = (off + 1 == word.size()) ? -1 : static_cast<int>(off) + 1;
             symbols.push_back(s);
         }
 
@@ -406,26 +410,36 @@ transcribe_status encode_tiktoken_raw_bytes(
             queue.pop();
             Symbol & left  = symbols[bg.left];
             Symbol & right = symbols[bg.right];
-            if (left.n == 0 || right.n == 0) continue;
-            if (left.n + right.n != bg.size) continue;
-            if (std::memcmp(left.text,  bg.text.data(),           left.n)  != 0) continue;
-            if (std::memcmp(right.text, bg.text.data() + left.n,  right.n) != 0) continue;
+            if (left.n == 0 || right.n == 0) {
+                continue;
+            }
+            if (left.n + right.n != bg.size) {
+                continue;
+            }
+            if (std::memcmp(left.text, bg.text.data(), left.n) != 0) {
+                continue;
+            }
+            if (std::memcmp(right.text, bg.text.data() + left.n, right.n) != 0) {
+                continue;
+            }
 
             left.n += right.n;
-            right.n = 0;
+            right.n   = 0;
             left.next = right.next;
             if (right.next >= 0) {
                 symbols[right.next].prev = bg.left;
             }
             push_bigram(left.prev, bg.left);
-            push_bigram(bg.left,   left.next);
+            push_bigram(bg.left, left.next);
         }
 
         for (int i = 0; i != -1; i = symbols[i].next) {
             const Symbol & s = symbols[i];
-            if (s.n == 0) continue;
+            if (s.n == 0) {
+                continue;
+            }
             const std::string piece(s.text, s.n);
-            const auto it = piece_to_id.find(piece);
+            const auto        it = piece_to_id.find(piece);
             if (it != piece_to_id.end()) {
                 out_ids.push_back(it->second);
                 continue;
@@ -435,12 +449,12 @@ transcribe_status encode_tiktoken_raw_bytes(
             // structurally broken.
             for (size_t j = 0; j < piece.size(); ++j) {
                 const std::string sub(piece, j, 1);
-                const auto it2 = piece_to_id.find(sub);
+                const auto        it2 = piece_to_id.find(sub);
                 if (it2 == piece_to_id.end()) {
                     log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                                 "tokenizer.encode: byte 0x%02X not in "
-                                 "vocab",
-                                 static_cast<unsigned>(static_cast<unsigned char>(piece[j])));
+                            "tokenizer.encode: byte 0x%02X not in "
+                            "vocab",
+                            static_cast<unsigned>(static_cast<unsigned char>(piece[j])));
                     return TRANSCRIBE_ERR_GGUF;
                 }
                 out_ids.push_back(it2->second);
@@ -450,11 +464,9 @@ transcribe_status encode_tiktoken_raw_bytes(
     return TRANSCRIBE_OK;
 }
 
-} // namespace
+}  // namespace
 
-transcribe_status Tokenizer::encode(const std::string &    text,
-                                    std::vector<int32_t> & out_ids) const
-{
+transcribe_status Tokenizer::encode(const std::string & text, std::vector<int32_t> & out_ids) const {
     out_ids.clear();
 
     // Raw-bytes mode: tiktoken-style encoder, no merge table needed.
@@ -477,8 +489,8 @@ transcribe_status Tokenizer::encode(const std::string &    text,
         // is never what a caller wants. Surface the configuration
         // gap instead.
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "tokenizer.encode: \"gpt2\" tokenizer loaded without "
-                     "tokenizer.ggml.merges; encode unavailable");
+                "tokenizer.encode: \"gpt2\" tokenizer loaded without "
+                "tokenizer.ggml.merges; encode unavailable");
         return TRANSCRIBE_ERR_GGUF;
     }
     if (text.empty()) {
@@ -498,8 +510,9 @@ transcribe_status Tokenizer::encode(const std::string &    text,
     } else {
         if (pre_ != "qwen2" && !pre_.empty()) {
             log_msg(TRANSCRIBE_LOG_LEVEL_WARN,
-                         "tokenizer.encode: unknown tokenizer.ggml.pre "
-                         "\"%s\"; falling back to qwen2", pre_.c_str());
+                    "tokenizer.encode: unknown tokenizer.ggml.pre "
+                    "\"%s\"; falling back to qwen2",
+                    pre_.c_str());
         }
         words = unicode::pretokenize_qwen2(text);
     }
@@ -511,9 +524,7 @@ transcribe_status Tokenizer::encode(const std::string &    text,
     symbols.reserve(64);
     std::priority_queue<Bigram, std::vector<Bigram>, BigramGreater> queue;
 
-    auto rank_of = [&](const std::string & left,
-                       const std::string & right) -> int
-    {
+    auto rank_of = [&](const std::string & left, const std::string & right) -> int {
         std::string key;
         key.reserve(left.size() + 1 + right.size());
         key.append(left);
@@ -524,11 +535,15 @@ transcribe_status Tokenizer::encode(const std::string &    text,
     };
 
     auto push_bigram = [&](int l, int r) {
-        if (l < 0 || r < 0) return;
-        const std::string left (symbols[l].text, symbols[l].n);
+        if (l < 0 || r < 0) {
+            return;
+        }
+        const std::string left(symbols[l].text, symbols[l].n);
         const std::string right(symbols[r].text, symbols[r].n);
-        const int rank = rank_of(left, right);
-        if (rank < 0) return;
+        const int         rank = rank_of(left, right);
+        if (rank < 0) {
+            return;
+        }
         Bigram bg;
         bg.left  = l;
         bg.right = r;
@@ -540,18 +555,19 @@ transcribe_status Tokenizer::encode(const std::string &    text,
 
     for (const auto & word : words) {
         // Drain any stale entries from a previous word.
-        while (!queue.empty()) queue.pop();
+        while (!queue.empty()) {
+            queue.pop();
+        }
         symbols.clear();
 
         // Seed: one symbol per UTF-8 codepoint of the byte-encoded
         // word. Codepoint-level chunking matches the Python reference
         // (HF tokenizers iterate codepoints before merging).
-        int index = 0;
+        int    index  = 0;
         size_t offset = 0;
         while (offset < word.size()) {
-            const size_t clen = std::min(word.size() - offset,
-                                         unicode::len_utf8(word[offset]));
-            Symbol s;
+            const size_t clen = std::min(word.size() - offset, unicode::len_utf8(word[offset]));
+            Symbol       s;
             s.text = word.data() + offset;
             s.n    = clen;
             s.prev = index - 1;
@@ -571,18 +587,26 @@ transcribe_status Tokenizer::encode(const std::string &    text,
 
             Symbol & left  = symbols[bg.left];
             Symbol & right = symbols[bg.right];
-            if (left.n == 0 || right.n == 0) continue;
+            if (left.n == 0 || right.n == 0) {
+                continue;
+            }
 
             // Stale-entry check: if either side has been merged into
             // something else since this bigram was pushed, the
             // concatenation won't match `bg.text` and we drop it.
-            if (left.n + right.n != bg.size) continue;
-            if (std::memcmp(left.text,  bg.text.data(),            left.n)  != 0) continue;
-            if (std::memcmp(right.text, bg.text.data() + left.n,   right.n) != 0) continue;
+            if (left.n + right.n != bg.size) {
+                continue;
+            }
+            if (std::memcmp(left.text, bg.text.data(), left.n) != 0) {
+                continue;
+            }
+            if (std::memcmp(right.text, bg.text.data() + left.n, right.n) != 0) {
+                continue;
+            }
 
             // Merge right into left; unlink right.
             left.n += right.n;
-            right.n = 0;
+            right.n   = 0;
             left.next = right.next;
             if (right.next >= 0) {
                 symbols[right.next].prev = bg.left;
@@ -590,14 +614,16 @@ transcribe_status Tokenizer::encode(const std::string &    text,
 
             // Enqueue new neighbor bigrams around the enlarged left.
             push_bigram(left.prev, bg.left);
-            push_bigram(bg.left,   left.next);
+            push_bigram(bg.left, left.next);
         }
 
         for (int i = 0; i != -1; i = symbols[i].next) {
             const Symbol & s = symbols[i];
-            if (s.n == 0) continue;
+            if (s.n == 0) {
+                continue;
+            }
             const std::string piece(s.text, s.n);
-            const auto it = piece_to_id_.find(piece);
+            const auto        it = piece_to_id_.find(piece);
             if (it != piece_to_id_.end()) {
                 out_ids.push_back(it->second);
                 continue;
@@ -606,15 +632,15 @@ transcribe_status Tokenizer::encode(const std::string &    text,
             // single-byte tokens. Each byte of the byte-encoded
             // pretoken is itself a one-codepoint piece that the
             // vocab carries; the converter guarantees this.
-            for (size_t j = 0; j < piece.size(); /*++j*/ ) {
-                const size_t clen = std::min(piece.size() - j,
-                                             unicode::len_utf8(piece[j]));
+            for (size_t j = 0; j < piece.size(); /*++j*/) {
+                const size_t      clen = std::min(piece.size() - j, unicode::len_utf8(piece[j]));
                 const std::string sub(piece, j, clen);
-                const auto it2 = piece_to_id_.find(sub);
+                const auto        it2 = piece_to_id_.find(sub);
                 if (it2 == piece_to_id_.end()) {
                     log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                                 "tokenizer.encode: byte-fallback piece "
-                                 "not in vocab (\"%s\")", sub.c_str());
+                            "tokenizer.encode: byte-fallback piece "
+                            "not in vocab (\"%s\")",
+                            sub.c_str());
                     return TRANSCRIBE_ERR_GGUF;
                 }
                 out_ids.push_back(it2->second);
@@ -654,9 +680,7 @@ transcribe_status Tokenizer::load(const gguf_context * gguf) {
     // surface as NOT_IMPLEMENTED so the caller can tell "the file is
     // fine, the library is just not ready for this tokenizer" from
     // "the file is broken."
-    if (model_ != "unigram" && model_ != "bpe" && model_ != "gpt2" &&
-        model_ != "char")
-    {
+    if (model_ != "unigram" && model_ != "bpe" && model_ != "gpt2" && model_ != "char") {
         return TRANSCRIBE_ERR_NOT_IMPLEMENTED;
     }
     if (model_ == "gpt2") {
@@ -711,9 +735,7 @@ transcribe_status Tokenizer::load(const gguf_context * gguf) {
     // Optional: scores. Absent is fine (we clear and move on); BadType
     // is a converter bug and propagates as ERR_GGUF. The length-must-
     // match contract on Ok is a separate, narrower check.
-    switch (read_typed_array_kv<float>(gguf, "tokenizer.ggml.scores",
-                                       GGUF_TYPE_FLOAT32, scores_))
-    {
+    switch (read_typed_array_kv<float>(gguf, "tokenizer.ggml.scores", GGUF_TYPE_FLOAT32, scores_)) {
         case KvResult::Absent:
             scores_.clear();
             break;
@@ -727,9 +749,7 @@ transcribe_status Tokenizer::load(const gguf_context * gguf) {
     }
 
     // Optional: token_type.
-    switch (read_typed_array_kv<int32_t>(gguf, "tokenizer.ggml.token_type",
-                                         GGUF_TYPE_INT32, token_type_))
-    {
+    switch (read_typed_array_kv<int32_t>(gguf, "tokenizer.ggml.token_type", GGUF_TYPE_INT32, token_type_)) {
         case KvResult::Absent:
             token_type_.clear();
             break;
@@ -762,11 +782,12 @@ transcribe_status Tokenizer::load(const gguf_context * gguf) {
                 // position 1 so a merge whose left side is a single
                 // space (" ") still parses correctly — matches
                 // llama.cpp's bpe_ranks loader.
-                const size_t sp = line.find(' ', 1);
+                const size_t        sp   = line.find(' ', 1);
                 if (sp == std::string::npos) {
                     log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                                 "tokenizer.load: merge %zu has no space "
-                                 "separator: \"%s\"", i, line.c_str());
+                            "tokenizer.load: merge %zu has no space "
+                            "separator: \"%s\"",
+                            i, line.c_str());
                     return TRANSCRIBE_ERR_GGUF;
                 }
                 std::string key;
@@ -782,21 +803,28 @@ transcribe_status Tokenizer::load(const gguf_context * gguf) {
     // Optional special token ids.
     auto read_special = [&](const char * key, int & field) -> transcribe_status {
         switch (read_token_id_kv(gguf, key, field)) {
-            case KvResult::Absent:  return TRANSCRIBE_OK;
-            case KvResult::Ok:      return TRANSCRIBE_OK;
-            case KvResult::BadType: return TRANSCRIBE_ERR_GGUF;
+            case KvResult::Absent:
+                return TRANSCRIBE_OK;
+            case KvResult::Ok:
+                return TRANSCRIBE_OK;
+            case KvResult::BadType:
+                return TRANSCRIBE_ERR_GGUF;
         }
         return TRANSCRIBE_ERR_GGUF;
     };
 
-    if (auto st = read_special("tokenizer.ggml.unknown_token_id", unk_id_);
-        st != TRANSCRIBE_OK) return st;
-    if (auto st = read_special("tokenizer.ggml.bos_token_id", bos_id_);
-        st != TRANSCRIBE_OK) return st;
-    if (auto st = read_special("tokenizer.ggml.eos_token_id", eos_id_);
-        st != TRANSCRIBE_OK) return st;
-    if (auto st = read_special("tokenizer.ggml.blank_token_id", blank_id_);
-        st != TRANSCRIBE_OK) return st;
+    if (auto st = read_special("tokenizer.ggml.unknown_token_id", unk_id_); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_special("tokenizer.ggml.bos_token_id", bos_id_); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_special("tokenizer.ggml.eos_token_id", eos_id_); st != TRANSCRIBE_OK) {
+        return st;
+    }
+    if (auto st = read_special("tokenizer.ggml.blank_token_id", blank_id_); st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     return TRANSCRIBE_OK;
 }
@@ -813,11 +841,9 @@ namespace {
 // the RawBytes loader (whisper.cpp .bin) gets a tiktoken-style
 // encoder via piece_to_id_ ranks; the Gpt2ByteUnicode decode-only
 // loader (no merges populated) reports has_encoder() == false.
-transcribe_status install_decode_only_vocab(
-    std::vector<std::string> &                  tokens_dst,
-    std::unordered_map<std::string, int32_t> &  piece_to_id_dst,
-    std::vector<std::string>                    tokens_src)
-{
+transcribe_status install_decode_only_vocab(std::vector<std::string> &                 tokens_dst,
+                                            std::unordered_map<std::string, int32_t> & piece_to_id_dst,
+                                            std::vector<std::string>                   tokens_src) {
     if (tokens_src.empty()) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
@@ -830,15 +856,13 @@ transcribe_status install_decode_only_vocab(
     return TRANSCRIBE_OK;
 }
 
-} // namespace
+}  // namespace
 
-transcribe_status Tokenizer::load_decode_only_gpt2(
-    std::vector<std::string>   tokens,
-    const DecodeOnlySpecials & specials)
-{
-    if (auto st = install_decode_only_vocab(tokens_, piece_to_id_,
-                                            std::move(tokens));
-        st != TRANSCRIBE_OK) return st;
+transcribe_status Tokenizer::load_decode_only_gpt2(std::vector<std::string>   tokens,
+                                                   const DecodeOnlySpecials & specials) {
+    if (auto st = install_decode_only_vocab(tokens_, piece_to_id_, std::move(tokens)); st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     decode_mode_ = DecodeMode::Gpt2ByteUnicode;
     model_.clear();
@@ -855,13 +879,11 @@ transcribe_status Tokenizer::load_decode_only_gpt2(
     return TRANSCRIBE_OK;
 }
 
-transcribe_status Tokenizer::load_decode_only_raw_bytes(
-    std::vector<std::string>   tokens,
-    const DecodeOnlySpecials & specials)
-{
-    if (auto st = install_decode_only_vocab(tokens_, piece_to_id_,
-                                            std::move(tokens));
-        st != TRANSCRIBE_OK) return st;
+transcribe_status Tokenizer::load_decode_only_raw_bytes(std::vector<std::string>   tokens,
+                                                        const DecodeOnlySpecials & specials) {
+    if (auto st = install_decode_only_vocab(tokens_, piece_to_id_, std::move(tokens)); st != TRANSCRIBE_OK) {
+        return st;
+    }
 
     decode_mode_ = DecodeMode::RawBytes;
     model_.clear();
@@ -878,4 +900,4 @@ transcribe_status Tokenizer::load_decode_only_raw_bytes(
     return TRANSCRIBE_OK;
 }
 
-} // namespace transcribe
+}  // namespace transcribe
diff --git a/src/transcribe-tokenizer.h b/src/transcribe-tokenizer.h
index 689c72b5..fb35823d 100644
--- a/src/transcribe-tokenizer.h
+++ b/src/transcribe-tokenizer.h
@@ -35,7 +35,7 @@ struct gguf_context;
 namespace transcribe {
 
 class Tokenizer {
-public:
+  public:
     Tokenizer() = default;
 
     // Read tokenizer.ggml.* keys from a gguf_context.
@@ -89,9 +89,9 @@ class Tokenizer {
     //
     // Returns TRANSCRIBE_OK on success, TRANSCRIBE_ERR_INVALID_ARG if
     // `tokens` is empty.
-    transcribe_status load_decode_only_gpt2(std::vector<std::string>   tokens,
-                                            const DecodeOnlySpecials & specials);
-    transcribe_status load_decode_only_gpt2(std::vector<std::string>   tokens) {
+    transcribe_status load_decode_only_gpt2(std::vector<std::string> tokens, const DecodeOnlySpecials & specials);
+
+    transcribe_status load_decode_only_gpt2(std::vector<std::string> tokens) {
         return load_decode_only_gpt2(std::move(tokens), DecodeOnlySpecials{});
     }
 
@@ -105,9 +105,9 @@ class Tokenizer {
     // need a separate merges list because the vocab id IS the merge
     // rank. encode() walks adjacent pairs and looks up "left+right"
     // in piece_to_id_ directly; has_encoder() returns true.
-    transcribe_status load_decode_only_raw_bytes(std::vector<std::string>   tokens,
-                                                 const DecodeOnlySpecials & specials);
-    transcribe_status load_decode_only_raw_bytes(std::vector<std::string>   tokens) {
+    transcribe_status load_decode_only_raw_bytes(std::vector<std::string> tokens, const DecodeOnlySpecials & specials);
+
+    transcribe_status load_decode_only_raw_bytes(std::vector<std::string> tokens) {
         return load_decode_only_raw_bytes(std::move(tokens), DecodeOnlySpecials{});
     }
 
@@ -115,9 +115,10 @@ class Tokenizer {
     // out-of-range id (matching the safe-sentinel pattern used by the
     // public result accessors). find(piece) returns -1 if the piece
     // is not in the vocabulary OR the synthesized special-piece map.
-    int                 n_tokens() const { return static_cast<int>(tokens_.size()); }
-    const std::string & token   (int id) const;
-    int                 find    (const std::string & piece) const;
+    int n_tokens() const { return static_cast<int>(tokens_.size()); }
+
+    const std::string & token(int id) const;
+    int                 find(const std::string & piece) const;
 
     // True if the token at `id` is a CONTROL-typed entry per the GGUF
     // tokenizer.ggml.token_type array (= TOKEN_TYPE_CONTROL = 3, the
@@ -128,7 +129,7 @@ class Tokenizer {
     // that did not carry a token_type array return false (= "not
     // control"), so this is safe to consult without a per-family
     // token-type guard.
-    bool                is_control(int id) const;
+    bool is_control(int id) const;
 
     // Register a synthesized "special-piece" literal that find() will
     // resolve. Used by source adapters that don't carry every special-
@@ -180,17 +181,21 @@ class Tokenizer {
     //                                  support encoding yet.
     //   TRANSCRIBE_ERR_GGUF            if "gpt2" is loaded without
     //                                  merges (the encoder needs them).
-    transcribe_status encode(const std::string &    text,
-                             std::vector<int32_t> & out_ids) const;
+    transcribe_status encode(const std::string & text, std::vector<int32_t> & out_ids) const;
 
     // Identification + special token ids. -1 if the corresponding key
     // was absent from the GGUF.
     const std::string & model_type() const { return model_; }
+
     const std::string & pretokenizer() const { return pre_; }
-    int                 unk_id   () const { return unk_id_; }
-    int                 bos_id   () const { return bos_id_; }
-    int                 eos_id   () const { return eos_id_; }
-    int                 blank_id () const { return blank_id_; }
+
+    int unk_id() const { return unk_id_; }
+
+    int bos_id() const { return bos_id_; }
+
+    int eos_id() const { return eos_id_; }
+
+    int blank_id() const { return blank_id_; }
 
     // True if encode() is available for this tokenizer. Callers that
     // want to gate a feature on encoder presence can branch on this
@@ -205,7 +210,7 @@ class Tokenizer {
     // strings with a warning.
     void set_pretokenizer(const std::string & pre) { pre_ = pre; }
 
-private:
+  private:
     // How decode() should reassemble token bytes. Set during load().
     //   SentencePiece    - U+2581 → ASCII space (unigram / bpe)
     //   Gpt2ByteUnicode  - invert GPT-2 byte-to-unicode per codepoint
@@ -221,11 +226,11 @@ class Tokenizer {
     };
 
     std::string              model_;
-    std::string              pre_;        // "qwen2" (default) or "gpt2"
+    std::string              pre_;  // "qwen2" (default) or "gpt2"
     DecodeMode               decode_mode_ = DecodeMode::SentencePiece;
     std::vector<std::string> tokens_;
-    std::vector<float>       scores_;     // optional, may be empty
-    std::vector<int32_t>     token_type_; // optional, may be empty
+    std::vector<float>       scores_;      // optional, may be empty
+    std::vector<int32_t>     token_type_;  // optional, may be empty
 
     // O(1) piece -> id lookup built at load time. Duplicates are rare
     // (only from the byte-fallback vocab augmentation); we keep the
@@ -254,4 +259,4 @@ class Tokenizer {
     int blank_id_ = -1;
 };
 
-} // namespace transcribe
+}  // namespace transcribe
diff --git a/src/transcribe-unicode.cpp b/src/transcribe-unicode.cpp
index 192814f5..b7abc3cc 100644
--- a/src/transcribe-unicode.cpp
+++ b/src/transcribe-unicode.cpp
@@ -26,8 +26,8 @@ namespace transcribe::unicode {
 
 namespace data {
 extern const std::initializer_list<std::pair<uint32_t, uint16_t>> ranges_flags;
-extern const std::unordered_set<uint32_t> set_whitespace;
-} // namespace data
+extern const std::unordered_set<uint32_t>                         set_whitespace;
+}  // namespace data
 
 // ---------------------------------------------------------------------------
 // UTF-8 codec.
@@ -80,21 +80,16 @@ uint32_t cpt_from_utf8(const std::string & utf8, size_t & offset) {
         return b0;
     }
     if ((b0 & 0xE0u) == 0xC0u) {
-        if (offset + 1 >= utf8.size() ||
-            (static_cast<uint8_t>(utf8[offset + 1]) & 0xC0u) != 0x80u)
-        {
+        if (offset + 1 >= utf8.size() || (static_cast<uint8_t>(utf8[offset + 1]) & 0xC0u) != 0x80u) {
             throw std::invalid_argument("transcribe::unicode: malformed UTF-8 (2-byte)");
         }
-        uint32_t c = (static_cast<uint32_t>(b0 & 0x1Fu) << 6) |
-                     (static_cast<uint32_t>(utf8[offset + 1]) & 0x3Fu);
+        uint32_t c = (static_cast<uint32_t>(b0 & 0x1Fu) << 6) | (static_cast<uint32_t>(utf8[offset + 1]) & 0x3Fu);
         offset += 2;
         return c;
     }
     if ((b0 & 0xF0u) == 0xE0u) {
-        if (offset + 2 >= utf8.size() ||
-            (static_cast<uint8_t>(utf8[offset + 1]) & 0xC0u) != 0x80u ||
-            (static_cast<uint8_t>(utf8[offset + 2]) & 0xC0u) != 0x80u)
-        {
+        if (offset + 2 >= utf8.size() || (static_cast<uint8_t>(utf8[offset + 1]) & 0xC0u) != 0x80u ||
+            (static_cast<uint8_t>(utf8[offset + 2]) & 0xC0u) != 0x80u) {
             throw std::invalid_argument("transcribe::unicode: malformed UTF-8 (3-byte)");
         }
         uint32_t c = (static_cast<uint32_t>(b0 & 0x0Fu) << 12) |
@@ -104,16 +99,14 @@ uint32_t cpt_from_utf8(const std::string & utf8, size_t & offset) {
         return c;
     }
     if ((b0 & 0xF8u) == 0xF0u) {
-        if (offset + 3 >= utf8.size() ||
-            (static_cast<uint8_t>(utf8[offset + 1]) & 0xC0u) != 0x80u ||
+        if (offset + 3 >= utf8.size() || (static_cast<uint8_t>(utf8[offset + 1]) & 0xC0u) != 0x80u ||
             (static_cast<uint8_t>(utf8[offset + 2]) & 0xC0u) != 0x80u ||
-            (static_cast<uint8_t>(utf8[offset + 3]) & 0xC0u) != 0x80u)
-        {
+            (static_cast<uint8_t>(utf8[offset + 3]) & 0xC0u) != 0x80u) {
             throw std::invalid_argument("transcribe::unicode: malformed UTF-8 (4-byte)");
         }
         uint32_t c = (static_cast<uint32_t>(b0 & 0x07u) << 18) |
                      ((static_cast<uint32_t>(utf8[offset + 1]) & 0x3Fu) << 12) |
-                     ((static_cast<uint32_t>(utf8[offset + 2]) & 0x3Fu) << 6)  |
+                     ((static_cast<uint32_t>(utf8[offset + 2]) & 0x3Fu) << 6) |
                      (static_cast<uint32_t>(utf8[offset + 3]) & 0x3Fu);
         offset += 4;
         return c;
@@ -155,7 +148,7 @@ constexpr uint32_t k_fast_path_limit = 0x10000u;  // BMP only
 
 struct FlagsTable {
     std::vector<std::pair<uint32_t, uint16_t>> ranges;
-    std::vector<uint16_t>                       fast;  // size = k_fast_path_limit
+    std::vector<uint16_t>                      fast;  // size = k_fast_path_limit
 
     FlagsTable() {
         ranges.reserve(data::ranges_flags.size());
@@ -169,11 +162,11 @@ struct FlagsTable {
         // Build the fast-path array.
         fast.assign(k_fast_path_limit, 0);
         for (size_t i = 1; i < ranges.size(); ++i) {
-            const auto begin = ranges[i - 1].first;
-            const auto end   = ranges[i].first;
-            const auto flag  = ranges[i - 1].second;
-            const uint32_t b = begin;
-            const uint32_t e = std::min<uint32_t>(end, k_fast_path_limit);
+            const auto     begin = ranges[i - 1].first;
+            const auto     end   = ranges[i].first;
+            const auto     flag  = ranges[i - 1].second;
+            const uint32_t b     = begin;
+            const uint32_t e     = std::min<uint32_t>(end, k_fast_path_limit);
             for (uint32_t c = b; c < e; ++c) {
                 fast[c] = flag;
             }
@@ -183,8 +176,7 @@ struct FlagsTable {
         }
         for (uint32_t ws : data::set_whitespace) {
             if (ws < k_fast_path_limit) {
-                fast[ws] = static_cast<uint16_t>(
-                    fast[ws] | CptFlags::WHITESPACE);
+                fast[ws] = static_cast<uint16_t>(fast[ws] | CptFlags::WHITESPACE);
             }
         }
     }
@@ -198,8 +190,11 @@ struct FlagsTable {
         size_t hi = ranges.size();
         while (lo + 1 < hi) {
             const size_t mid = (lo + hi) / 2;
-            if (ranges[mid].first <= cpt) lo = mid;
-            else                          hi = mid;
+            if (ranges[mid].first <= cpt) {
+                lo = mid;
+            } else {
+                hi = mid;
+            }
         }
         uint16_t f = ranges[lo].second;
         if (data::set_whitespace.count(cpt)) {
@@ -214,7 +209,7 @@ const FlagsTable & flags_table() {
     return t;
 }
 
-} // namespace
+}  // namespace
 
 CptFlags flags_from_cpt(uint32_t cpt) {
     CptFlags f;
@@ -253,8 +248,8 @@ uint32_t tolower_ascii(uint32_t cpt) {
 namespace {
 
 struct ByteMap {
-    std::string  fwd[256];      // byte -> utf-8 of mapped codepoint
-    uint32_t     cpt[256];      // byte -> mapped codepoint
+    std::string                           fwd[256];  // byte -> utf-8 of mapped codepoint
+    uint32_t                              cpt[256];  // byte -> mapped codepoint
     // Inverse: the mapped codepoints are dense in two ranges
     // (0x21..0xFF minus 0x7F/0xAD, plus 0x0100..0x0142). We pack the
     // inverse into a small open-addressing map keyed by codepoint.
@@ -264,12 +259,18 @@ struct ByteMap {
         // Build the "visible" byte list (bs) and the codepoint list (cs).
         std::vector<int> bs;
         bs.reserve(256);
-        for (int b = '!'; b <= '~';  ++b) bs.push_back(b);
-        for (int b = 0xA1; b <= 0xAC; ++b) bs.push_back(b);
-        for (int b = 0xAE; b <= 0xFF; ++b) bs.push_back(b);
+        for (int b = '!'; b <= '~'; ++b) {
+            bs.push_back(b);
+        }
+        for (int b = 0xA1; b <= 0xAC; ++b) {
+            bs.push_back(b);
+        }
+        for (int b = 0xAE; b <= 0xFF; ++b) {
+            bs.push_back(b);
+        }
 
         std::vector<int> cs = bs;
-        int n = 0;
+        int              n  = 0;
         for (int b = 0; b < 256; ++b) {
             if (std::find(bs.begin(), bs.end(), b) == bs.end()) {
                 bs.push_back(b);
@@ -281,8 +282,8 @@ struct ByteMap {
         for (size_t i = 0; i < bs.size(); ++i) {
             const uint8_t  byte = static_cast<uint8_t>(bs[i]);
             const uint32_t c    = static_cast<uint32_t>(cs[i]);
-            fwd[byte] = cpt_to_utf8(c);
-            cpt[byte] = c;
+            fwd[byte]           = cpt_to_utf8(c);
+            cpt[byte]           = c;
             inv.emplace(c, byte);
         }
     }
@@ -293,25 +294,31 @@ const ByteMap & byte_map() {
     return m;
 }
 
-} // namespace
+}  // namespace
 
 std::string byte_to_unicode(uint8_t byte) {
     return byte_map().fwd[byte];
 }
 
 int unicode_to_byte(const std::string & utf8) {
-    if (utf8.empty()) return -1;
-    size_t off = 0;
+    if (utf8.empty()) {
+        return -1;
+    }
+    size_t   off = 0;
     uint32_t c;
     try {
         c = cpt_from_utf8(utf8, off);
     } catch (const std::invalid_argument &) {
         return -1;
     }
-    if (off != utf8.size()) return -1;  // must be a single-codepoint piece
-    const auto & m = byte_map().inv;
-    const auto it = m.find(c);
-    if (it == m.end()) return -1;
+    if (off != utf8.size()) {
+        return -1;  // must be a single-codepoint piece
+    }
+    const auto & m  = byte_map().inv;
+    const auto   it = m.find(c);
+    if (it == m.end()) {
+        return -1;
+    }
     return static_cast<int>(it->second);
 }
 
@@ -335,10 +342,7 @@ constexpr uint32_t OOR = 0xFFFFFFFFu;
 // special-token partition step -- our inputs never contain <|...|>
 // special tokens (those live in the chat template ids we resolve
 // out of band).
-std::vector<size_t> qwen2_split_offsets(const std::vector<uint32_t> & cpts,
-                                        size_t begin,
-                                        size_t end)
-{
+std::vector<size_t> qwen2_split_offsets(const std::vector<uint32_t> & cpts, size_t begin, size_t end) {
     std::vector<size_t> out;
 
     auto get_cpt = [&](size_t p) -> uint32_t {
@@ -348,8 +352,8 @@ std::vector<size_t> qwen2_split_offsets(const std::vector<uint32_t> & cpts,
         return (begin <= p && p < end) ? flags_from_cpt(cpts[p]) : CptFlags{};
     };
 
-    size_t prev = begin;
-    auto push_upto = [&](size_t p) {
+    size_t prev      = begin;
+    auto   push_upto = [&](size_t p) {
         assert(prev <= p && p <= end);
         if (p > prev) {
             out.push_back(p);
@@ -372,10 +376,7 @@ std::vector<size_t> qwen2_split_offsets(const std::vector<uint32_t> & cpts,
             }
             if (pos + 2 < end) {
                 const uint32_t c2 = tolower_ascii(get_cpt(pos + 2));
-                if ((c1 == 'r' && c2 == 'e') ||
-                    (c1 == 'v' && c2 == 'e') ||
-                    (c1 == 'l' && c2 == 'l'))
-                {
+                if ((c1 == 'r' && c2 == 'e') || (c1 == 'v' && c2 == 'e') || (c1 == 'l' && c2 == 'l')) {
                     pos += 3;
                     push_upto(pos);
                     continue;
@@ -427,8 +428,8 @@ std::vector<size_t> qwen2_split_offsets(const std::vector<uint32_t> & cpts,
         }
 
         // Whitespace handling: \s*[\r\n]+ | \s+(?!\S) | \s+
-        size_t ws_count       = 0;
-        size_t last_after_nl  = 0;  // "end-of-\s*[\r\n]+" if any
+        size_t ws_count      = 0;
+        size_t last_after_nl = 0;  // "end-of-\s*[\r\n]+" if any
         while (get_flags(pos + ws_count).is_whitespace()) {
             const uint32_t cw = get_cpt(pos + ws_count);
             if (cw == '\r' || cw == '\n') {
@@ -466,7 +467,7 @@ std::vector<size_t> qwen2_split_offsets(const std::vector<uint32_t> & cpts,
     return out;
 }
 
-} // namespace
+}  // namespace
 
 std::vector<std::string> pretokenize_qwen2(const std::string & text) {
     std::vector<std::string> out;
@@ -508,10 +509,7 @@ namespace {
 // tokenizers crate's interpretation of the granite tokenizer.json
 // regex (`tokenizers` Rust regex engine does not consume the
 // `[\r\n]*` here even though the Python `regex` module does).
-std::vector<size_t> granite_split_offsets(const std::vector<uint32_t> & cpts,
-                                          size_t begin,
-                                          size_t end)
-{
+std::vector<size_t> granite_split_offsets(const std::vector<uint32_t> & cpts, size_t begin, size_t end) {
     std::vector<size_t> out;
 
     auto get_cpt = [&](size_t p) -> uint32_t {
@@ -521,8 +519,8 @@ std::vector<size_t> granite_split_offsets(const std::vector<uint32_t> & cpts,
         return (begin <= p && p < end) ? flags_from_cpt(cpts[p]) : CptFlags{};
     };
 
-    size_t prev = begin;
-    auto push_upto = [&](size_t p) {
+    size_t prev      = begin;
+    auto   push_upto = [&](size_t p) {
         assert(prev <= p && p <= end);
         if (p > prev) {
             out.push_back(p);
@@ -545,10 +543,7 @@ std::vector<size_t> granite_split_offsets(const std::vector<uint32_t> & cpts,
             }
             if (pos + 2 < end) {
                 const uint32_t c2 = tolower_ascii(get_cpt(pos + 2));
-                if ((c1 == 'r' && c2 == 'e') ||
-                    (c1 == 'v' && c2 == 'e') ||
-                    (c1 == 'l' && c2 == 'l'))
-                {
+                if ((c1 == 'r' && c2 == 'e') || (c1 == 'v' && c2 == 'e') || (c1 == 'l' && c2 == 'l')) {
                     pos += 3;
                     push_upto(pos);
                     continue;
@@ -574,7 +569,9 @@ std::vector<size_t> granite_split_offsets(const std::vector<uint32_t> & cpts,
         // up to 3; HF granite uses {1,3}).
         if (flags.is_number()) {
             size_t n = 0;
-            while (n < 3 && get_flags(pos + n).is_number()) ++n;
+            while (n < 3 && get_flags(pos + n).is_number()) {
+                ++n;
+            }
             pos += n;
             push_upto(pos);
             continue;
@@ -599,8 +596,8 @@ std::vector<size_t> granite_split_offsets(const std::vector<uint32_t> & cpts,
         }
 
         // Whitespace handling: \s*[\r\n]+ | \s+(?!\S) | \s+
-        size_t ws_count       = 0;
-        size_t last_after_nl  = 0;
+        size_t ws_count      = 0;
+        size_t last_after_nl = 0;
         while (get_flags(pos + ws_count).is_whitespace()) {
             const uint32_t cw = get_cpt(pos + ws_count);
             if (cw == '\r' || cw == '\n') {
@@ -632,7 +629,7 @@ std::vector<size_t> granite_split_offsets(const std::vector<uint32_t> & cpts,
     return out;
 }
 
-} // namespace
+}  // namespace
 
 std::vector<std::string> pretokenize_granite(const std::string & text) {
     std::vector<std::string> out;
@@ -671,10 +668,7 @@ std::vector<std::string> pretokenize_granite(const std::string & text) {
 
 namespace {
 
-std::vector<size_t> gpt2_split_offsets(const std::vector<uint32_t> & cpts,
-                                      size_t begin,
-                                      size_t end)
-{
+std::vector<size_t> gpt2_split_offsets(const std::vector<uint32_t> & cpts, size_t begin, size_t end) {
     std::vector<size_t> out;
 
     auto get_cpt = [&](size_t p) -> uint32_t {
@@ -684,8 +678,8 @@ std::vector<size_t> gpt2_split_offsets(const std::vector<uint32_t> & cpts,
         return (begin <= p && p < end) ? flags_from_cpt(cpts[p]) : CptFlags{};
     };
 
-    size_t prev = begin;
-    auto push_upto = [&](size_t p) {
+    size_t prev      = begin;
+    auto   push_upto = [&](size_t p) {
         assert(prev <= p && p <= end);
         if (p > prev) {
             out.push_back(p);
@@ -708,10 +702,7 @@ std::vector<size_t> gpt2_split_offsets(const std::vector<uint32_t> & cpts,
             }
             if (pos + 2 < end) {
                 const uint32_t c2 = get_cpt(pos + 2);
-                if ((c1 == 'r' && c2 == 'e') ||
-                    (c1 == 'v' && c2 == 'e') ||
-                    (c1 == 'l' && c2 == 'l'))
-                {
+                if ((c1 == 'r' && c2 == 'e') || (c1 == 'v' && c2 == 'e') || (c1 == 'l' && c2 == 'l')) {
                     pos += 3;
                     push_upto(pos);
                     continue;
@@ -721,11 +712,13 @@ std::vector<size_t> gpt2_split_offsets(const std::vector<uint32_t> & cpts,
 
         // 2. Optional leading space + letter run:   ?\p{L}+
         {
-            const bool leading_space = (cpt == ' ');
-            const size_t body = pos + (leading_space ? 1 : 0);
+            const bool   leading_space = (cpt == ' ');
+            const size_t body          = pos + (leading_space ? 1 : 0);
             if (get_flags(body).is_letter()) {
                 size_t q = body;
-                while (get_flags(q).is_letter()) ++q;
+                while (get_flags(q).is_letter()) {
+                    ++q;
+                }
                 pos = q;
                 push_upto(pos);
                 continue;
@@ -736,11 +729,13 @@ std::vector<size_t> gpt2_split_offsets(const std::vector<uint32_t> & cpts,
         //    This is the bit that matters for Whisper parity with HF
         //    — Qwen2 emits one pretoken per digit, GPT-2 merges the run.
         {
-            const bool leading_space = (cpt == ' ');
-            const size_t body = pos + (leading_space ? 1 : 0);
+            const bool   leading_space = (cpt == ' ');
+            const size_t body          = pos + (leading_space ? 1 : 0);
             if (get_flags(body).is_number()) {
                 size_t q = body;
-                while (get_flags(q).is_number()) ++q;
+                while (get_flags(q).is_number()) {
+                    ++q;
+                }
                 pos = q;
                 push_upto(pos);
                 continue;
@@ -751,20 +746,16 @@ std::vector<size_t> gpt2_split_offsets(const std::vector<uint32_t> & cpts,
         //    "Symbols and punctuation", roughly. Stops as soon as a
         //    whitespace / letter / digit / OOR codepoint appears.
         {
-            const bool leading_space = (cpt == ' ');
-            const size_t body = pos + (leading_space ? 1 : 0);
-            const CptFlags fb = get_flags(body);
-            const bool body_ok =
-                body < end &&
-                !fb.is_whitespace() && !fb.is_letter() && !fb.is_number() &&
-                fb.has_category();
+            const bool     leading_space = (cpt == ' ');
+            const size_t   body          = pos + (leading_space ? 1 : 0);
+            const CptFlags fb            = get_flags(body);
+            const bool     body_ok =
+                body < end && !fb.is_whitespace() && !fb.is_letter() && !fb.is_number() && fb.has_category();
             if (body_ok) {
                 size_t q = body;
                 while (q < end) {
                     const CptFlags fx = get_flags(q);
-                    if (fx.is_whitespace() || fx.is_letter() || fx.is_number() ||
-                        !fx.has_category())
-                    {
+                    if (fx.is_whitespace() || fx.is_letter() || fx.is_number() || !fx.has_category()) {
                         break;
                     }
                     ++q;
@@ -799,10 +790,11 @@ std::vector<size_t> gpt2_split_offsets(const std::vector<uint32_t> & cpts,
         //    space of the following letter/number/symbol pretoken).
         if (get_flags(pos).is_whitespace()) {
             size_t q = pos;
-            while (q < end && get_flags(q).is_whitespace()) ++q;
+            while (q < end && get_flags(q).is_whitespace()) {
+                ++q;
+            }
             // q is the end of the full whitespace run.
-            const bool followed_by_nonspace =
-                (q < end) && !get_flags(q).is_whitespace();
+            const bool followed_by_nonspace = (q < end) && !get_flags(q).is_whitespace();
             if (followed_by_nonspace) {
                 // Emit one pretoken per whitespace codepoint up to the
                 // second-to-last. The final whitespace is left for
@@ -847,7 +839,7 @@ std::vector<size_t> gpt2_split_offsets(const std::vector<uint32_t> & cpts,
     return out;
 }
 
-} // namespace
+}  // namespace
 
 std::vector<std::string> pretokenize_gpt2(const std::string & text) {
     std::vector<std::string> out;
@@ -896,4 +888,4 @@ std::vector<std::string> pretokenize_gpt2_raw_bytes(const std::string & text) {
     return out;
 }
 
-} // namespace transcribe::unicode
+}  // namespace transcribe::unicode
diff --git a/src/transcribe-unicode.h b/src/transcribe-unicode.h
index 655261e0..82fad06f 100644
--- a/src/transcribe-unicode.h
+++ b/src/transcribe-unicode.h
@@ -44,16 +44,18 @@ struct CptFlags {
 
     uint16_t bits = 0;
 
-    bool is_letter     () const { return (bits & LETTER)      != 0; }
-    bool is_number     () const { return (bits & NUMBER)      != 0; }
-    bool is_whitespace () const { return (bits & WHITESPACE)  != 0; }
+    bool is_letter() const { return (bits & LETTER) != 0; }
+
+    bool is_number() const { return (bits & NUMBER) != 0; }
+
+    bool is_whitespace() const { return (bits & WHITESPACE) != 0; }
 
     // True if any category bit in MASK_CATEGORIES (the low byte) is
     // set. Mirrors unicode_cpt_flags::as_uint() & MASK_CATEGORIES != 0
     // from llama.cpp. Used by the pretokenizer to distinguish "known
     // character in some category" from "undefined / outside the
     // ranges we care about" (OOR codepoints get bits=0 at lookup).
-    bool has_category  () const { return (bits & 0x00FFu)     != 0; }
+    bool has_category() const { return (bits & 0x00FFu) != 0; }
 };
 
 // UTF-8 codec. Mirrors the narrow subset of llama.cpp's unicode.cpp
@@ -61,8 +63,8 @@ struct CptFlags {
 // std::invalid_argument; callers only pass text that already made it
 // through the GGUF tokenizer / Python reference, so the throw guards a
 // programming bug rather than a user-facing error path.
-std::string           cpt_to_utf8   (uint32_t cpt);
-uint32_t              cpt_from_utf8 (const std::string & utf8, size_t & offset);
+std::string           cpt_to_utf8(uint32_t cpt);
+uint32_t              cpt_from_utf8(const std::string & utf8, size_t & offset);
 std::vector<uint32_t> cpts_from_utf8(const std::string & utf8);
 
 // Length in bytes of the UTF-8 sequence whose leading byte is `c`.
@@ -170,4 +172,4 @@ std::vector<std::string> pretokenize_gpt2_raw_bytes(const std::string & text);
 // pretokenizer we'd emit 5380 where the reference produces (30, 198).
 std::vector<std::string> pretokenize_granite(const std::string & text);
 
-} // namespace transcribe::unicode
+}  // namespace transcribe::unicode
diff --git a/src/transcribe-weights-util.cpp b/src/transcribe-weights-util.cpp
index 0fee0e77..594f8401 100644
--- a/src/transcribe-weights-util.cpp
+++ b/src/transcribe-weights-util.cpp
@@ -4,20 +4,19 @@
 // for rationale.
 
 #include "transcribe-weights-util.h"
-#include "transcribe-log.h"
 
 #include "ggml.h"
+#include "transcribe-log.h"
 
 #include <cstdio>
 
 namespace transcribe::weights {
 
-ggml_tensor * find_tensor(ggml_context *                    ctx_meta,
-                          const char *                      name,
-                          std::initializer_list<ggml_type>  allowed_types,
-                          std::initializer_list<int64_t>    expected_ne,
-                          const char *                      error_tag)
-{
+ggml_tensor * find_tensor(ggml_context *                   ctx_meta,
+                          const char *                     name,
+                          std::initializer_list<ggml_type> allowed_types,
+                          std::initializer_list<int64_t>   expected_ne,
+                          const char *                     error_tag) {
     ggml_tensor * t = ggml_get_tensor(ctx_meta, name);
     if (t == nullptr) {
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: missing tensor \"%s\"", error_tag, name);
@@ -34,14 +33,12 @@ ggml_tensor * find_tensor(ggml_context *                    ctx_meta,
     if (!type_ok) {
         // Build a short human-readable list of allowed types for the
         // diagnostic. Stack buffer is plenty for 1-12 allowed types.
-        char allowed_buf[192] = {0};
-        size_t off = 0;
-        bool first = true;
+        char   allowed_buf[192] = { 0 };
+        size_t off              = 0;
+        bool   first            = true;
         for (ggml_type allowed : allowed_types) {
             const char * tn = ggml_type_name(allowed);
-            const int n = std::snprintf(allowed_buf + off,
-                                        sizeof(allowed_buf) - off,
-                                        "%s%s", first ? "" : ",", tn);
+            const int    n  = std::snprintf(allowed_buf + off, sizeof(allowed_buf) - off, "%s%s", first ? "" : ",", tn);
             if (n < 0 || static_cast<size_t>(n) >= sizeof(allowed_buf) - off) {
                 break;
             }
@@ -49,17 +46,15 @@ ggml_tensor * find_tensor(ggml_context *                    ctx_meta,
             first = false;
         }
         log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "%s: tensor \"%s\" type mismatch: "
-                     "expected one of {%s}, got %s",
-                     error_tag, name, allowed_buf, ggml_type_name(t->type));
+                "%s: tensor \"%s\" type mismatch: "
+                "expected one of {%s}, got %s",
+                error_tag, name, allowed_buf, ggml_type_name(t->type));
         return nullptr;
     }
 
     const size_t n_expected = expected_ne.size();
     if (n_expected == 0 || n_expected > GGML_MAX_DIMS) {
-        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                     "%s: bad expected_ne size %zu for \"%s\"",
-                     error_tag, n_expected, name);
+        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "%s: bad expected_ne size %zu for \"%s\"", error_tag, n_expected, name);
         return nullptr;
     }
 
@@ -67,11 +62,9 @@ ggml_tensor * find_tensor(ggml_context *                    ctx_meta,
     for (size_t i = 0; i < n_expected; ++i, ++it) {
         if (t->ne[i] != *it) {
             log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "%s: tensor \"%s\" shape mismatch: "
-                         "expected ne[%zu]=%lld, got %lld",
-                         error_tag, name, i,
-                         static_cast<long long>(*it),
-                         static_cast<long long>(t->ne[i]));
+                    "%s: tensor \"%s\" shape mismatch: "
+                    "expected ne[%zu]=%lld, got %lld",
+                    error_tag, name, i, static_cast<long long>(*it), static_cast<long long>(t->ne[i]));
             return nullptr;
         }
     }
@@ -81,10 +74,9 @@ ggml_tensor * find_tensor(ggml_context *                    ctx_meta,
     for (size_t i = n_expected; i < GGML_MAX_DIMS; ++i) {
         if (t->ne[i] != 1) {
             log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "%s: tensor \"%s\" has unexpected non-1 "
-                         "ne[%zu]=%lld (rank too high)",
-                         error_tag, name, i,
-                         static_cast<long long>(t->ne[i]));
+                    "%s: tensor \"%s\" has unexpected non-1 "
+                    "ne[%zu]=%lld (rank too high)",
+                    error_tag, name, i, static_cast<long long>(t->ne[i]));
             return nullptr;
         }
     }
@@ -92,4 +84,4 @@ ggml_tensor * find_tensor(ggml_context *                    ctx_meta,
     return t;
 }
 
-} // namespace transcribe::weights
+}  // namespace transcribe::weights
diff --git a/src/transcribe-weights-util.h b/src/transcribe-weights-util.h
index 57c072f8..50f3c1e3 100644
--- a/src/transcribe-weights-util.h
+++ b/src/transcribe-weights-util.h
@@ -47,15 +47,11 @@
 // expansion (rather than a constexpr array) keeps the existing
 // find_tensor signature (std::initializer_list<ggml_type>) untouched.
 
-#define TRANSCRIBE_QUANT_LINEAR_TYPES                                        \
-    GGML_TYPE_F32,  GGML_TYPE_F16,  GGML_TYPE_BF16,                          \
-    GGML_TYPE_Q4_0, GGML_TYPE_Q4_1,                                          \
-    GGML_TYPE_Q5_0, GGML_TYPE_Q5_1,                                          \
-    GGML_TYPE_Q8_0,                                                          \
-    GGML_TYPE_Q4_K, GGML_TYPE_Q5_K, GGML_TYPE_Q6_K
+#define TRANSCRIBE_QUANT_LINEAR_TYPES                                                                             \
+    GGML_TYPE_F32, GGML_TYPE_F16, GGML_TYPE_BF16, GGML_TYPE_Q4_0, GGML_TYPE_Q4_1, GGML_TYPE_Q5_0, GGML_TYPE_Q5_1, \
+        GGML_TYPE_Q8_0, GGML_TYPE_Q4_K, GGML_TYPE_Q5_K, GGML_TYPE_Q6_K
 
-#define TRANSCRIBE_QUANT_CONV_TYPES                                          \
-    GGML_TYPE_F32, GGML_TYPE_F16
+#define TRANSCRIBE_QUANT_CONV_TYPES GGML_TYPE_F32, GGML_TYPE_F16
 
 namespace transcribe::weights {
 
@@ -70,11 +66,11 @@ namespace transcribe::weights {
 // returns nullptr. The lookup is purely against `ctx_meta`; the source
 // (a real GGUF on disk, or an in-memory legacy whisper.cpp .bin
 // adapter) is invisible at this layer.
-ggml_tensor * find_tensor(ggml_context *                    ctx_meta,
-                          const char *                      name,
-                          std::initializer_list<ggml_type>  allowed_types,
-                          std::initializer_list<int64_t>    expected_ne,
-                          const char *                      error_tag);
+ggml_tensor * find_tensor(ggml_context *                   ctx_meta,
+                          const char *                     name,
+                          std::initializer_list<ggml_type> allowed_types,
+                          std::initializer_list<int64_t>   expected_ne,
+                          const char *                     error_tag);
 
 // Format a per-layer tensor name. The caller passes a printf fmt
 // containing exactly one %d; the layer index is substituted. Returns
@@ -88,4 +84,4 @@ inline const char * lname(const char * fmt, int layer_idx) {
     return buf;
 }
 
-} // namespace transcribe::weights
+}  // namespace transcribe::weights
diff --git a/src/transcribe.cpp b/src/transcribe.cpp
index 47723963..1d861e66 100644
--- a/src/transcribe.cpp
+++ b/src/transcribe.cpp
@@ -14,32 +14,30 @@
 // load(), init_context(), and run().
 
 #include "transcribe.h"
-#include "transcribe/whisper.h"
 
+#include "arch/whisper/bin_load.h"
+#include "ggml-backend.h"
+#include "ggml.h"  // ggml_log_set: route ggml diagnostics into our sink
 #include "transcribe-abi.h"
 #include "transcribe-arch.h"
 #include "transcribe-backend.h"
-#include "transcribe-log.h"
-#include "transcribe-session.h"
 #include "transcribe-loader.h"
-
-#include "ggml.h"          // ggml_log_set: route ggml diagnostics into our sink
-#include "ggml-backend.h"
+#include "transcribe-log.h"
 #include "transcribe-model.h"
+#include "transcribe-session.h"
 #include "transcribe-tokenizer.h"
-
-#include "arch/whisper/bin_load.h"
+#include "transcribe/whisper.h"
 
 #if defined(TRANSCRIBE_GGML_BACKEND_DL) && defined(_WIN32)
-#ifndef WIN32_LEAN_AND_MEAN
-#define WIN32_LEAN_AND_MEAN
-#endif
-#ifndef NOMINMAX
-#define NOMINMAX
-#endif
-#include <windows.h>
+#    ifndef WIN32_LEAN_AND_MEAN
+#        define WIN32_LEAN_AND_MEAN
+#    endif
+#    ifndef NOMINMAX
+#        define NOMINMAX
+#    endif
+#    include <windows.h>
 #elif defined(TRANSCRIBE_GGML_BACKEND_DL)
-#include <dlfcn.h>
+#    include <dlfcn.h>
 #endif
 
 #include <sys/stat.h>
@@ -47,7 +45,7 @@
 // MSVC's <sys/stat.h> has the _S_IFDIR mode bits but not the POSIX
 // S_ISDIR() macro.
 #if defined(_WIN32) && !defined(S_ISDIR)
-#define S_ISDIR(m) (((m) & _S_IFMT) == _S_IFDIR)
+#    define S_ISDIR(m) (((m) & _S_IFMT) == _S_IFDIR)
 #endif
 
 #include <algorithm>
@@ -75,27 +73,46 @@
 // above the declaration in include/transcribe.h.
 extern "C" const char * transcribe_status_string(int status) {
     switch (status) {
-        case TRANSCRIBE_OK:                       return "ok";
-        case TRANSCRIBE_ERR_INVALID_ARG:          return "invalid argument";
-        case TRANSCRIBE_ERR_NOT_IMPLEMENTED:      return "not implemented";
-        case TRANSCRIBE_ERR_FILE_NOT_FOUND:       return "file not found";
-        case TRANSCRIBE_ERR_GGUF:                 return "gguf load error";
-        case TRANSCRIBE_ERR_UNSUPPORTED_ARCH:     return "unsupported architecture";
-        case TRANSCRIBE_ERR_UNSUPPORTED_VARIANT:  return "unsupported variant";
-        case TRANSCRIBE_ERR_OOM:                  return "out of memory";
-        case TRANSCRIBE_ERR_BACKEND:              return "backend error";
-        case TRANSCRIBE_ERR_SAMPLE_RATE:          return "sample rate mismatch";
-        case TRANSCRIBE_ERR_UNSUPPORTED_LANGUAGE: return "unsupported language";
-        case TRANSCRIBE_ERR_UNSUPPORTED_TASK:     return "unsupported task";
+        case TRANSCRIBE_OK:
+            return "ok";
+        case TRANSCRIBE_ERR_INVALID_ARG:
+            return "invalid argument";
+        case TRANSCRIBE_ERR_NOT_IMPLEMENTED:
+            return "not implemented";
+        case TRANSCRIBE_ERR_FILE_NOT_FOUND:
+            return "file not found";
+        case TRANSCRIBE_ERR_GGUF:
+            return "gguf load error";
+        case TRANSCRIBE_ERR_UNSUPPORTED_ARCH:
+            return "unsupported architecture";
+        case TRANSCRIBE_ERR_UNSUPPORTED_VARIANT:
+            return "unsupported variant";
+        case TRANSCRIBE_ERR_OOM:
+            return "out of memory";
+        case TRANSCRIBE_ERR_BACKEND:
+            return "backend error";
+        case TRANSCRIBE_ERR_SAMPLE_RATE:
+            return "sample rate mismatch";
+        case TRANSCRIBE_ERR_UNSUPPORTED_LANGUAGE:
+            return "unsupported language";
+        case TRANSCRIBE_ERR_UNSUPPORTED_TASK:
+            return "unsupported task";
         case TRANSCRIBE_ERR_UNSUPPORTED_TIMESTAMPS:
-                                                  return "unsupported timestamp granularity";
-        case TRANSCRIBE_ERR_ABORTED:              return "aborted by callback";
-        case TRANSCRIBE_ERR_BAD_STRUCT_SIZE:      return "caller-owned struct missing or has bad struct_size";
-        case TRANSCRIBE_ERR_UNSUPPORTED_PNC:      return "model does not support runtime PNC control (reserved; not currently returned)";
-        case TRANSCRIBE_ERR_UNSUPPORTED_ITN:      return "model does not support runtime ITN control (reserved; not currently returned)";
-        case TRANSCRIBE_ERR_INPUT_TOO_LONG:       return "input audio too long for model context";
-        case TRANSCRIBE_ERR_OUTPUT_TRUNCATED:     return "output truncated: decode hit the context/generation cap before end-of-stream";
-        default:                                  return "unknown status";
+            return "unsupported timestamp granularity";
+        case TRANSCRIBE_ERR_ABORTED:
+            return "aborted by callback";
+        case TRANSCRIBE_ERR_BAD_STRUCT_SIZE:
+            return "caller-owned struct missing or has bad struct_size";
+        case TRANSCRIBE_ERR_UNSUPPORTED_PNC:
+            return "model does not support runtime PNC control (reserved; not currently returned)";
+        case TRANSCRIBE_ERR_UNSUPPORTED_ITN:
+            return "model does not support runtime ITN control (reserved; not currently returned)";
+        case TRANSCRIBE_ERR_INPUT_TOO_LONG:
+            return "input audio too long for model context";
+        case TRANSCRIBE_ERR_OUTPUT_TRUNCATED:
+            return "output truncated: decode hit the context/generation cap before end-of-stream";
+        default:
+            return "unknown status";
     }
 }
 
@@ -105,7 +122,7 @@ extern "C" const char * transcribe_status_string(int status) {
 // configure time); fall back to "unknown" so the accessor never returns
 // NULL. TRANSCRIBE_VERSION comes from <transcribe.h>.
 #ifndef TRANSCRIBE_COMMIT
-#define TRANSCRIBE_COMMIT "unknown"
+#    define TRANSCRIBE_COMMIT "unknown"
 #endif
 
 extern "C" const char * transcribe_version(void) {
@@ -129,6 +146,7 @@ static inline int enum_field_raw(const void * field) {
     std::memcpy(&raw, field, sizeof(raw));
     return raw;
 }
+
 static_assert(sizeof(transcribe_backend_request) == sizeof(int),
               "public enums must be int-sized for raw boundary reads");
 
@@ -138,40 +156,68 @@ static_assert(sizeof(transcribe_backend_request) == sizeof(int),
 
 extern "C" size_t transcribe_abi_struct_size(transcribe_abi_struct which) {
     switch (enum_field_raw(&which)) {
-        case TRANSCRIBE_ABI_MODEL_LOAD_PARAMS: return sizeof(struct transcribe_model_load_params);
-        case TRANSCRIBE_ABI_SESSION_PARAMS:    return sizeof(struct transcribe_session_params);
-        case TRANSCRIBE_ABI_RUN_PARAMS:        return sizeof(struct transcribe_run_params);
-        case TRANSCRIBE_ABI_STREAM_PARAMS:     return sizeof(struct transcribe_stream_params);
-        case TRANSCRIBE_ABI_CAPABILITIES:      return sizeof(struct transcribe_capabilities);
-        case TRANSCRIBE_ABI_TIMINGS:           return sizeof(struct transcribe_timings);
-        case TRANSCRIBE_ABI_SEGMENT:           return sizeof(struct transcribe_segment);
-        case TRANSCRIBE_ABI_WORD:              return sizeof(struct transcribe_word);
-        case TRANSCRIBE_ABI_TOKEN:             return sizeof(struct transcribe_token);
-        case TRANSCRIBE_ABI_STREAM_UPDATE:     return sizeof(struct transcribe_stream_update);
-        case TRANSCRIBE_ABI_STREAM_TEXT:       return sizeof(struct transcribe_stream_text);
-        case TRANSCRIBE_ABI_SESSION_LIMITS:    return sizeof(struct transcribe_session_limits);
-        case TRANSCRIBE_ABI_EXT:               return sizeof(struct transcribe_ext);
-        case TRANSCRIBE_ABI_BACKEND_DEVICE:    return sizeof(struct transcribe_backend_device);
+        case TRANSCRIBE_ABI_MODEL_LOAD_PARAMS:
+            return sizeof(struct transcribe_model_load_params);
+        case TRANSCRIBE_ABI_SESSION_PARAMS:
+            return sizeof(struct transcribe_session_params);
+        case TRANSCRIBE_ABI_RUN_PARAMS:
+            return sizeof(struct transcribe_run_params);
+        case TRANSCRIBE_ABI_STREAM_PARAMS:
+            return sizeof(struct transcribe_stream_params);
+        case TRANSCRIBE_ABI_CAPABILITIES:
+            return sizeof(struct transcribe_capabilities);
+        case TRANSCRIBE_ABI_TIMINGS:
+            return sizeof(struct transcribe_timings);
+        case TRANSCRIBE_ABI_SEGMENT:
+            return sizeof(struct transcribe_segment);
+        case TRANSCRIBE_ABI_WORD:
+            return sizeof(struct transcribe_word);
+        case TRANSCRIBE_ABI_TOKEN:
+            return sizeof(struct transcribe_token);
+        case TRANSCRIBE_ABI_STREAM_UPDATE:
+            return sizeof(struct transcribe_stream_update);
+        case TRANSCRIBE_ABI_STREAM_TEXT:
+            return sizeof(struct transcribe_stream_text);
+        case TRANSCRIBE_ABI_SESSION_LIMITS:
+            return sizeof(struct transcribe_session_limits);
+        case TRANSCRIBE_ABI_EXT:
+            return sizeof(struct transcribe_ext);
+        case TRANSCRIBE_ABI_BACKEND_DEVICE:
+            return sizeof(struct transcribe_backend_device);
     }
     return 0;  // unknown id: "cannot verify", never a real size
 }
 
 extern "C" size_t transcribe_abi_struct_align(transcribe_abi_struct which) {
     switch (enum_field_raw(&which)) {
-        case TRANSCRIBE_ABI_MODEL_LOAD_PARAMS: return alignof(struct transcribe_model_load_params);
-        case TRANSCRIBE_ABI_SESSION_PARAMS:    return alignof(struct transcribe_session_params);
-        case TRANSCRIBE_ABI_RUN_PARAMS:        return alignof(struct transcribe_run_params);
-        case TRANSCRIBE_ABI_STREAM_PARAMS:     return alignof(struct transcribe_stream_params);
-        case TRANSCRIBE_ABI_CAPABILITIES:      return alignof(struct transcribe_capabilities);
-        case TRANSCRIBE_ABI_TIMINGS:           return alignof(struct transcribe_timings);
-        case TRANSCRIBE_ABI_SEGMENT:           return alignof(struct transcribe_segment);
-        case TRANSCRIBE_ABI_WORD:              return alignof(struct transcribe_word);
-        case TRANSCRIBE_ABI_TOKEN:             return alignof(struct transcribe_token);
-        case TRANSCRIBE_ABI_STREAM_UPDATE:     return alignof(struct transcribe_stream_update);
-        case TRANSCRIBE_ABI_STREAM_TEXT:       return alignof(struct transcribe_stream_text);
-        case TRANSCRIBE_ABI_SESSION_LIMITS:    return alignof(struct transcribe_session_limits);
-        case TRANSCRIBE_ABI_EXT:               return alignof(struct transcribe_ext);
-        case TRANSCRIBE_ABI_BACKEND_DEVICE:    return alignof(struct transcribe_backend_device);
+        case TRANSCRIBE_ABI_MODEL_LOAD_PARAMS:
+            return alignof(struct transcribe_model_load_params);
+        case TRANSCRIBE_ABI_SESSION_PARAMS:
+            return alignof(struct transcribe_session_params);
+        case TRANSCRIBE_ABI_RUN_PARAMS:
+            return alignof(struct transcribe_run_params);
+        case TRANSCRIBE_ABI_STREAM_PARAMS:
+            return alignof(struct transcribe_stream_params);
+        case TRANSCRIBE_ABI_CAPABILITIES:
+            return alignof(struct transcribe_capabilities);
+        case TRANSCRIBE_ABI_TIMINGS:
+            return alignof(struct transcribe_timings);
+        case TRANSCRIBE_ABI_SEGMENT:
+            return alignof(struct transcribe_segment);
+        case TRANSCRIBE_ABI_WORD:
+            return alignof(struct transcribe_word);
+        case TRANSCRIBE_ABI_TOKEN:
+            return alignof(struct transcribe_token);
+        case TRANSCRIBE_ABI_STREAM_UPDATE:
+            return alignof(struct transcribe_stream_update);
+        case TRANSCRIBE_ABI_STREAM_TEXT:
+            return alignof(struct transcribe_stream_text);
+        case TRANSCRIBE_ABI_SESSION_LIMITS:
+            return alignof(struct transcribe_session_limits);
+        case TRANSCRIBE_ABI_EXT:
+            return alignof(struct transcribe_ext);
+        case TRANSCRIBE_ABI_BACKEND_DEVICE:
+            return alignof(struct transcribe_backend_device);
     }
     return 0;
 }
@@ -183,11 +229,16 @@ namespace {
 // any unknown value get rank -1.
 int timestamp_rank(transcribe_timestamp_kind k) {
     switch (k) {
-        case TRANSCRIBE_TIMESTAMPS_NONE:    return 0;
-        case TRANSCRIBE_TIMESTAMPS_SEGMENT: return 1;
-        case TRANSCRIBE_TIMESTAMPS_WORD:    return 2;
-        case TRANSCRIBE_TIMESTAMPS_TOKEN:   return 3;
-        case TRANSCRIBE_TIMESTAMPS_AUTO:    return -1;
+        case TRANSCRIBE_TIMESTAMPS_NONE:
+            return 0;
+        case TRANSCRIBE_TIMESTAMPS_SEGMENT:
+            return 1;
+        case TRANSCRIBE_TIMESTAMPS_WORD:
+            return 2;
+        case TRANSCRIBE_TIMESTAMPS_TOKEN:
+            return 3;
+        case TRANSCRIBE_TIMESTAMPS_AUTO:
+            return -1;
     }
     return -1;
 }
@@ -198,10 +249,7 @@ int timestamp_rank(transcribe_timestamp_kind k) {
 // rejection differs between the two (run mirrors supports_translate,
 // streaming-begin rejects unconditionally in v1), so each caller
 // applies its own translate check before reaching this helper.
-transcribe_status validate_run_params_common(
-    const transcribe_session * session,
-    const transcribe_run_params *  params)
-{
+transcribe_status validate_run_params_common(const transcribe_session * session, const transcribe_run_params * params) {
     // Raw-validate every enum field before its first enum-typed load (see
     // enum_field_raw). Once a field passes here, downstream typed reads —
     // including the per-family handlers' — are defined.
@@ -245,10 +293,8 @@ transcribe_status validate_run_params_common(
             return TRANSCRIBE_ERR_UNSUPPORTED_TIMESTAMPS;
         }
     }
-    if (params->language != nullptr &&
-        session->model->caps.n_languages > 0 &&
-        session->model->caps.languages != nullptr)
-    {
+    if (params->language != nullptr && session->model->caps.n_languages > 0 &&
+        session->model->caps.languages != nullptr) {
         bool found = false;
         for (int i = 0; i < session->model->caps.n_languages; ++i) {
             const char * entry = session->model->caps.languages[i];
@@ -267,17 +313,13 @@ transcribe_status validate_run_params_common(
     // above and returns the same code. An empty/unadvertised set (old
     // GGUFs, ASR-only models) makes this inert; family-level target/pair
     // checks (e.g. canary's pivot pairs) still apply on top.
-    if (params->task == TRANSCRIBE_TASK_TRANSLATE &&
-        params->target_language != nullptr &&
+    if (params->task == TRANSCRIBE_TASK_TRANSLATE && params->target_language != nullptr &&
         session->model->caps.n_translate_target_languages > 0 &&
-        session->model->caps.translate_target_languages != nullptr)
-    {
+        session->model->caps.translate_target_languages != nullptr) {
         bool found = false;
         for (int i = 0; i < session->model->caps.n_translate_target_languages; ++i) {
-            const char * entry =
-                session->model->caps.translate_target_languages[i];
-            if (entry != nullptr &&
-                std::strcmp(entry, params->target_language) == 0) {
+            const char * entry = session->model->caps.translate_target_languages[i];
+            if (entry != nullptr && std::strcmp(entry, params->target_language) == 0) {
                 found = true;
                 break;
             }
@@ -290,18 +332,15 @@ transcribe_status validate_run_params_common(
     // the caller supplied both sides, reject unsupported directions before
     // family dispatch. A missing source hint keeps this inert because most
     // families do not perform generic language detection here.
-    if (params->task == TRANSCRIBE_TASK_TRANSLATE &&
-        params->language != nullptr &&
+    if (params->task == TRANSCRIBE_TASK_TRANSLATE && params->language != nullptr &&
         params->target_language != nullptr &&
-        !session->model->allows_translation_pair(params->language,
-                                                 params->target_language))
-    {
+        !session->model->allows_translation_pair(params->language, params->target_language)) {
         return TRANSCRIBE_ERR_UNSUPPORTED_LANGUAGE;
     }
     return TRANSCRIBE_OK;
 }
 
-} // namespace
+}  // namespace
 
 // Logging
 //
@@ -326,8 +365,8 @@ namespace {
 // logging. Never invoked; only compared against.
 void transcribe_log_cb_disabled(transcribe_log_level, const char *, void *) {}
 
-std::atomic<transcribe_log_callback> g_log_cb       { nullptr };
-std::atomic<void *>                  g_log_userdata { nullptr };
+std::atomic<transcribe_log_callback> g_log_cb{ nullptr };
+std::atomic<void *>                  g_log_userdata{ nullptr };
 
 // Map a ggml log level onto the transcribe enum. The numeric values do
 // NOT coincide (vendored ggml: DEBUG=1 INFO=2 WARN=3 ERROR=4;
@@ -337,24 +376,30 @@ std::atomic<void *>                  g_log_userdata { nullptr };
 // degrade to INFO rather than being dropped.
 transcribe_log_level transcribe_log_level_from_ggml(int level) {
     switch (level) {
-        case GGML_LOG_LEVEL_NONE:  return TRANSCRIBE_LOG_LEVEL_NONE;
-        case GGML_LOG_LEVEL_DEBUG: return TRANSCRIBE_LOG_LEVEL_DEBUG;
-        case GGML_LOG_LEVEL_INFO:  return TRANSCRIBE_LOG_LEVEL_INFO;
-        case GGML_LOG_LEVEL_WARN:  return TRANSCRIBE_LOG_LEVEL_WARN;
-        case GGML_LOG_LEVEL_ERROR: return TRANSCRIBE_LOG_LEVEL_ERROR;
-        case GGML_LOG_LEVEL_CONT:  return TRANSCRIBE_LOG_LEVEL_CONT;
-        default:                   return TRANSCRIBE_LOG_LEVEL_INFO;
+        case GGML_LOG_LEVEL_NONE:
+            return TRANSCRIBE_LOG_LEVEL_NONE;
+        case GGML_LOG_LEVEL_DEBUG:
+            return TRANSCRIBE_LOG_LEVEL_DEBUG;
+        case GGML_LOG_LEVEL_INFO:
+            return TRANSCRIBE_LOG_LEVEL_INFO;
+        case GGML_LOG_LEVEL_WARN:
+            return TRANSCRIBE_LOG_LEVEL_WARN;
+        case GGML_LOG_LEVEL_ERROR:
+            return TRANSCRIBE_LOG_LEVEL_ERROR;
+        case GGML_LOG_LEVEL_CONT:
+            return TRANSCRIBE_LOG_LEVEL_CONT;
+        default:
+            return TRANSCRIBE_LOG_LEVEL_INFO;
     }
 }
 
 void transcribe_ggml_log_bridge(enum ggml_log_level level, const char * text, void *);
 
-} // namespace
+}  // namespace
 
 extern "C" void transcribe_log_set(transcribe_log_callback cb, void * userdata) {
     g_log_userdata.store(userdata, std::memory_order_relaxed);
-    g_log_cb.store(cb != nullptr ? cb : &transcribe_log_cb_disabled,
-                   std::memory_order_release);
+    g_log_cb.store(cb != nullptr ? cb : &transcribe_log_cb_disabled, std::memory_order_release);
     // Route ggml's own diagnostics — above all the per-module dlopen
     // failures from dynamic backend loading, the signal a host needs to
     // see why an accelerator degraded to CPU — through the same sink.
@@ -370,10 +415,7 @@ extern "C" void transcribe_log_set(transcribe_log_callback cb, void * userdata)
 // path; future logging from the loader / frontend / decode can call
 // through here as well. Drops the message in both the never-configured
 // and explicitly-disabled states.
-static void transcribe_log_emit(
-    transcribe_log_level level,
-    const char *         msg)
-{
+static void transcribe_log_emit(transcribe_log_level level, const char * msg) {
     const auto cb = g_log_cb.load(std::memory_order_acquire);
     if (cb == nullptr || cb == &transcribe_log_cb_disabled) {
         return;
@@ -388,16 +430,13 @@ static void transcribe_log_emit(
 // transcribe_log_set(NULL, ...) silences them per the public contract.
 // The single load (instead of emit-then-recheck) also closes the benign
 // race where a concurrently installed callback could double-emit.
-static void transcribe_log_emit_or_stderr(
-    transcribe_log_level level,
-    const char *         msg)
-{
+static void transcribe_log_emit_or_stderr(transcribe_log_level level, const char * msg) {
     const auto cb = g_log_cb.load(std::memory_order_acquire);
-    if (cb == nullptr) {                              // never configured
+    if (cb == nullptr) {  // never configured
         std::fprintf(stderr, "%s\n", msg);
         return;
     }
-    if (cb == &transcribe_log_cb_disabled) {          // explicit silence
+    if (cb == &transcribe_log_cb_disabled) {  // explicit silence
         return;
     }
     cb(level, msg, g_log_userdata.load(std::memory_order_relaxed));
@@ -424,7 +463,7 @@ void transcribe_ggml_log_bridge(enum ggml_log_level level, const char * text, vo
     transcribe_log_emit_or_stderr(transcribe_log_level_from_ggml(level), buf);
 }
 
-} // namespace
+}  // namespace
 
 // Internal printf-style logger declared in transcribe-log.h. Renders into
 // a bounded stack buffer and forwards to the stderr-fallback emitter, so
@@ -433,14 +472,14 @@ void transcribe_ggml_log_bridge(enum ggml_log_level level, const char * text, vo
 // transcribe-log.h and docs/input-limits.md.
 namespace transcribe {
 void log_msg(transcribe_log_level level, const char * fmt, ...) {
-    char buf[1024];
+    char    buf[1024];
     va_list ap;
     va_start(ap, fmt);
     std::vsnprintf(buf, sizeof(buf), fmt, ap);
     va_end(ap);
     transcribe_log_emit_or_stderr(level, buf);
 }
-} // namespace transcribe
+}  // namespace transcribe
 
 // Params init functions
 //
@@ -450,29 +489,37 @@ void log_msg(transcribe_log_level level, const char * fmt, ...) {
 // memory could hit the zero case); callers reach defaults via NULL only.
 
 extern "C" void transcribe_model_load_params_init(struct transcribe_model_load_params * p) {
-    if (p == nullptr) { return; }
+    if (p == nullptr) {
+        return;
+    }
     std::memset(p, 0, sizeof(*p));
     p->struct_size = sizeof(*p);
 }
 
 extern "C" void transcribe_session_params_init(struct transcribe_session_params * p) {
-    if (p == nullptr) { return; }
+    if (p == nullptr) {
+        return;
+    }
     std::memset(p, 0, sizeof(*p));
     p->struct_size = sizeof(*p);
 }
 
 extern "C" void transcribe_run_params_init(struct transcribe_run_params * p) {
-    if (p == nullptr) { return; }
+    if (p == nullptr) {
+        return;
+    }
     std::memset(p, 0, sizeof(*p));
-    p->struct_size = sizeof(*p);
+    p->struct_size   = sizeof(*p);
     p->spec_k_drafts = -1;  // family default
     // Default to AUTO ("richest the model supports", resolved per-family at
     // run time) rather than the memset NONE.
-    p->timestamps = TRANSCRIBE_TIMESTAMPS_AUTO;
+    p->timestamps    = TRANSCRIBE_TIMESTAMPS_AUTO;
 }
 
 extern "C" void transcribe_stream_params_init(struct transcribe_stream_params * p) {
-    if (p == nullptr) { return; }
+    if (p == nullptr) {
+        return;
+    }
     std::memset(p, 0, sizeof(*p));
     p->struct_size = sizeof(*p);
 }
@@ -486,55 +533,73 @@ extern "C" void transcribe_stream_params_init(struct transcribe_stream_params *
 // the accessors as a "you forgot to init the buffer" error.
 
 extern "C" void transcribe_capabilities_init(struct transcribe_capabilities * p) {
-    if (p == nullptr) { return; }
+    if (p == nullptr) {
+        return;
+    }
     std::memset(p, 0, sizeof(*p));
     p->struct_size = sizeof(*p);
 }
 
 extern "C" void transcribe_session_limits_init(struct transcribe_session_limits * p) {
-    if (p == nullptr) { return; }
+    if (p == nullptr) {
+        return;
+    }
     std::memset(p, 0, sizeof(*p));
     p->struct_size = sizeof(*p);
 }
 
 extern "C" void transcribe_timings_init(struct transcribe_timings * p) {
-    if (p == nullptr) { return; }
+    if (p == nullptr) {
+        return;
+    }
     std::memset(p, 0, sizeof(*p));
     p->struct_size = sizeof(*p);
 }
 
 extern "C" void transcribe_stream_update_init(struct transcribe_stream_update * p) {
-    if (p == nullptr) { return; }
+    if (p == nullptr) {
+        return;
+    }
     std::memset(p, 0, sizeof(*p));
     p->struct_size = sizeof(*p);
 }
 
 extern "C" void transcribe_stream_text_init(struct transcribe_stream_text * p) {
-    if (p == nullptr) { return; }
+    if (p == nullptr) {
+        return;
+    }
     std::memset(p, 0, sizeof(*p));
     p->struct_size = sizeof(*p);
 }
 
 extern "C" void transcribe_segment_init(struct transcribe_segment * p) {
-    if (p == nullptr) { return; }
+    if (p == nullptr) {
+        return;
+    }
     std::memset(p, 0, sizeof(*p));
     p->struct_size = sizeof(*p);
 }
 
 extern "C" void transcribe_backend_device_init(struct transcribe_backend_device * p) {
-    if (p == nullptr) { return; }
+    if (p == nullptr) {
+        return;
+    }
     std::memset(p, 0, sizeof(*p));
     p->struct_size = sizeof(*p);
 }
 
 extern "C" void transcribe_word_init(struct transcribe_word * p) {
-    if (p == nullptr) { return; }
+    if (p == nullptr) {
+        return;
+    }
     std::memset(p, 0, sizeof(*p));
     p->struct_size = sizeof(*p);
 }
 
 extern "C" void transcribe_token_init(struct transcribe_token * p) {
-    if (p == nullptr) { return; }
+    if (p == nullptr) {
+        return;
+    }
     std::memset(p, 0, sizeof(*p));
     p->struct_size = sizeof(*p);
 }
@@ -547,11 +612,9 @@ extern "C" void transcribe_token_init(struct transcribe_token * p) {
 
 // Extension helpers
 
-extern "C" transcribe_status transcribe_ext_check(
-    const struct transcribe_ext * ext,
-    uint32_t                      expected_kind,
-    uint64_t                      min_size)
-{
+extern "C" transcribe_status transcribe_ext_check(const struct transcribe_ext * ext,
+                                                  uint32_t                      expected_kind,
+                                                  uint64_t                      min_size) {
     if (ext == nullptr) {
         return TRANSCRIBE_OK;
     }
@@ -567,11 +630,9 @@ extern "C" transcribe_status transcribe_ext_check(
     return TRANSCRIBE_OK;
 }
 
-extern "C" bool transcribe_model_accepts_ext_kind(
-    const struct transcribe_model * model,
-    transcribe_ext_slot             slot,
-    uint32_t                        kind)
-{
+extern "C" bool transcribe_model_accepts_ext_kind(const struct transcribe_model * model,
+                                                  transcribe_ext_slot             slot,
+                                                  uint32_t                        kind) {
     if (model == nullptr || model->arch == nullptr) {
         return false;
     }
@@ -581,10 +642,7 @@ extern "C" bool transcribe_model_accepts_ext_kind(
     return model->arch->accepts_ext_kind(model, slot, kind);
 }
 
-extern "C" bool transcribe_model_supports(
-    const struct transcribe_model * model,
-    transcribe_feature              feature)
-{
+extern "C" bool transcribe_model_supports(const struct transcribe_model * model, transcribe_feature feature) {
     // Raw read before any enum-typed load (see enum_field_raw): an unknown
     // feature id from a C caller answers false, per the documented probe
     // contract, instead of being UB.
@@ -598,43 +656,28 @@ namespace {
 // library writes on a given call path must lie inside this prefix. New
 // fields appended at the end of the public struct without growing the
 // library-side prefix do NOT raise this value.
-#define TRANSCRIBE_FIELD_END(type, field) \
-    (offsetof(type, field) + sizeof(((type *) 0)->field))
-
-constexpr size_t k_min_model_params_size =
-    TRANSCRIBE_FIELD_END(transcribe_model_load_params, gpu_device);
-constexpr size_t k_min_context_params_size =
-    TRANSCRIBE_FIELD_END(transcribe_session_params, kv_type);
-constexpr size_t k_min_run_params_size =
-    TRANSCRIBE_FIELD_END(transcribe_run_params, family);
-constexpr size_t k_min_stream_params_size =
-    TRANSCRIBE_FIELD_END(transcribe_stream_params, family);
-constexpr size_t k_stream_params_commit_policy_size =
-    TRANSCRIBE_FIELD_END(transcribe_stream_params, commit_policy);
+#define TRANSCRIBE_FIELD_END(type, field) (offsetof(type, field) + sizeof(((type *) 0)->field))
+
+constexpr size_t k_min_model_params_size            = TRANSCRIBE_FIELD_END(transcribe_model_load_params, gpu_device);
+constexpr size_t k_min_context_params_size          = TRANSCRIBE_FIELD_END(transcribe_session_params, kv_type);
+constexpr size_t k_min_run_params_size              = TRANSCRIBE_FIELD_END(transcribe_run_params, family);
+constexpr size_t k_min_stream_params_size           = TRANSCRIBE_FIELD_END(transcribe_stream_params, family);
+constexpr size_t k_stream_params_commit_policy_size = TRANSCRIBE_FIELD_END(transcribe_stream_params, commit_policy);
 constexpr size_t k_stream_params_agreement_n_size =
     TRANSCRIBE_FIELD_END(transcribe_stream_params, stable_prefix_agreement_n);
-constexpr size_t k_min_stream_update_size =
-    TRANSCRIBE_FIELD_END(transcribe_stream_update, buffered_ms);
+constexpr size_t k_min_stream_update_size = TRANSCRIBE_FIELD_END(transcribe_stream_update, buffered_ms);
 constexpr size_t k_stream_update_committed_changed_size =
     TRANSCRIBE_FIELD_END(transcribe_stream_update, committed_changed);
 constexpr size_t k_stream_update_tentative_changed_size =
     TRANSCRIBE_FIELD_END(transcribe_stream_update, tentative_changed);
-constexpr size_t k_min_stream_text_size =
-    TRANSCRIBE_FIELD_END(transcribe_stream_text, raw_tentative_start_bytes);
-constexpr size_t k_min_capabilities_size =
-    TRANSCRIBE_FIELD_END(transcribe_capabilities, supports_streaming);
-constexpr size_t k_min_session_limits_size =
-    TRANSCRIBE_FIELD_END(transcribe_session_limits, max_kv_bytes);
-constexpr size_t k_min_segment_size =
-    TRANSCRIBE_FIELD_END(transcribe_segment, text);
-constexpr size_t k_min_word_size =
-    TRANSCRIBE_FIELD_END(transcribe_word, text);
-constexpr size_t k_min_token_size =
-    TRANSCRIBE_FIELD_END(transcribe_token, text);
-constexpr size_t k_min_timings_size =
-    TRANSCRIBE_FIELD_END(transcribe_timings, decode_ms);
-constexpr size_t k_min_backend_device_size =
-    TRANSCRIBE_FIELD_END(transcribe_backend_device, kind);
+constexpr size_t k_min_stream_text_size    = TRANSCRIBE_FIELD_END(transcribe_stream_text, raw_tentative_start_bytes);
+constexpr size_t k_min_capabilities_size   = TRANSCRIBE_FIELD_END(transcribe_capabilities, supports_streaming);
+constexpr size_t k_min_session_limits_size = TRANSCRIBE_FIELD_END(transcribe_session_limits, max_kv_bytes);
+constexpr size_t k_min_segment_size        = TRANSCRIBE_FIELD_END(transcribe_segment, text);
+constexpr size_t k_min_word_size           = TRANSCRIBE_FIELD_END(transcribe_word, text);
+constexpr size_t k_min_token_size          = TRANSCRIBE_FIELD_END(transcribe_token, text);
+constexpr size_t k_min_timings_size        = TRANSCRIBE_FIELD_END(transcribe_timings, decode_ms);
+constexpr size_t k_min_backend_device_size = TRANSCRIBE_FIELD_END(transcribe_backend_device, kind);
 // k_min_whisper_chunk_trace_size lives in arch/whisper/public.cpp with
 // the chunk-trace accessor that uses it.
 
@@ -644,8 +687,8 @@ constexpr size_t k_min_backend_device_size =
 // copy_out_prefix) live in transcribe-abi.h so per-family public
 // accessors (arch/whisper/public.cpp) share one definition. Pull them
 // into this TU's unqualified scope so existing call sites are unchanged.
-using transcribe::check_struct_size;
 using transcribe::check_input_struct_size;
+using transcribe::check_struct_size;
 using transcribe::copy_out_prefix;
 
 static bool has_field(uint64_t struct_size, size_t field_end) {
@@ -666,7 +709,7 @@ static bool valid_stream_commit_policy(int policy) {
     return false;
 }
 
-} // namespace
+}  // namespace
 
 // Backend modules and device discovery
 //
@@ -698,23 +741,16 @@ static void ensure_ggml_time_init() {
 
 #if defined(TRANSCRIBE_GGML_BACKEND_DL)
 static std::filesystem::path library_self_dir() {
-#if defined(_WIN32)
-    HMODULE module = nullptr;
-    const auto flags =
-        GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS |
-        GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT;
-    if (!GetModuleHandleExW(
-            flags,
-            reinterpret_cast<LPCWSTR>(&transcribe_init_backends_default),
-            &module))
-    {
+#    if defined(_WIN32)
+    HMODULE    module = nullptr;
+    const auto flags  = GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT;
+    if (!GetModuleHandleExW(flags, reinterpret_cast<LPCWSTR>(&transcribe_init_backends_default), &module)) {
         return {};
     }
 
     std::wstring path(1024, L'\0');
     for (;;) {
-        const DWORD n = GetModuleFileNameW(
-            module, path.data(), static_cast<DWORD>(path.size()));
+        const DWORD n = GetModuleFileNameW(module, path.data(), static_cast<DWORD>(path.size()));
         if (n == 0) {
             return {};
         }
@@ -728,16 +764,15 @@ static std::filesystem::path library_self_dir() {
         path.resize(path.size() * 2);
     }
     return std::filesystem::path(path).parent_path();
-#else
-    Dl_info info {};
+#    else
+    Dl_info info{};
     if (dladdr(reinterpret_cast<const void *>(&transcribe_init_backends_default), &info) == 0 ||
-        info.dli_fname == nullptr || info.dli_fname[0] == '\0')
-    {
+        info.dli_fname == nullptr || info.dli_fname[0] == '\0') {
         return {};
     }
     std::filesystem::path path(info.dli_fname);
-    std::error_code ec;
-    auto canonical = std::filesystem::weakly_canonical(path, ec);
+    std::error_code       ec;
+    auto                  canonical = std::filesystem::weakly_canonical(path, ec);
     if (ec) {
         canonical = std::filesystem::absolute(path, ec);
     }
@@ -745,16 +780,16 @@ static std::filesystem::path library_self_dir() {
         canonical = path;
     }
     return canonical.parent_path();
-#endif
+#    endif
 }
 
 static std::string path_for_c_api(const std::filesystem::path & path) {
-#if defined(_WIN32)
+#    if defined(_WIN32)
     const auto u8 = path.u8string();
     return std::string(u8.begin(), u8.end());
-#else
+#    else
     return path.string();
-#endif
+#    endif
 }
 #endif
 
@@ -764,11 +799,10 @@ extern "C" transcribe_status transcribe_init_backends(const char * artifact_dir)
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
     {
-        struct stat st {};
+        struct stat st{};
         if (::stat(artifact_dir, &st) != 0 || !S_ISDIR(st.st_mode)) {
-            transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "transcribe_init_backends: %s is not an existing directory",
-                artifact_dir);
+            transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "transcribe_init_backends: %s is not an existing directory",
+                                artifact_dir);
             return TRANSCRIBE_ERR_FILE_NOT_FOUND;
         }
     }
@@ -778,13 +812,11 @@ extern "C" transcribe_status transcribe_init_backends(const char * artifact_dir)
     // path so two spellings of one directory count as one load.
     static std::mutex            s_mutex;
     static std::set<std::string> s_loaded_dirs;
-    std::lock_guard<std::mutex> lock(s_mutex);
+    std::lock_guard<std::mutex>  lock(s_mutex);
 
-    std::error_code ec;
-    std::filesystem::path canonical =
-        std::filesystem::weakly_canonical(artifact_dir, ec);
-    const std::string key = ec ? std::string(artifact_dir)
-                               : canonical.string();
+    std::error_code       ec;
+    std::filesystem::path canonical = std::filesystem::weakly_canonical(artifact_dir, ec);
+    const std::string     key       = ec ? std::string(artifact_dir) : canonical.string();
     if (s_loaded_dirs.find(key) == s_loaded_dirs.end()) {
         ggml_backend_load_all_from_path(artifact_dir);
         s_loaded_dirs.insert(key);
@@ -793,14 +825,12 @@ extern "C" transcribe_status transcribe_init_backends(const char * artifact_dir)
         // ggml compiles its per-module load-failure diagnostics out, so this
         // line is the reliable signal of which backends made it). Callback-only
         // so a host without a sink gets no new import-time stderr noise.
-        char devices[256];
-        size_t off = 0;
+        char         devices[256];
+        size_t       off   = 0;
         const size_t n_dev = ggml_backend_dev_count();
         for (size_t i = 0; i < n_dev; ++i) {
-            const int wrote = std::snprintf(
-                devices + off, sizeof(devices) - off, "%s%s",
-                i == 0 ? "" : ", ",
-                ggml_backend_dev_name(ggml_backend_dev_get(i)));
+            const int wrote = std::snprintf(devices + off, sizeof(devices) - off, "%s%s", i == 0 ? "" : ", ",
+                                            ggml_backend_dev_name(ggml_backend_dev_get(i)));
             if (wrote < 0 || static_cast<size_t>(wrote) >= sizeof(devices) - off) {
                 break;  // truncated; the prefix is summary enough
             }
@@ -819,9 +849,10 @@ extern "C" transcribe_status transcribe_init_backends(const char * artifact_dir)
         // modules: the process has nothing to compute on. Loud and early
         // beats a confusing model-load failure later.
         transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "transcribe_init_backends: no compute devices registered after "
-            "loading %s (no usable ggml backend modules found there, and no "
-            "backends are compiled in)", artifact_dir);
+                            "transcribe_init_backends: no compute devices registered after "
+                            "loading %s (no usable ggml backend modules found there, and no "
+                            "backends are compiled in)",
+                            artifact_dir);
         return TRANSCRIBE_ERR_BACKEND;
     }
     return TRANSCRIBE_OK;
@@ -835,8 +866,8 @@ extern "C" transcribe_status transcribe_init_backends_default(void) {
     const auto dir = library_self_dir();
     if (dir.empty()) {
         transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-            "transcribe_init_backends_default: could not resolve the "
-            "directory containing libtranscribe");
+                            "transcribe_init_backends_default: could not resolve the "
+                            "directory containing libtranscribe");
         return TRANSCRIBE_ERR_BACKEND;
     }
     const auto s = path_for_c_api(dir);
@@ -852,28 +883,30 @@ namespace {
 // reported faithfully.
 transcribe_device_type to_device_type(enum ggml_backend_dev_type t) {
     switch (t) {
-        case GGML_BACKEND_DEVICE_TYPE_CPU:   return TRANSCRIBE_DEVICE_TYPE_CPU;
-        case GGML_BACKEND_DEVICE_TYPE_IGPU:  return TRANSCRIBE_DEVICE_TYPE_IGPU;
-        case GGML_BACKEND_DEVICE_TYPE_ACCEL: return TRANSCRIBE_DEVICE_TYPE_ACCEL;
+        case GGML_BACKEND_DEVICE_TYPE_CPU:
+            return TRANSCRIBE_DEVICE_TYPE_CPU;
+        case GGML_BACKEND_DEVICE_TYPE_IGPU:
+            return TRANSCRIBE_DEVICE_TYPE_IGPU;
+        case GGML_BACKEND_DEVICE_TYPE_ACCEL:
+            return TRANSCRIBE_DEVICE_TYPE_ACCEL;
         case GGML_BACKEND_DEVICE_TYPE_GPU:
-        default:                             return TRANSCRIBE_DEVICE_TYPE_GPU;
+        default:
+            return TRANSCRIBE_DEVICE_TYPE_GPU;
     }
 }
 
 // Fill a caller-owned transcribe_backend_device from a ggml device, honoring
 // the caller's declared struct_size via copy_out_prefix. ggml_backend_dev_get_props
 // queries memory live, so every call observes a fresh memory_free snapshot.
-void fill_backend_device(ggml_backend_dev_t dev, uint64_t caller_size,
-                         struct transcribe_backend_device * out) {
+void fill_backend_device(ggml_backend_dev_t dev, uint64_t caller_size, struct transcribe_backend_device * out) {
     ggml_backend_dev_props props{};
     ggml_backend_dev_get_props(dev, &props);
 
-    const transcribe::BackendKind kind = transcribe::classify_device(dev);
-    const char * kind_name = transcribe::kind_name(kind);
-    const char * name = ggml_backend_dev_name(dev);
+    const transcribe::BackendKind kind      = transcribe::classify_device(dev);
+    const char *                  kind_name = transcribe::kind_name(kind);
+    const char *                  name      = ggml_backend_dev_name(dev);
     if (name == nullptr || name[0] == '\0') {
-        name = (props.name != nullptr && props.name[0] != '\0')
-            ? props.name : kind_name;
+        name = (props.name != nullptr && props.name[0] != '\0') ? props.name : kind_name;
     }
     const char * description = ggml_backend_dev_description(dev);
     if (description == nullptr) {
@@ -892,22 +925,17 @@ void fill_backend_device(ggml_backend_dev_t dev, uint64_t caller_size,
     copy_out_prefix(out, &staged, caller_size, sizeof(staged));
 }
 
-} // namespace
+}  // namespace
 
 extern "C" int transcribe_backend_device_count(void) {
     return static_cast<int>(ggml_backend_dev_count());
 }
 
-extern "C" transcribe_status transcribe_get_backend_device(
-    int                                index,
-    struct transcribe_backend_device * out)
-{
+extern "C" transcribe_status transcribe_get_backend_device(int index, struct transcribe_backend_device * out) {
     if (out == nullptr) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
-    if (const auto st = check_struct_size(out->struct_size, k_min_backend_device_size);
-        st != TRANSCRIBE_OK)
-    {
+    if (const auto st = check_struct_size(out->struct_size, k_min_backend_device_size); st != TRANSCRIBE_OK) {
         return st;
     }
     if (index < 0 || index >= static_cast<int>(ggml_backend_dev_count())) {
@@ -921,19 +949,28 @@ extern "C" transcribe_status transcribe_get_backend_device(
 extern "C" bool transcribe_backend_available(transcribe_backend_request kind) {
     // Raw read before any enum-typed load (see enum_field_raw); unknown
     // values answer false per the documented probe contract.
-    const int raw = enum_field_raw(&kind);
-    const size_t n = ggml_backend_dev_count();
+    const int    raw = enum_field_raw(&kind);
+    const size_t n   = ggml_backend_dev_count();
     if (raw == TRANSCRIBE_BACKEND_AUTO) {
         return n > 0;
     }
     transcribe::BackendKind want;
     switch (raw) {
         case TRANSCRIBE_BACKEND_CPU:
-        case TRANSCRIBE_BACKEND_CPU_ACCEL: want = transcribe::BackendKind::Cpu;    break;
-        case TRANSCRIBE_BACKEND_METAL:     want = transcribe::BackendKind::Metal;  break;
-        case TRANSCRIBE_BACKEND_VULKAN:    want = transcribe::BackendKind::Vulkan; break;
-        case TRANSCRIBE_BACKEND_CUDA:      want = transcribe::BackendKind::Cuda;   break;
-        default:                           return false;
+        case TRANSCRIBE_BACKEND_CPU_ACCEL:
+            want = transcribe::BackendKind::Cpu;
+            break;
+        case TRANSCRIBE_BACKEND_METAL:
+            want = transcribe::BackendKind::Metal;
+            break;
+        case TRANSCRIBE_BACKEND_VULKAN:
+            want = transcribe::BackendKind::Vulkan;
+            break;
+        case TRANSCRIBE_BACKEND_CUDA:
+            want = transcribe::BackendKind::Cuda;
+            break;
+        default:
+            return false;
     }
     for (size_t i = 0; i < n; ++i) {
         if (transcribe::classify_device(ggml_backend_dev_get(i)) == want) {
@@ -951,9 +988,7 @@ enum class StreamStablePrefixImpl {
     FamilyNativeCommit,
 };
 
-static StreamStablePrefixImpl stream_stable_prefix_impl_for_arch(
-    const transcribe::Arch * arch)
-{
+static StreamStablePrefixImpl stream_stable_prefix_impl_for_arch(const transcribe::Arch * arch) {
     // Single source of truth for the stable-prefix implementation used by
     // AUTO and explicit STABLE_PREFIX. Add new streaming families here
     // deliberately; otherwise they use the generic text-agreement fallback.
@@ -961,17 +996,17 @@ static StreamStablePrefixImpl stream_stable_prefix_impl_for_arch(
         const char *           arch_name;
         StreamStablePrefixImpl impl;
     };
+
     static constexpr Entry k_defaults[] = {
         // Parakeet publishes native committed chunks; agreement_n does not
         // add useful evidence on top of the family-provided boundary.
-        { "parakeet",            StreamStablePrefixImpl::FamilyNativeCommit },
+        { "parakeet",            StreamStablePrefixImpl::FamilyNativeCommit   },
         // Moonshine re-decodes the full prefix and its family boundary is
         // token-id agreement; the family applies stable_prefix_agreement_n.
         { "moonshine_streaming", StreamStablePrefixImpl::FamilyTokenAgreement },
     };
 
-    const char * name =
-        arch != nullptr && arch->name != nullptr ? arch->name : "";
+    const char * name = arch != nullptr && arch->name != nullptr ? arch->name : "";
     for (const Entry & entry : k_defaults) {
         if (std::strcmp(name, entry.arch_name) == 0) {
             return entry.impl;
@@ -984,37 +1019,30 @@ static size_t utf8_floor_boundary(const std::string & s, size_t pos) {
     if (pos >= s.size()) {
         return s.size();
     }
-    while (pos > 0 &&
-           (static_cast<unsigned char>(s[pos]) & 0xC0u) == 0x80u)
-    {
+    while (pos > 0 && (static_cast<unsigned char>(s[pos]) & 0xC0u) == 0x80u) {
         --pos;
     }
     return pos;
 }
 
-static size_t common_prefix_bytes(const std::string & a,
-                                  const std::string & b) {
+static size_t common_prefix_bytes(const std::string & a, const std::string & b) {
     const size_t n = std::min(a.size(), b.size());
-    size_t i = 0;
+    size_t       i = 0;
     while (i < n && a[i] == b[i]) {
         ++i;
     }
     return utf8_floor_boundary(a, i);
 }
 
-static bool starts_with_bytes(const std::string & s,
-                              const std::string & prefix) {
-    return s.size() >= prefix.size() &&
-           s.compare(0, prefix.size(), prefix) == 0;
+static bool starts_with_bytes(const std::string & s, const std::string & prefix) {
+    return s.size() >= prefix.size() && s.compare(0, prefix.size(), prefix) == 0;
 }
 
-static size_t token_prefix_raw_bytes(const transcribe_session * session,
-                                     int n_tokens) {
+static size_t token_prefix_raw_bytes(const transcribe_session * session, int n_tokens) {
     if (session == nullptr || n_tokens <= 0 || session->tokens.empty()) {
         return 0;
     }
-    const int capped =
-        std::min<int>(n_tokens, static_cast<int>(session->tokens.size()));
+    const int   capped = std::min<int>(n_tokens, static_cast<int>(session->tokens.size()));
     std::string prefix;
     prefix.reserve(session->full_text.size());
     for (int i = 0; i < capped; ++i) {
@@ -1023,9 +1051,7 @@ static size_t token_prefix_raw_bytes(const transcribe_session * session,
     if (starts_with_bytes(session->full_text, prefix)) {
         return prefix.size();
     }
-    if (!prefix.empty() && prefix.front() == ' ' &&
-        (session->full_text.empty() || session->full_text.front() != ' '))
-    {
+    if (!prefix.empty() && prefix.front() == ' ' && (session->full_text.empty() || session->full_text.front() != ' ')) {
         const std::string normalized_prefix = prefix.substr(1);
         if (starts_with_bytes(session->full_text, normalized_prefix)) {
             return normalized_prefix.size();
@@ -1035,37 +1061,31 @@ static size_t token_prefix_raw_bytes(const transcribe_session * session,
     return common_prefix_bytes(session->full_text, prefix);
 }
 
-static size_t family_candidate_raw_prefix_bytes(
-    const transcribe_session * session) {
+static size_t family_candidate_raw_prefix_bytes(const transcribe_session * session) {
     if (session == nullptr || !session->has_result) {
         return 0;
     }
     if (session->n_committed_tokens > 0) {
         return token_prefix_raw_bytes(session, session->n_committed_tokens);
     }
-    if (session->n_committed_words > 0 &&
-        session->n_committed_words >= static_cast<int>(session->words.size()))
-    {
+    if (session->n_committed_words > 0 && session->n_committed_words >= static_cast<int>(session->words.size())) {
         return session->full_text.size();
     }
     if (session->n_committed_segments > 0 &&
-        session->n_committed_segments >= static_cast<int>(session->segments.size()))
-    {
+        session->n_committed_segments >= static_cast<int>(session->segments.size())) {
         return session->full_text.size();
     }
     return 0;
 }
 
-static size_t generic_text_stable_prefix_candidate_raw_bytes(
-    transcribe_session * session)
-{
+static size_t generic_text_stable_prefix_candidate_raw_bytes(transcribe_session * session) {
     if (session == nullptr || !session->has_result) {
         return 0;
     }
     // Library default when the caller leaves stable_prefix_agreement_n at
     // 0; documented as "currently 3" on transcribe_stream_params.
     static constexpr uint32_t k_default_stable_prefix_agreement_n = 3;
-    uint32_t agreement_n = session->stream_stable_prefix_agreement_n;
+    uint32_t                  agreement_n                         = session->stream_stable_prefix_agreement_n;
     if (agreement_n == 0) {
         agreement_n = k_default_stable_prefix_agreement_n;
     }
@@ -1083,21 +1103,16 @@ static size_t generic_text_stable_prefix_candidate_raw_bytes(
 
     size_t prefix_n = session->stream_raw_history.front().size();
     for (const auto & text : session->stream_raw_history) {
-        prefix_n = std::min(prefix_n,
-                            common_prefix_bytes(
-                                session->stream_raw_history.front(), text));
+        prefix_n = std::min(prefix_n, common_prefix_bytes(session->stream_raw_history.front(), text));
     }
     return utf8_floor_boundary(session->full_text, prefix_n);
 }
 
-static size_t selected_stable_prefix_candidate_raw_bytes(
-    transcribe_session * session)
-{
+static size_t selected_stable_prefix_candidate_raw_bytes(transcribe_session * session) {
     if (session == nullptr) {
         return 0;
     }
-    const transcribe::Arch * arch =
-        session->model != nullptr ? session->model->arch : nullptr;
+    const transcribe::Arch * arch = session->model != nullptr ? session->model->arch : nullptr;
     switch (stream_stable_prefix_impl_for_arch(arch)) {
         case StreamStablePrefixImpl::FamilyTokenAgreement:
         case StreamStablePrefixImpl::FamilyNativeCommit:
@@ -1108,35 +1123,25 @@ static size_t selected_stable_prefix_candidate_raw_bytes(
     return 0;
 }
 
-static bool append_committed_raw_prefix(transcribe_session * session,
-                                        size_t              candidate_bytes)
-{
+static bool append_committed_raw_prefix(transcribe_session * session, size_t candidate_bytes) {
     if (session == nullptr || !session->has_result) {
         return false;
     }
-    const std::string & raw = session->full_text;
-    const size_t old_boundary = utf8_floor_boundary(
-        raw, std::min<size_t>(
-                 static_cast<size_t>(session->stream_raw_tentative_start_bytes),
-                 raw.size()));
-    const size_t candidate = utf8_floor_boundary(
-        raw, std::min(candidate_bytes, raw.size()));
+    const std::string & raw          = session->full_text;
+    const size_t        old_boundary = utf8_floor_boundary(
+        raw, std::min<size_t>(static_cast<size_t>(session->stream_raw_tentative_start_bytes), raw.size()));
+    const size_t candidate = utf8_floor_boundary(raw, std::min(candidate_bytes, raw.size()));
     if (candidate <= old_boundary) {
         return false;
     }
     if (old_boundary != session->stream_committed_text.size()) {
         return false;
     }
-    if (raw.compare(0, old_boundary,
-                    session->stream_committed_text.data(),
-                    old_boundary) != 0)
-    {
+    if (raw.compare(0, old_boundary, session->stream_committed_text.data(), old_boundary) != 0) {
         return false;
     }
-    session->stream_committed_text.append(
-        raw.data() + old_boundary, candidate - old_boundary);
-    session->stream_raw_tentative_start_bytes =
-        static_cast<uint64_t>(candidate);
+    session->stream_committed_text.append(raw.data() + old_boundary, candidate - old_boundary);
+    session->stream_raw_tentative_start_bytes = static_cast<uint64_t>(candidate);
     return true;
 }
 
@@ -1145,31 +1150,23 @@ static bool finalize_committed_text(transcribe_session * session) {
         return false;
     }
     if (session->stream_commit_policy == TRANSCRIBE_STREAM_COMMIT_ON_FINALIZE ||
-        session->stream_committed_text.empty())
-    {
-        const bool changed =
-            session->stream_committed_text != session->full_text;
-        session->stream_committed_text = session->full_text;
-        session->stream_raw_tentative_start_bytes =
-            static_cast<uint64_t>(session->full_text.size());
+        session->stream_committed_text.empty()) {
+        const bool changed                        = session->stream_committed_text != session->full_text;
+        session->stream_committed_text            = session->full_text;
+        session->stream_raw_tentative_start_bytes = static_cast<uint64_t>(session->full_text.size());
         return changed;
     }
     if (!starts_with_bytes(session->full_text, session->stream_committed_text)) {
-        session->stream_raw_tentative_start_bytes =
-            static_cast<uint64_t>(session->full_text.size());
+        session->stream_raw_tentative_start_bytes = static_cast<uint64_t>(session->full_text.size());
         return false;
     }
     const size_t old_n = session->stream_committed_text.size();
     if (session->full_text.size() > old_n) {
-        session->stream_committed_text.append(
-            session->full_text.data() + old_n,
-            session->full_text.size() - old_n);
-        session->stream_raw_tentative_start_bytes =
-            static_cast<uint64_t>(session->full_text.size());
+        session->stream_committed_text.append(session->full_text.data() + old_n, session->full_text.size() - old_n);
+        session->stream_raw_tentative_start_bytes = static_cast<uint64_t>(session->full_text.size());
         return true;
     }
-    session->stream_raw_tentative_start_bytes =
-        static_cast<uint64_t>(session->full_text.size());
+    session->stream_raw_tentative_start_bytes = static_cast<uint64_t>(session->full_text.size());
     return false;
 }
 
@@ -1178,10 +1175,7 @@ struct StreamTextDelta {
     bool tentative_changed = false;
 };
 
-static StreamTextDelta apply_stream_text_policy(
-    transcribe_session * session,
-    bool                 is_finalize)
-{
+static StreamTextDelta apply_stream_text_policy(transcribe_session * session, bool is_finalize) {
     StreamTextDelta delta;
     if (session == nullptr) {
         return delta;
@@ -1204,34 +1198,25 @@ static StreamTextDelta apply_stream_text_policy(
                 candidate = selected_stable_prefix_candidate_raw_bytes(session);
                 break;
         }
-        delta.committed_changed =
-            append_committed_raw_prefix(session, candidate);
+        delta.committed_changed = append_committed_raw_prefix(session, candidate);
 
         const size_t boundary = utf8_floor_boundary(
-            session->full_text,
-            std::min<size_t>(
-                static_cast<size_t>(session->stream_raw_tentative_start_bytes),
-                session->full_text.size()));
-        session->stream_tentative_text.assign(
-            session->full_text.data() + boundary,
-            session->full_text.size() - boundary);
+            session->full_text, std::min<size_t>(static_cast<size_t>(session->stream_raw_tentative_start_bytes),
+                                                 session->full_text.size()));
+        session->stream_tentative_text.assign(session->full_text.data() + boundary,
+                                              session->full_text.size() - boundary);
     } else {
         session->stream_tentative_text.clear();
     }
 
-    delta.committed_changed =
-        delta.committed_changed ||
-        session->stream_committed_text != prev_committed;
-    delta.tentative_changed =
-        session->stream_tentative_text != prev_tentative;
+    delta.committed_changed = delta.committed_changed || session->stream_committed_text != prev_committed;
+    delta.tentative_changed = session->stream_tentative_text != prev_tentative;
     return delta;
 }
 
-static void publish_stream_update_tail(
-    transcribe_stream_update * update,
-    bool                       committed_changed,
-    bool                       tentative_changed)
-{
+static void publish_stream_update_tail(transcribe_stream_update * update,
+                                       bool                       committed_changed,
+                                       bool                       tentative_changed) {
     if (update == nullptr) {
         return;
     }
@@ -1250,33 +1235,23 @@ static void publish_stream_update_tail(
 // exactly one place; the path-specific work (ON_FINALIZE counter zeroing
 // and audio_committed_ms on feed, is_final and the lifecycle transition
 // on finalize) stays in the callers.
-static void publish_observable_delta(
-    transcribe_session *       session,
-    transcribe_stream_update * update,
-    int32_t                    prev_revision,
-    const std::string &        prev_full_text,
-    bool                       prev_has_result,
-    const StreamTextDelta &    text_delta)
-{
-    const bool raw_changed =
-        session->has_result != prev_has_result ||
-        session->full_text != prev_full_text;
-    const bool observable_changed =
-        raw_changed || text_delta.committed_changed ||
-        text_delta.tentative_changed ||
-        (update != nullptr && update->result_changed);
+static void publish_observable_delta(transcribe_session *       session,
+                                     transcribe_stream_update * update,
+                                     int32_t                    prev_revision,
+                                     const std::string &        prev_full_text,
+                                     bool                       prev_has_result,
+                                     const StreamTextDelta &    text_delta) {
+    const bool raw_changed        = session->has_result != prev_has_result || session->full_text != prev_full_text;
+    const bool observable_changed = raw_changed || text_delta.committed_changed || text_delta.tentative_changed ||
+                                    (update != nullptr && update->result_changed);
     if (observable_changed && session->stream_revision == prev_revision) {
         session->stream_revision += 1;
     }
     if (update != nullptr) {
         update->result_changed =
-            update->result_changed ||
-            observable_changed ||
-            session->stream_revision != prev_revision;
+            update->result_changed || observable_changed || session->stream_revision != prev_revision;
         update->revision = session->stream_revision;
-        publish_stream_update_tail(
-            update, text_delta.committed_changed,
-            text_delta.tentative_changed);
+        publish_stream_update_tail(update, text_delta.committed_changed, text_delta.tentative_changed);
     }
 }
 
@@ -1286,59 +1261,48 @@ static void publish_observable_delta(
 // TRANSCRIBE_ERR_UNSUPPORTED_PNC / _ITN codes are NOT returned today
 // (placeholders for a future opt-in strict mode). The message includes the
 // arch + variant strings to pinpoint which model dropped the request.
-void warn_unsupported_advisory(
-    const struct transcribe_model *  model,
-    const struct transcribe_run_params * rp)
-{
+void warn_unsupported_advisory(const struct transcribe_model * model, const struct transcribe_run_params * rp) {
     if (model == nullptr || rp == nullptr) {
         return;
     }
-    const char * arch_name =
-        (model->arch != nullptr && model->arch->name != nullptr)
-            ? model->arch->name : "(unknown)";
-    const char * variant = model->variant.c_str();
+    const char * arch_name = (model->arch != nullptr && model->arch->name != nullptr) ? model->arch->name : "(unknown)";
+    const char * variant   = model->variant.c_str();
     if (variant == nullptr || variant[0] == '\0') {
         variant = "(unknown)";
     }
 
     char buf[512];
-    if (rp->pnc != TRANSCRIBE_PNC_MODE_DEFAULT &&
-        !transcribe::has_feature(model, TRANSCRIBE_FEATURE_PNC))
-    {
+    if (rp->pnc != TRANSCRIBE_PNC_MODE_DEFAULT && !transcribe::has_feature(model, TRANSCRIBE_FEATURE_PNC)) {
         const char * req = (rp->pnc == TRANSCRIBE_PNC_MODE_ON) ? "ON" : "OFF";
         std::snprintf(buf, sizeof(buf),
-            "transcribe_run: caller requested pnc=%s but model '%s' "
-            "(variant '%s') does not support pnc control; output will use "
-            "the model's default behavior. Use "
-            "transcribe_model_supports(model, TRANSCRIBE_FEATURE_PNC) to "
-            "pre-check.",
-            req, arch_name, variant);
+                      "transcribe_run: caller requested pnc=%s but model '%s' "
+                      "(variant '%s') does not support pnc control; output will use "
+                      "the model's default behavior. Use "
+                      "transcribe_model_supports(model, TRANSCRIBE_FEATURE_PNC) to "
+                      "pre-check.",
+                      req, arch_name, variant);
         transcribe_log_emit_or_stderr(TRANSCRIBE_LOG_LEVEL_WARN, buf);
     }
-    if (rp->itn != TRANSCRIBE_ITN_MODE_DEFAULT &&
-        !transcribe::has_feature(model, TRANSCRIBE_FEATURE_ITN))
-    {
+    if (rp->itn != TRANSCRIBE_ITN_MODE_DEFAULT && !transcribe::has_feature(model, TRANSCRIBE_FEATURE_ITN)) {
         const char * req = (rp->itn == TRANSCRIBE_ITN_MODE_ON) ? "ON" : "OFF";
         std::snprintf(buf, sizeof(buf),
-            "transcribe_run: caller requested itn=%s but model '%s' "
-            "(variant '%s') does not support itn control; output will use "
-            "the model's default behavior. Use "
-            "transcribe_model_supports(model, TRANSCRIBE_FEATURE_ITN) to "
-            "pre-check.",
-            req, arch_name, variant);
+                      "transcribe_run: caller requested itn=%s but model '%s' "
+                      "(variant '%s') does not support itn control; output will use "
+                      "the model's default behavior. Use "
+                      "transcribe_model_supports(model, TRANSCRIBE_FEATURE_ITN) to "
+                      "pre-check.",
+                      req, arch_name, variant);
         transcribe_log_emit_or_stderr(TRANSCRIBE_LOG_LEVEL_WARN, buf);
     }
 }
 
-} // namespace
+}  // namespace
 
 // Lifecycle
 
-extern "C" transcribe_status transcribe_model_load_file(
-    const char *                           path,
-    const struct transcribe_model_load_params * params,
-    struct transcribe_model **             out_model)
-{
+extern "C" transcribe_status transcribe_model_load_file(const char *                                path,
+                                                        const struct transcribe_model_load_params * params,
+                                                        struct transcribe_model **                  out_model) {
     // Set up ggml's timer before any family's load-timing ggml_time_us() runs
     // (Windows/MSVC ÷0 otherwise — see ensure_ggml_time_init).
     ensure_ggml_time_init();
@@ -1353,13 +1317,12 @@ extern "C" transcribe_status transcribe_model_load_file(
     // spelling of defaults — it carries no struct_size, so it always
     // matches the running library. A zeroed struct ({0}) is a different
     // thing: it claims struct_size == 0 and is rejected below.
-    struct transcribe_model_load_params params_defaults; transcribe_model_load_params_init(&params_defaults);
+    struct transcribe_model_load_params params_defaults;
+    transcribe_model_load_params_init(&params_defaults);
     if (params == nullptr) {
         params = &params_defaults;
     }
-    if (const auto st = check_input_struct_size(params->struct_size, k_min_model_params_size);
-        st != TRANSCRIBE_OK)
-    {
+    if (const auto st = check_input_struct_size(params->struct_size, k_min_model_params_size); st != TRANSCRIBE_OK) {
         return st;
     }
 
@@ -1382,9 +1345,8 @@ extern "C" transcribe_status transcribe_model_load_file(
         case TRANSCRIBE_BACKEND_CUDA:
             break;
         default:
-            transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                "transcribe_model_load_file: invalid backend request %d",
-                enum_field_raw(&params->backend));
+            transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "transcribe_model_load_file: invalid backend request %d",
+                                enum_field_raw(&params->backend));
             return TRANSCRIBE_ERR_INVALID_ARG;
     }
 
@@ -1393,7 +1355,7 @@ extern "C" transcribe_status transcribe_model_load_file(
     // ggml magic 0x67676d6c is a legacy whisper.cpp .bin. Public contract:
     // missing path -> ERR_FILE_NOT_FOUND; every other failure -> ERR_GGUF.
     {
-        struct stat st {};
+        struct stat st{};
         if (::stat(path, &st) != 0) {
             if (errno == ENOENT || errno == ENOTDIR) {
                 return TRANSCRIBE_ERR_FILE_NOT_FOUND;
@@ -1414,8 +1376,9 @@ extern "C" transcribe_status transcribe_model_load_file(
         fin.read(reinterpret_cast<char *>(&magic), sizeof(magic));
         if (!fin || fin.gcount() != sizeof(magic)) {
             transcribe::log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
-                         "transcribe_model_load_file: short read on file "
-                         "magic for %s", path);
+                                "transcribe_model_load_file: short read on file "
+                                "magic for %s",
+                                path);
             return TRANSCRIBE_ERR_GGUF;
         }
     }
@@ -1473,11 +1436,9 @@ extern "C" void transcribe_model_free(struct transcribe_model * model) {
     delete model;
 }
 
-extern "C" transcribe_status transcribe_session_init(
-    struct transcribe_model *                model,
-    const struct transcribe_session_params * params,
-    struct transcribe_session **             out_session)
-{
+extern "C" transcribe_status transcribe_session_init(struct transcribe_model *                model,
+                                                     const struct transcribe_session_params * params,
+                                                     struct transcribe_session **             out_session) {
     if (out_session == nullptr) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
@@ -1486,13 +1447,12 @@ extern "C" transcribe_status transcribe_session_init(
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
     // NULL params means "all defaults" (see transcribe_model_load_file).
-    struct transcribe_session_params params_defaults; transcribe_session_params_init(&params_defaults);
+    struct transcribe_session_params params_defaults;
+    transcribe_session_params_init(&params_defaults);
     if (params == nullptr) {
         params = &params_defaults;
     }
-    if (const auto st = check_input_struct_size(params->struct_size, k_min_context_params_size);
-        st != TRANSCRIBE_OK)
-    {
+    if (const auto st = check_input_struct_size(params->struct_size, k_min_context_params_size); st != TRANSCRIBE_OK) {
         return st;
     }
     // n_threads contract from include/transcribe.h: 0 means "library
@@ -1520,9 +1480,7 @@ extern "C" transcribe_status transcribe_session_init(
     // value is undefined input, not a documented sentinel. The family that
     // honors n_ctx clamps a too-large value down to the model maximum, so
     // only the negative case is rejected here. See include/transcribe.h.
-    if (has_field(params->struct_size,
-                  offsetof(struct transcribe_session_params, n_ctx) +
-                      sizeof(params->n_ctx)) &&
+    if (has_field(params->struct_size, offsetof(struct transcribe_session_params, n_ctx) + sizeof(params->n_ctx)) &&
         params->n_ctx < 0) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
@@ -1546,8 +1504,7 @@ extern "C" void transcribe_session_free(struct transcribe_session * session) {
     if (session == nullptr) {
         return;
     }
-    struct transcribe_model * owned =
-        session->owns_model ? session->model : nullptr;
+    struct transcribe_model * owned = session->owns_model ? session->model : nullptr;
     delete session;
     transcribe_model_free(owned);  // NULL is a no-op
 }
@@ -1559,12 +1516,10 @@ extern "C" void transcribe_session_free(struct transcribe_session * session) {
 // transcribe_session_free; both honor owns_model and free the owned model
 // after the session.
 
-extern "C" transcribe_status transcribe_open(
-    const char *                                path,
-    const struct transcribe_model_load_params * load_params,
-    const struct transcribe_session_params *    session_params,
-    struct transcribe_session **                out_session)
-{
+extern "C" transcribe_status transcribe_open(const char *                                path,
+                                             const struct transcribe_model_load_params * load_params,
+                                             const struct transcribe_session_params *    session_params,
+                                             struct transcribe_session **                out_session) {
     if (out_session == nullptr) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
@@ -1573,16 +1528,12 @@ extern "C" transcribe_status transcribe_open(
     // NULL params are forwarded as-is: the callees already treat NULL as
     // "all defaults", so no substitution is needed here.
     struct transcribe_model * model = nullptr;
-    if (const auto st = transcribe_model_load_file(path, load_params, &model);
-        st != TRANSCRIBE_OK)
-    {
+    if (const auto st = transcribe_model_load_file(path, load_params, &model); st != TRANSCRIBE_OK) {
         return st;
     }
 
     struct transcribe_session * session = nullptr;
-    if (const auto st = transcribe_session_init(model, session_params, &session);
-        st != TRANSCRIBE_OK)
-    {
+    if (const auto st = transcribe_session_init(model, session_params, &session); st != TRANSCRIBE_OK) {
         // Load succeeded but session init failed: own the cleanup so the
         // caller sees the same all-or-nothing contract as the two-step
         // API. No partial state leaks.
@@ -1594,7 +1545,7 @@ extern "C" transcribe_status transcribe_open(
     // transcribe_session_free or transcribe_close (its alias) will free
     // both. This is the only place owns_model is set.
     session->owns_model = true;
-    *out_session = session;
+    *out_session        = session;
     return TRANSCRIBE_OK;
 }
 
@@ -1604,20 +1555,16 @@ extern "C" void transcribe_close(struct transcribe_session * session) {
     transcribe_session_free(session);
 }
 
-extern "C" const struct transcribe_model * transcribe_get_model(
-    const struct transcribe_session * session)
-{
+extern "C" const struct transcribe_model * transcribe_get_model(const struct transcribe_session * session) {
     if (session == nullptr) {
         return nullptr;
     }
     return session->model;
 }
 
-extern "C" void transcribe_set_abort_callback(
-    struct transcribe_session * session,
-    transcribe_abort_callback   cb,
-    void *                      user_data)
-{
+extern "C" void transcribe_set_abort_callback(struct transcribe_session * session,
+                                              transcribe_abort_callback   cb,
+                                              void *                      user_data) {
     if (session == nullptr) {
         return;
     }
@@ -1648,50 +1595,46 @@ extern "C" bool transcribe_was_truncated(const struct transcribe_session * sessi
 // last_status, and the public committed/tentative text view. clear_result()
 // wipes the snapshot but never touches stream_state.
 
-extern "C" transcribe_status transcribe_stream_begin(
-    struct transcribe_session *              session,
-    const struct transcribe_run_params *         run_params,
-    const struct transcribe_stream_params *  stream_params)
-{
+extern "C" transcribe_status transcribe_stream_begin(struct transcribe_session *             session,
+                                                     const struct transcribe_run_params *    run_params,
+                                                     const struct transcribe_stream_params * stream_params) {
     if (session == nullptr) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
     // NULL run/stream params each mean "all defaults".
-    struct transcribe_run_params    run_params_defaults;    transcribe_run_params_init(&run_params_defaults);
-    struct transcribe_stream_params stream_params_defaults; transcribe_stream_params_init(&stream_params_defaults);
-    if (run_params == nullptr)    { run_params = &run_params_defaults; }
-    if (stream_params == nullptr) { stream_params = &stream_params_defaults; }
-    if (const auto st = check_input_struct_size(run_params->struct_size, k_min_run_params_size);
-        st != TRANSCRIBE_OK)
-    {
+    struct transcribe_run_params run_params_defaults;
+    transcribe_run_params_init(&run_params_defaults);
+    struct transcribe_stream_params stream_params_defaults;
+    transcribe_stream_params_init(&stream_params_defaults);
+    if (run_params == nullptr) {
+        run_params = &run_params_defaults;
+    }
+    if (stream_params == nullptr) {
+        stream_params = &stream_params_defaults;
+    }
+    if (const auto st = check_input_struct_size(run_params->struct_size, k_min_run_params_size); st != TRANSCRIBE_OK) {
         return st;
     }
     if (const auto st = check_input_struct_size(stream_params->struct_size, k_min_stream_params_size);
-        st != TRANSCRIBE_OK)
-    {
+        st != TRANSCRIBE_OK) {
         return st;
     }
     // Read the caller's commit_policy as raw bytes and validate BEFORE the
     // first load through the enum-typed lvalue: C callers can legally store
     // any int there, and an out-of-range enum load is UB in C++.
-    int commit_policy_raw = TRANSCRIBE_STREAM_COMMIT_AUTO;
+    int      commit_policy_raw         = TRANSCRIBE_STREAM_COMMIT_AUTO;
     uint32_t stable_prefix_agreement_n = 0;
-    if (has_field(stream_params->struct_size,
-                  k_stream_params_commit_policy_size))
-    {
+    if (has_field(stream_params->struct_size, k_stream_params_commit_policy_size)) {
         static_assert(sizeof(stream_params->commit_policy) == sizeof(int),
                       "commit_policy must be int-sized for the raw read");
-        std::memcpy(&commit_policy_raw, &stream_params->commit_policy,
-                    sizeof(commit_policy_raw));
+        std::memcpy(&commit_policy_raw, &stream_params->commit_policy, sizeof(commit_policy_raw));
     }
     if (!valid_stream_commit_policy(commit_policy_raw)) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
     const transcribe_stream_commit_policy commit_policy =
         static_cast<transcribe_stream_commit_policy>(commit_policy_raw);
-    if (has_field(stream_params->struct_size,
-                  k_stream_params_agreement_n_size))
-    {
+    if (has_field(stream_params->struct_size, k_stream_params_agreement_n_size)) {
         stable_prefix_agreement_n = stream_params->stable_prefix_agreement_n;
         if (stable_prefix_agreement_n > 32) {
             return TRANSCRIBE_ERR_INVALID_ARG;
@@ -1712,17 +1655,12 @@ extern "C" transcribe_status transcribe_stream_begin(
     // remains optional; the dispatcher's clear_result + state wipe is
     // sufficient when a family does not need to release per-utterance
     // buffers explicitly.
-    if (!session->model->caps.supports_streaming                ||
-        session->model->arch->stream_begin    == nullptr        ||
-        session->model->arch->stream_feed     == nullptr        ||
-        session->model->arch->stream_finalize == nullptr)
-    {
+    if (!session->model->caps.supports_streaming || session->model->arch->stream_begin == nullptr ||
+        session->model->arch->stream_feed == nullptr || session->model->arch->stream_finalize == nullptr) {
         return TRANSCRIBE_ERR_NOT_IMPLEMENTED;
     }
 
-    if (const transcribe_status st = validate_run_params_common(session, run_params);
-        st != TRANSCRIBE_OK)
-    {
+    if (const transcribe_status st = validate_run_params_common(session, run_params); st != TRANSCRIBE_OK) {
         return st;
     }
 
@@ -1738,11 +1676,8 @@ extern "C" transcribe_status transcribe_stream_begin(
         if (stream_params->family->size < sizeof(struct transcribe_ext)) {
             return TRANSCRIBE_ERR_BAD_STRUCT_SIZE;
         }
-        if (!transcribe_model_accepts_ext_kind(
-                session->model,
-                TRANSCRIBE_EXT_SLOT_STREAM,
-                stream_params->family->kind))
-        {
+        if (!transcribe_model_accepts_ext_kind(session->model, TRANSCRIBE_EXT_SLOT_STREAM,
+                                               stream_params->family->kind)) {
             return TRANSCRIBE_ERR_INVALID_ARG;
         }
     }
@@ -1758,23 +1693,21 @@ extern "C" transcribe_status transcribe_stream_begin(
     // non-OK return the previous snapshot and lifecycle are preserved
     // so a caller-side typo does not destroy the prior utterance.
     if (session->model->arch->stream_validate != nullptr) {
-        if (const transcribe_status st = session->model->arch->stream_validate(
-                session, run_params, stream_params);
-            st != TRANSCRIBE_OK)
-        {
+        if (const transcribe_status st = session->model->arch->stream_validate(session, run_params, stream_params);
+            st != TRANSCRIBE_OK) {
             return st;
         }
     }
 
     // All checks pass — clear the previous snapshot and hand off.
     session->clear_result();
-    session->t_mel_us    = 0;
-    session->t_encode_us = 0;
-    session->t_decode_us = 0;
-    session->was_aborted = false;
-    session->was_truncated = false;
-    session->stream_state = TRANSCRIBE_STREAM_ACTIVE;
-    session->stream_commit_policy = commit_policy;
+    session->t_mel_us                         = 0;
+    session->t_encode_us                      = 0;
+    session->t_decode_us                      = 0;
+    session->was_aborted                      = false;
+    session->was_truncated                    = false;
+    session->stream_state                     = TRANSCRIBE_STREAM_ACTIVE;
+    session->stream_commit_policy             = commit_policy;
     session->stream_stable_prefix_agreement_n = stable_prefix_agreement_n;
 
     // Hand the family hook a params view whose pointers the LIBRARY owns.
@@ -1786,11 +1719,8 @@ extern "C" transcribe_status transcribe_stream_begin(
     // family reads it on the stream path today, and per the ext copy-out
     // contract a retained pointer to it would dangle; a future family that
     // wants a run-slot ext at stream begin must plumb it deliberately.
-    session->stream_language_owned =
-        run_params->language != nullptr ? run_params->language : "";
-    session->stream_target_language_owned =
-        run_params->target_language != nullptr ? run_params->target_language
-                                                : "";
+    session->stream_language_owned        = run_params->language != nullptr ? run_params->language : "";
+    session->stream_target_language_owned = run_params->target_language != nullptr ? run_params->target_language : "";
     // PREFIX copy, not struct assignment: the size gate above admits any
     // struct_size >= k_min_run_params_size, so a conforming caller's
     // allocation may be SHORTER than sizeof (fields past `family`, e.g.
@@ -1801,24 +1731,19 @@ extern "C" transcribe_status transcribe_stream_begin(
     struct transcribe_run_params run_params_owned;
     transcribe_run_params_init(&run_params_owned);
     std::memcpy(&run_params_owned, run_params,
-                static_cast<size_t>(std::min<uint64_t>(
-                    run_params->struct_size, sizeof(run_params_owned))));
-    run_params_owned.language =
-        run_params->language != nullptr
-            ? session->stream_language_owned.c_str() : nullptr;
+                static_cast<size_t>(std::min<uint64_t>(run_params->struct_size, sizeof(run_params_owned))));
+    run_params_owned.language = run_params->language != nullptr ? session->stream_language_owned.c_str() : nullptr;
     run_params_owned.target_language =
-        run_params->target_language != nullptr
-            ? session->stream_target_language_owned.c_str() : nullptr;
+        run_params->target_language != nullptr ? session->stream_target_language_owned.c_str() : nullptr;
     run_params_owned.family = nullptr;
 
-    const transcribe_status st = session->model->arch->stream_begin(
-        session, &run_params_owned, stream_params);
+    const transcribe_status st = session->model->arch->stream_begin(session, &run_params_owned, stream_params);
     if (st != TRANSCRIBE_OK) {
         // Family hook rejected the begin (config it does not understand,
         // memory allocation failure, etc.). Roll lifecycle back to
         // FAILED so the caller can read last_status; leave the cleared
         // result snapshot in place.
-        session->stream_state      = TRANSCRIBE_STREAM_FAILED;
+        session->stream_state       = TRANSCRIBE_STREAM_FAILED;
         session->stream_last_status = st;
     }
     return st;
@@ -1832,24 +1757,20 @@ static transcribe_status prepare_stream_update(struct transcribe_stream_update *
     if (update == nullptr) {
         return TRANSCRIBE_OK;
     }
-    if (const auto st = check_struct_size(update->struct_size, k_min_stream_update_size);
-        st != TRANSCRIBE_OK)
-    {
+    if (const auto st = check_struct_size(update->struct_size, k_min_stream_update_size); st != TRANSCRIBE_OK) {
         return st;
     }
-    const uint64_t caller_size = update->struct_size;
+    const uint64_t           caller_size = update->struct_size;
     transcribe_stream_update staged{};
     staged.struct_size = caller_size;
     copy_out_prefix(update, &staged, caller_size, sizeof(staged));
     return TRANSCRIBE_OK;
 }
 
-extern "C" transcribe_status transcribe_stream_feed(
-    struct transcribe_session *        session,
-    const float *                      pcm,
-    int                                n_samples,
-    struct transcribe_stream_update *  update)
-{
+extern "C" transcribe_status transcribe_stream_feed(struct transcribe_session *       session,
+                                                    const float *                     pcm,
+                                                    int                               n_samples,
+                                                    struct transcribe_stream_update * update) {
     if (const auto st = prepare_stream_update(update); st != TRANSCRIBE_OK) {
         return st;
     }
@@ -1868,47 +1789,35 @@ extern "C" transcribe_status transcribe_stream_feed(
     // begin already confirmed model/arch/hook; we re-check defensively
     // so a malformed context (never happens in practice from a real
     // begin) does not deref a null function pointer.
-    if (session->model == nullptr || session->model->arch == nullptr ||
-        session->model->arch->stream_feed == nullptr)
-    {
+    if (session->model == nullptr || session->model->arch == nullptr || session->model->arch->stream_feed == nullptr) {
         return TRANSCRIBE_ERR_NOT_IMPLEMENTED;
     }
 
-    const int32_t prev_revision = session->stream_revision;
-    const std::string prev_full_text = session->full_text;
-    const bool prev_has_result = session->has_result;
+    const int32_t     prev_revision   = session->stream_revision;
+    const std::string prev_full_text  = session->full_text;
+    const bool        prev_has_result = session->has_result;
 
-    const transcribe_status st = session->model->arch->stream_feed(
-        session, pcm, n_samples, update);
+    const transcribe_status st = session->model->arch->stream_feed(session, pcm, n_samples, update);
     if (st != TRANSCRIBE_OK) {
         session->stream_state       = TRANSCRIBE_STREAM_FAILED;
         session->stream_last_status = st;
         return st;
     }
-    const StreamTextDelta text_delta =
-        apply_stream_text_policy(session, /*is_finalize=*/false);
-    if (session->stream_commit_policy ==
-        TRANSCRIBE_STREAM_COMMIT_ON_FINALIZE)
-    {
+    const StreamTextDelta text_delta = apply_stream_text_policy(session, /*is_finalize=*/false);
+    if (session->stream_commit_policy == TRANSCRIBE_STREAM_COMMIT_ON_FINALIZE) {
         session->n_committed_tokens   = 0;
         session->n_committed_words    = 0;
         session->n_committed_segments = 0;
     }
-    publish_observable_delta(session, update, prev_revision,
-                             prev_full_text, prev_has_result, text_delta);
-    if (update != nullptr &&
-        session->stream_commit_policy ==
-            TRANSCRIBE_STREAM_COMMIT_ON_FINALIZE)
-    {
+    publish_observable_delta(session, update, prev_revision, prev_full_text, prev_has_result, text_delta);
+    if (update != nullptr && session->stream_commit_policy == TRANSCRIBE_STREAM_COMMIT_ON_FINALIZE) {
         update->audio_committed_ms = 0;
     }
     return st;
 }
 
-extern "C" transcribe_status transcribe_stream_finalize(
-    struct transcribe_session *        session,
-    struct transcribe_stream_update *  update)
-{
+extern "C" transcribe_status transcribe_stream_finalize(struct transcribe_session *       session,
+                                                        struct transcribe_stream_update * update) {
     if (const auto st = prepare_stream_update(update); st != TRANSCRIBE_OK) {
         return st;
     }
@@ -1919,14 +1828,13 @@ extern "C" transcribe_status transcribe_stream_finalize(
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
     if (session->model == nullptr || session->model->arch == nullptr ||
-        session->model->arch->stream_finalize == nullptr)
-    {
+        session->model->arch->stream_finalize == nullptr) {
         return TRANSCRIBE_ERR_NOT_IMPLEMENTED;
     }
 
-    const int32_t prev_revision = session->stream_revision;
-    const std::string prev_full_text = session->full_text;
-    const bool prev_has_result = session->has_result;
+    const int32_t     prev_revision   = session->stream_revision;
+    const std::string prev_full_text  = session->full_text;
+    const bool        prev_has_result = session->has_result;
 
     const transcribe_status st = session->model->arch->stream_finalize(session, update);
     if (update != nullptr) {
@@ -1940,10 +1848,8 @@ extern "C" transcribe_status transcribe_stream_finalize(
         session->stream_last_status = st;
         return st;
     }
-    const StreamTextDelta text_delta =
-        apply_stream_text_policy(session, /*is_finalize=*/true);
-    publish_observable_delta(session, update, prev_revision,
-                             prev_full_text, prev_has_result, text_delta);
+    const StreamTextDelta text_delta = apply_stream_text_policy(session, /*is_finalize=*/true);
+    publish_observable_delta(session, update, prev_revision, prev_full_text, prev_has_result, text_delta);
     session->stream_state = TRANSCRIBE_STREAM_FINISHED;
     return TRANSCRIBE_OK;
 }
@@ -1956,9 +1862,7 @@ extern "C" void transcribe_stream_reset(struct transcribe_session * session) {
     // audio contents while keeping the allocations. A family without
     // streaming just has no hook installed; reset becomes a pure
     // dispatcher state wipe.
-    if (session->model != nullptr && session->model->arch != nullptr &&
-        session->model->arch->stream_reset != nullptr)
-    {
+    if (session->model != nullptr && session->model->arch != nullptr && session->model->arch->stream_reset != nullptr) {
         session->model->arch->stream_reset(session);
     }
     session->clear_result();
@@ -1968,9 +1872,7 @@ extern "C" void transcribe_stream_reset(struct transcribe_session * session) {
     session->was_aborted  = false;
 }
 
-extern "C" enum transcribe_stream_state
-transcribe_stream_get_state(const struct transcribe_session * session)
-{
+extern "C" enum transcribe_stream_state transcribe_stream_get_state(const struct transcribe_session * session) {
     if (session == nullptr) {
         return TRANSCRIBE_STREAM_IDLE;
     }
@@ -1984,67 +1886,56 @@ extern "C" int transcribe_stream_revision(const struct transcribe_session * sess
     return session->stream_revision;
 }
 
-extern "C" int transcribe_stream_n_committed_segments(
-    const struct transcribe_session * session)
-{
-    if (session == nullptr) return 0;
+extern "C" int transcribe_stream_n_committed_segments(const struct transcribe_session * session) {
+    if (session == nullptr) {
+        return 0;
+    }
     return session->n_committed_segments;
 }
 
-extern "C" int transcribe_stream_n_committed_words(
-    const struct transcribe_session * session)
-{
-    if (session == nullptr) return 0;
+extern "C" int transcribe_stream_n_committed_words(const struct transcribe_session * session) {
+    if (session == nullptr) {
+        return 0;
+    }
     return session->n_committed_words;
 }
 
-extern "C" int transcribe_stream_n_committed_tokens(
-    const struct transcribe_session * session)
-{
-    if (session == nullptr) return 0;
+extern "C" int transcribe_stream_n_committed_tokens(const struct transcribe_session * session) {
+    if (session == nullptr) {
+        return 0;
+    }
     return session->n_committed_tokens;
 }
 
-extern "C" transcribe_status transcribe_stream_last_status(
-    const struct transcribe_session * session)
-{
+extern "C" transcribe_status transcribe_stream_last_status(const struct transcribe_session * session) {
     if (session == nullptr) {
         return TRANSCRIBE_OK;
     }
     return session->stream_last_status;
 }
 
-extern "C" transcribe_status transcribe_stream_get_text(
-    const struct transcribe_session * session,
-    struct transcribe_stream_text *   out)
-{
+extern "C" transcribe_status transcribe_stream_get_text(const struct transcribe_session * session,
+                                                        struct transcribe_stream_text *   out) {
     if (out == nullptr) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
-    if (const auto st = check_struct_size(out->struct_size, k_min_stream_text_size);
-        st != TRANSCRIBE_OK)
-    {
+    if (const auto st = check_struct_size(out->struct_size, k_min_stream_text_size); st != TRANSCRIBE_OK) {
         return st;
     }
-    const uint64_t caller_size = out->struct_size;
+    const uint64_t         caller_size = out->struct_size;
     transcribe_stream_text staged{};
     staged.struct_size = caller_size;
     if (session != nullptr && session->has_result) {
-        staged.full_text = session->full_text.c_str();
-        staged.full_text_bytes =
-            static_cast<uint64_t>(session->full_text.size());
-        staged.committed_text = session->stream_committed_text.c_str();
-        staged.committed_text_bytes =
-            static_cast<uint64_t>(session->stream_committed_text.size());
-        staged.tentative_text = session->stream_tentative_text.c_str();
-        staged.tentative_text_bytes =
-            static_cast<uint64_t>(session->stream_tentative_text.size());
+        staged.full_text            = session->full_text.c_str();
+        staged.full_text_bytes      = static_cast<uint64_t>(session->full_text.size());
+        staged.committed_text       = session->stream_committed_text.c_str();
+        staged.committed_text_bytes = static_cast<uint64_t>(session->stream_committed_text.size());
+        staged.tentative_text       = session->stream_tentative_text.c_str();
+        staged.tentative_text_bytes = static_cast<uint64_t>(session->stream_tentative_text.size());
         staged.raw_tentative_start_bytes =
-            std::min<uint64_t>(
-                session->stream_raw_tentative_start_bytes,
-                staged.full_text_bytes);
+            std::min<uint64_t>(session->stream_raw_tentative_start_bytes, staged.full_text_bytes);
     } else {
-        staged.full_text = "";
+        staged.full_text      = "";
         staged.committed_text = "";
         staged.tentative_text = "";
     }
@@ -2058,12 +1949,10 @@ extern "C" transcribe_status transcribe_stream_get_text(
 // below clears batch_results once before delegating here. Every early
 // return preserves the previous result snapshot exactly as the original
 // transcribe_run contract documented (see the inline comments).
-static transcribe_status run_one_inner(
-    struct transcribe_session *      session,
-    const float *                    pcm,
-    int                              n_samples,
-    const struct transcribe_run_params * params)
-{
+static transcribe_status run_one_inner(struct transcribe_session *          session,
+                                       const float *                        pcm,
+                                       int                                  n_samples,
+                                       const struct transcribe_run_params * params) {
     // Parameter-shape validation runs first and does not touch session
     // state. A caller that passes NULL pointers or a non-positive sample
     // count gets ERR_INVALID_ARG back without any visible side effect
@@ -2085,13 +1974,12 @@ static transcribe_status run_one_inner(
     // NULL params means "all defaults" (transcribe vs translate, no
     // timestamps, etc.). A well-formed default run is not a malformed
     // call, so it proceeds and replaces the previous result.
-    struct transcribe_run_params params_defaults; transcribe_run_params_init(&params_defaults);
+    struct transcribe_run_params params_defaults;
+    transcribe_run_params_init(&params_defaults);
     if (params == nullptr) {
         params = &params_defaults;
     }
-    if (const auto st = check_input_struct_size(params->struct_size, k_min_run_params_size);
-        st != TRANSCRIBE_OK)
-    {
+    if (const auto st = check_input_struct_size(params->struct_size, k_min_run_params_size); st != TRANSCRIBE_OK) {
         return st;
     }
     // A run cannot replace an active stream's results — that would
@@ -2113,17 +2001,11 @@ static transcribe_status run_one_inner(
     // does this for prompt semantics) can still reject a correctly-shaped
     // ext after the snapshot is cleared; full pre-clear safety requires
     // validating values in run_validate.
-    if (params->family != nullptr &&
-        session->model != nullptr && session->model->arch != nullptr)
-    {
+    if (params->family != nullptr && session->model != nullptr && session->model->arch != nullptr) {
         if (params->family->size < sizeof(struct transcribe_ext)) {
             return TRANSCRIBE_ERR_BAD_STRUCT_SIZE;
         }
-        if (!transcribe_model_accepts_ext_kind(
-                session->model,
-                TRANSCRIBE_EXT_SLOT_RUN,
-                params->family->kind))
-        {
+        if (!transcribe_model_accepts_ext_kind(session->model, TRANSCRIBE_EXT_SLOT_RUN, params->family->kind)) {
             return TRANSCRIBE_ERR_INVALID_ARG;
         }
     }
@@ -2147,14 +2029,10 @@ static transcribe_status run_one_inner(
         // model-null case falls through to the post-clear
         // NOT_IMPLEMENTED path, which keeps its existing snapshot-wipe
         // behavior.
-        if (const transcribe_status st = validate_run_params_common(session, params);
-            st != TRANSCRIBE_OK)
-        {
+        if (const transcribe_status st = validate_run_params_common(session, params); st != TRANSCRIBE_OK) {
             return st;
         }
-        if (params->task == TRANSCRIBE_TASK_TRANSLATE &&
-            !session->model->caps.supports_translate)
-        {
+        if (params->task == TRANSCRIBE_TASK_TRANSLATE && !session->model->caps.supports_translate) {
             return TRANSCRIBE_ERR_UNSUPPORTED_TASK;
         }
 
@@ -2167,13 +2045,8 @@ static transcribe_status run_one_inner(
         // family with no _RUN ext leaves this hook NULL. Called regardless
         // of whether params->family is set (whisper's hook treats a NULL
         // family as "defaults", returning OK).
-        if (session->model->arch != nullptr &&
-            session->model->arch->run_validate != nullptr)
-        {
-            if (const transcribe_status st =
-                    session->model->arch->run_validate(session, params);
-                st != TRANSCRIBE_OK)
-            {
+        if (session->model->arch != nullptr && session->model->arch->run_validate != nullptr) {
+            if (const transcribe_status st = session->model->arch->run_validate(session, params); st != TRANSCRIBE_OK) {
                 return st;
             }
         }
@@ -2195,32 +2068,28 @@ static transcribe_status run_one_inner(
     // redundant but idempotent, and removing it is a refactor
     // deferred to a later pass.
     session->clear_result();
-    session->t_mel_us    = 0;
-    session->t_encode_us = 0;
-    session->t_decode_us = 0;
-    session->was_aborted = false;
+    session->t_mel_us      = 0;
+    session->t_encode_us   = 0;
+    session->t_decode_us   = 0;
+    session->was_aborted   = false;
     session->was_truncated = false;
     // Force stream_state to IDLE: clear_result deliberately preserves
     // lifecycle state, but a well-formed transcribe_run subsumes any
     // prior FINISHED/FAILED stream — after a one-shot run the context
     // is no longer meaningfully in a streaming lifecycle.
-    session->stream_state = TRANSCRIBE_STREAM_IDLE;
+    session->stream_state  = TRANSCRIBE_STREAM_IDLE;
 
-    if (session->model == nullptr || session->model->arch == nullptr ||
-        session->model->arch->run == nullptr)
-    {
+    if (session->model == nullptr || session->model->arch == nullptr || session->model->arch->run == nullptr) {
         return TRANSCRIBE_ERR_NOT_IMPLEMENTED;
     }
 
     return session->model->arch->run(session, pcm, n_samples, params);
 }
 
-extern "C" transcribe_status transcribe_run(
-    struct transcribe_session *      session,
-    const float *                    pcm,
-    int                              n_samples,
-    const struct transcribe_run_params * params)
-{
+extern "C" transcribe_status transcribe_run(struct transcribe_session *          session,
+                                            const float *                        pcm,
+                                            int                                  n_samples,
+                                            const struct transcribe_run_params * params) {
     // A well-formed single run has the same result view as a one-item batch:
     // reset batch_results so the transcribe_batch_* accessors fall back to
     // reading the scratch slot as utterance 0.
@@ -2246,9 +2115,7 @@ extern "C" transcribe_status transcribe_run(
 namespace {
 
 // Copy the session's scratch result slot into a ResultSet snapshot.
-transcribe_session::ResultSet snapshot_scratch_result(
-    const transcribe_session * s, transcribe_status status)
-{
+transcribe_session::ResultSet snapshot_scratch_result(const transcribe_session * s, transcribe_status status) {
     transcribe_session::ResultSet rs;
     rs.tokens            = s->tokens;
     rs.words             = s->words;
@@ -2276,9 +2143,7 @@ void pad_batch_results_aborted(transcribe_session * s, int n) {
 
 // Restore the scratch slot from a ResultSet so the single-result accessors
 // stay coherent after a batch run (they reflect utterance 0).
-void restore_scratch_from_result(
-    transcribe_session * s, const transcribe_session::ResultSet & rs)
-{
+void restore_scratch_from_result(transcribe_session * s, const transcribe_session::ResultSet & rs) {
     s->tokens            = rs.tokens;
     s->words             = rs.words;
     s->segments          = rs.segments;
@@ -2288,15 +2153,13 @@ void restore_scratch_from_result(
     s->has_result        = rs.has_result;
 }
 
-} // namespace
+}  // namespace
 
-extern "C" transcribe_status transcribe_run_batch(
-    struct transcribe_session *          session,
-    const float * const *                pcm,
-    const int *                          n_samples,
-    int                                  n,
-    const struct transcribe_run_params * params)
-{
+extern "C" transcribe_status transcribe_run_batch(struct transcribe_session *          session,
+                                                  const float * const *                pcm,
+                                                  const int *                          n_samples,
+                                                  int                                  n,
+                                                  const struct transcribe_run_params * params) {
     // Top-level argument shape. The arrays themselves must be present and
     // n strictly positive; an individual malformed utterance (pcm[i] NULL
     // or n_samples[i] <= 0) is a per-utterance failure handled in the loop,
@@ -2305,13 +2168,12 @@ extern "C" transcribe_status transcribe_run_batch(
     if (session == nullptr || pcm == nullptr || n_samples == nullptr || n <= 0) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
-    struct transcribe_run_params params_defaults; transcribe_run_params_init(&params_defaults);
+    struct transcribe_run_params params_defaults;
+    transcribe_run_params_init(&params_defaults);
     if (params == nullptr) {
         params = &params_defaults;
     }
-    if (const auto st = check_input_struct_size(params->struct_size, k_min_run_params_size);
-        st != TRANSCRIBE_OK)
-    {
+    if (const auto st = check_input_struct_size(params->struct_size, k_min_run_params_size); st != TRANSCRIBE_OK) {
         return st;
     }
     if (session->stream_state == TRANSCRIBE_STREAM_ACTIVE) {
@@ -2322,62 +2184,46 @@ extern "C" transcribe_status transcribe_run_batch(
     // gates (ext shape/kind, pnc/itn advisory, enum range, timestamp
     // ceiling, language, TRANSLATE support, run_validate). A rejection here
     // preserves the previous result snapshot — nothing has been cleared.
-    if (params->family != nullptr &&
-        session->model != nullptr && session->model->arch != nullptr)
-    {
+    if (params->family != nullptr && session->model != nullptr && session->model->arch != nullptr) {
         if (params->family->size < sizeof(struct transcribe_ext)) {
             return TRANSCRIBE_ERR_BAD_STRUCT_SIZE;
         }
-        if (!transcribe_model_accepts_ext_kind(
-                session->model, TRANSCRIBE_EXT_SLOT_RUN, params->family->kind))
-        {
+        if (!transcribe_model_accepts_ext_kind(session->model, TRANSCRIBE_EXT_SLOT_RUN, params->family->kind)) {
             return TRANSCRIBE_ERR_INVALID_ARG;
         }
     }
     if (session->model != nullptr) {
         warn_unsupported_advisory(session->model, params);
-        if (const transcribe_status st = validate_run_params_common(session, params);
-            st != TRANSCRIBE_OK)
-        {
+        if (const transcribe_status st = validate_run_params_common(session, params); st != TRANSCRIBE_OK) {
             return st;
         }
-        if (params->task == TRANSCRIBE_TASK_TRANSLATE &&
-            !session->model->caps.supports_translate)
-        {
+        if (params->task == TRANSCRIBE_TASK_TRANSLATE && !session->model->caps.supports_translate) {
             return TRANSCRIBE_ERR_UNSUPPORTED_TASK;
         }
-        if (session->model->arch != nullptr &&
-            session->model->arch->run_validate != nullptr)
-        {
-            if (const transcribe_status st =
-                    session->model->arch->run_validate(session, params);
-                st != TRANSCRIBE_OK)
-            {
+        if (session->model->arch != nullptr && session->model->arch->run_validate != nullptr) {
+            if (const transcribe_status st = session->model->arch->run_validate(session, params); st != TRANSCRIBE_OK) {
                 return st;
             }
         }
     }
 
-    if (session->model == nullptr || session->model->arch == nullptr ||
-        session->model->arch->run == nullptr)
-    {
+    if (session->model == nullptr || session->model->arch == nullptr || session->model->arch->run == nullptr) {
         return TRANSCRIBE_ERR_NOT_IMPLEMENTED;
     }
 
     // Past this point we commit to producing a fresh batch result.
     session->clear_result();
-    session->t_mel_us    = 0;
-    session->t_encode_us = 0;
-    session->t_decode_us = 0;
-    session->was_aborted = false;
+    session->t_mel_us      = 0;
+    session->t_encode_us   = 0;
+    session->t_decode_us   = 0;
+    session->was_aborted   = false;
     session->was_truncated = false;
-    session->stream_state = TRANSCRIBE_STREAM_IDLE;
+    session->stream_state  = TRANSCRIBE_STREAM_IDLE;
     session->batch_results.clear();
 
     // Fast path: a family with a batched compute graph owns the whole loop.
     if (session->model->arch->run_batch != nullptr) {
-        const transcribe_status st =
-            session->model->arch->run_batch(session, pcm, n_samples, n, params);
+        const transcribe_status st = session->model->arch->run_batch(session, pcm, n_samples, n, params);
         // On abort the hook may retain only completed results; synthesize any
         // missing slots so the result-set view always exposes n entries.
         if (st == TRANSCRIBE_ERR_ABORTED) {
@@ -2403,11 +2249,9 @@ extern "C" transcribe_status transcribe_run_batch(
         // run_one_inner clears the scratch slot and writes this utterance's
         // result; it re-validates the shared params (idempotent) and
         // validates this utterance's pcm[i] / n_samples[i].
-        const transcribe_status st =
-            run_one_inner(session, pcm[i], n_samples[i], params);
+        const transcribe_status st = run_one_inner(session, pcm[i], n_samples[i], params);
         if (st == TRANSCRIBE_OK) {
-            session->batch_results.push_back(
-                snapshot_scratch_result(session, st));
+            session->batch_results.push_back(snapshot_scratch_result(session, st));
         } else {
             // Malformed-input early returns preserve the previous scratch
             // slot, so do NOT snapshot it — record an explicit empty
@@ -2442,16 +2286,12 @@ extern "C" transcribe_status transcribe_run_batch(
 // These accessors read directly from the base struct; per-family load()
 // fills caps / variant / backend before returning success.
 
-extern "C" transcribe_status transcribe_model_get_capabilities(
-    const struct transcribe_model *  model,
-    struct transcribe_capabilities * out_caps)
-{
+extern "C" transcribe_status transcribe_model_get_capabilities(const struct transcribe_model *  model,
+                                                               struct transcribe_capabilities * out_caps) {
     if (model == nullptr || out_caps == nullptr) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
-    if (const auto st = check_struct_size(out_caps->struct_size, k_min_capabilities_size);
-        st != TRANSCRIBE_OK)
-    {
+    if (const auto st = check_struct_size(out_caps->struct_size, k_min_capabilities_size); st != TRANSCRIBE_OK) {
         return st;
     }
     // Preserve the caller-declared size, then write only the prefix
@@ -2461,23 +2301,19 @@ extern "C" transcribe_status transcribe_model_get_capabilities(
     //
     // Pointer fields written into the caller buffer (e.g. languages)
     // remain model-owned and valid until transcribe_model_free().
-    const uint64_t caller_size = out_caps->struct_size;
-    transcribe_capabilities staged = model->caps;
-    staged.struct_size = caller_size;
+    const uint64_t          caller_size = out_caps->struct_size;
+    transcribe_capabilities staged      = model->caps;
+    staged.struct_size                  = caller_size;
     copy_out_prefix(out_caps, &staged, caller_size, sizeof(staged));
     return TRANSCRIBE_OK;
 }
 
-extern "C" transcribe_status transcribe_session_get_limits(
-    const struct transcribe_session *  session,
-    struct transcribe_session_limits * out)
-{
+extern "C" transcribe_status transcribe_session_get_limits(const struct transcribe_session *  session,
+                                                           struct transcribe_session_limits * out) {
     if (session == nullptr || out == nullptr) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
-    if (const auto st = check_struct_size(out->struct_size, k_min_session_limits_size);
-        st != TRANSCRIBE_OK)
-    {
+    if (const auto st = check_struct_size(out->struct_size, k_min_session_limits_size); st != TRANSCRIBE_OK) {
         return st;
     }
 
@@ -2485,7 +2321,7 @@ extern "C" transcribe_status transcribe_session_get_limits(
     transcribe_session_limits_init(&staged);
 
     const transcribe_model * model = session->model;
-    const auto & lb = model->limits;
+    const auto &             lb    = model->limits;
 
     if (lb.has_context_cap && lb.model_max_ctx > 0) {
         // effective_n_ctx = model max, lowered (never raised) by the session
@@ -2505,12 +2341,10 @@ extern "C" transcribe_status transcribe_session_get_limits(
         if (lb.audio_from_caps) {
             staged.effective_max_audio_ms = model->caps.max_audio_ms;
         } else {
-            const int64_t audio_tokens =
-                (int64_t) eff - lb.prompt_overhead - lb.gen_reserve;
-            staged.effective_max_audio_ms =
-                (audio_tokens > 0 && lb.ms_per_audio_token > 0.0)
-                    ? (int64_t) ((double) audio_tokens * lb.ms_per_audio_token)
-                    : 0;
+            const int64_t audio_tokens    = (int64_t) eff - lb.prompt_overhead - lb.gen_reserve;
+            staged.effective_max_audio_ms = (audio_tokens > 0 && lb.ms_per_audio_token > 0.0) ?
+                                                (int64_t) ((double) audio_tokens * lb.ms_per_audio_token) :
+                                                0;
         }
 
         // max_kv_bytes: worst-case single-utterance KV allocation at the
@@ -2520,10 +2354,8 @@ extern "C" transcribe_status transcribe_session_get_limits(
         // 2/elem otherwise. This is the ceiling for one utterance, not the
         // per-run allocation (the cache grows to fit input); transcribe_run_batch
         // allocates roughly batch_size x this.
-        const int64_t kv_bytes_per_elem =
-            (session->kv_type == TRANSCRIBE_KV_TYPE_F32) ? 4 : 2;
-        staged.max_kv_bytes =
-            lb.kv_elems_per_ctx_token * (int64_t) eff * kv_bytes_per_elem;
+        const int64_t kv_bytes_per_elem = (session->kv_type == TRANSCRIBE_KV_TYPE_F32) ? 4 : 2;
+        staged.max_kv_bytes             = lb.kv_elems_per_ctx_token * (int64_t) eff * kv_bytes_per_elem;
     } else {
         // Unbounded / soft-window family: no decoder context cap. Report the
         // soft window (if any) from caps.max_audio_ms, independent of n_ctx.
@@ -2533,7 +2365,7 @@ extern "C" transcribe_status transcribe_session_get_limits(
     }
 
     const uint64_t caller_size = out->struct_size;
-    staged.struct_size = caller_size;
+    staged.struct_size         = caller_size;
     copy_out_prefix(out, &staged, caller_size, sizeof(staged));
     return TRANSCRIBE_OK;
 }
@@ -2554,8 +2386,7 @@ extern "C" const char * transcribe_model_variant_string(const struct transcribe_
     return model->variant.c_str();
 }
 
-extern "C" const char * transcribe_model_meta_val_str(
-    const struct transcribe_model * model, const char * key) {
+extern "C" const char * transcribe_model_meta_val_str(const struct transcribe_model * model, const char * key) {
     // Generic GGUF string-metadata getter, mirroring llama_model_meta_val_str.
     // Returns a model-owned string (valid until the model is freed) or "" when
     // the model/key is null or the key is absent. There is no fallback to the
@@ -2567,12 +2398,10 @@ extern "C" const char * transcribe_model_meta_val_str(
     return it != model->meta.end() ? it->second.c_str() : "";
 }
 
-extern "C" int transcribe_tokenize(
-    const struct transcribe_model * model,
-    const char *                    text,
-    int32_t *                       tokens,
-    size_t                          n_max)
-{
+extern "C" int transcribe_tokenize(const struct transcribe_model * model,
+                                   const char *                    text,
+                                   int32_t *                       tokens,
+                                   size_t                          n_max) {
     if (model == nullptr || text == nullptr) {
         return INT_MIN;
     }
@@ -2618,16 +2447,12 @@ extern "C" const char * transcribe_model_backend(const struct transcribe_model *
     return model->backend.c_str();
 }
 
-extern "C" transcribe_status transcribe_model_get_device(
-    const struct transcribe_model *    model,
-    struct transcribe_backend_device * out)
-{
+extern "C" transcribe_status transcribe_model_get_device(const struct transcribe_model *    model,
+                                                         struct transcribe_backend_device * out) {
     if (model == nullptr || out == nullptr) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
-    if (const auto st = check_struct_size(out->struct_size, k_min_backend_device_size);
-        st != TRANSCRIBE_OK)
-    {
+    if (const auto st = check_struct_size(out->struct_size, k_min_backend_device_size); st != TRANSCRIBE_OK) {
         return st;
     }
     // The model's primary backend is bound by per-family load(); a model
@@ -2649,39 +2474,34 @@ extern "C" transcribe_status transcribe_model_get_device(
 // transcribe_session::t_{mel,encode,decode}_us), populated by per-family
 // load() / run(). These accessors convert microseconds to milliseconds.
 
-extern "C" transcribe_status transcribe_get_timings(
-    const struct transcribe_session * session,
-    struct transcribe_timings *       out_timings)
-{
+extern "C" transcribe_status transcribe_get_timings(const struct transcribe_session * session,
+                                                    struct transcribe_timings *       out_timings) {
     if (session == nullptr || out_timings == nullptr) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
-    if (const auto st = check_struct_size(out_timings->struct_size, k_min_timings_size);
-        st != TRANSCRIBE_OK)
-    {
+    if (const auto st = check_struct_size(out_timings->struct_size, k_min_timings_size); st != TRANSCRIBE_OK) {
         return st;
     }
-    const uint64_t caller_size = out_timings->struct_size;
+    const uint64_t     caller_size = out_timings->struct_size;
     transcribe_timings staged{};
     staged.struct_size = caller_size;
     if (session->model != nullptr) {
         staged.load_ms = static_cast<float>(session->model->t_load_us) / 1000.0f;
     }
-    staged.mel_ms    = static_cast<float>(session->t_mel_us)    / 1000.0f;
+    staged.mel_ms    = static_cast<float>(session->t_mel_us) / 1000.0f;
     staged.encode_ms = static_cast<float>(session->t_encode_us) / 1000.0f;
     staged.decode_ms = static_cast<float>(session->t_decode_us) / 1000.0f;
     copy_out_prefix(out_timings, &staged, caller_size, sizeof(staged));
     return TRANSCRIBE_OK;
 }
 
-extern "C" void
-transcribe_print_timings(const struct transcribe_session * session)
-{
+extern "C" void transcribe_print_timings(const struct transcribe_session * session) {
     if (session == nullptr) {
         return;
     }
-    struct transcribe_timings t; transcribe_timings_init(&t);
-    (void)transcribe_get_timings(session, &t);
+    struct transcribe_timings t;
+    transcribe_timings_init(&t);
+    (void) transcribe_get_timings(session, &t);
     char buf[256];
 
     std::snprintf(buf, sizeof(buf),
@@ -2694,9 +2514,7 @@ transcribe_print_timings(const struct transcribe_session * session)
     transcribe_log_emit_or_stderr(TRANSCRIBE_LOG_LEVEL_INFO, buf);
 }
 
-extern "C" void
-transcribe_reset_timings(struct transcribe_session * session)
-{
+extern "C" void transcribe_reset_timings(struct transcribe_session * session) {
     if (session == nullptr) {
         return;
     }
@@ -2728,8 +2546,7 @@ extern "C" const char * transcribe_detected_language(const struct transcribe_ses
     return session->detected_language.c_str();
 }
 
-extern "C" transcribe_timestamp_kind
-transcribe_returned_timestamp_kind(const struct transcribe_session * session) {
+extern "C" transcribe_timestamp_kind transcribe_returned_timestamp_kind(const struct transcribe_session * session) {
     if (session == nullptr || !session->has_result) {
         return TRANSCRIBE_TIMESTAMPS_NONE;
     }
@@ -2737,15 +2554,23 @@ transcribe_returned_timestamp_kind(const struct transcribe_session * session) {
 }
 
 extern "C" int transcribe_n_segments(const struct transcribe_session * session) {
-    if (session == nullptr || !session->has_result) return 0;
+    if (session == nullptr || !session->has_result) {
+        return 0;
+    }
     return static_cast<int>(session->segments.size());
 }
+
 extern "C" int transcribe_n_words(const struct transcribe_session * session) {
-    if (session == nullptr || !session->has_result) return 0;
+    if (session == nullptr || !session->has_result) {
+        return 0;
+    }
     return static_cast<int>(session->words.size());
 }
+
 extern "C" int transcribe_n_tokens(const struct transcribe_session * session) {
-    if (session == nullptr || !session->has_result) return 0;
+    if (session == nullptr || !session->has_result) {
+        return 0;
+    }
     return static_cast<int>(session->tokens.size());
 }
 
@@ -2762,29 +2587,23 @@ extern "C" int transcribe_n_tokens(const struct transcribe_session * session) {
 // transcribe_run / transcribe_stream_begin / transcribe_stream_reset /
 // transcribe_session_free on the same context (see the public header).
 
-extern "C" transcribe_status transcribe_get_segment(
-    const struct transcribe_session * session,
-    int                               i,
-    struct transcribe_segment *       out)
-{
+extern "C" transcribe_status transcribe_get_segment(const struct transcribe_session * session,
+                                                    int                               i,
+                                                    struct transcribe_segment *       out) {
     if (out == nullptr) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
-    if (const auto st = check_struct_size(out->struct_size, k_min_segment_size);
-        st != TRANSCRIBE_OK)
-    {
+    if (const auto st = check_struct_size(out->struct_size, k_min_segment_size); st != TRANSCRIBE_OK) {
         return st;
     }
-    const uint64_t caller_size = out->struct_size;
+    const uint64_t     caller_size = out->struct_size;
     transcribe_segment zero{};
     zero.struct_size = caller_size;
     copy_out_prefix(out, &zero, caller_size, sizeof(zero));
-    if (session == nullptr || !session->has_result || i < 0 ||
-        static_cast<size_t>(i) >= session->segments.size())
-    {
+    if (session == nullptr || !session->has_result || i < 0 || static_cast<size_t>(i) >= session->segments.size()) {
         return TRANSCRIBE_OK;
     }
-    const auto & s = session->segments[static_cast<size_t>(i)];
+    const auto &       s = session->segments[static_cast<size_t>(i)];
     transcribe_segment staged{};
     staged.struct_size = caller_size;
     staged.t0_ms       = s.t0_ms;
@@ -2798,29 +2617,23 @@ extern "C" transcribe_status transcribe_get_segment(
     return TRANSCRIBE_OK;
 }
 
-extern "C" transcribe_status transcribe_get_word(
-    const struct transcribe_session * session,
-    int                               i,
-    struct transcribe_word *          out)
-{
+extern "C" transcribe_status transcribe_get_word(const struct transcribe_session * session,
+                                                 int                               i,
+                                                 struct transcribe_word *          out) {
     if (out == nullptr) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
-    if (const auto st = check_struct_size(out->struct_size, k_min_word_size);
-        st != TRANSCRIBE_OK)
-    {
+    if (const auto st = check_struct_size(out->struct_size, k_min_word_size); st != TRANSCRIBE_OK) {
         return st;
     }
-    const uint64_t caller_size = out->struct_size;
+    const uint64_t  caller_size = out->struct_size;
     transcribe_word zero{};
     zero.struct_size = caller_size;
     copy_out_prefix(out, &zero, caller_size, sizeof(zero));
-    if (session == nullptr || !session->has_result || i < 0 ||
-        static_cast<size_t>(i) >= session->words.size())
-    {
+    if (session == nullptr || !session->has_result || i < 0 || static_cast<size_t>(i) >= session->words.size()) {
         return TRANSCRIBE_OK;
     }
-    const auto & w = session->words[static_cast<size_t>(i)];
+    const auto &    w = session->words[static_cast<size_t>(i)];
     transcribe_word staged{};
     staged.struct_size = caller_size;
     staged.t0_ms       = w.t0_ms;
@@ -2833,29 +2646,23 @@ extern "C" transcribe_status transcribe_get_word(
     return TRANSCRIBE_OK;
 }
 
-extern "C" transcribe_status transcribe_get_token(
-    const struct transcribe_session * session,
-    int                               i,
-    struct transcribe_token *         out)
-{
+extern "C" transcribe_status transcribe_get_token(const struct transcribe_session * session,
+                                                  int                               i,
+                                                  struct transcribe_token *         out) {
     if (out == nullptr) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
-    if (const auto st = check_struct_size(out->struct_size, k_min_token_size);
-        st != TRANSCRIBE_OK)
-    {
+    if (const auto st = check_struct_size(out->struct_size, k_min_token_size); st != TRANSCRIBE_OK) {
         return st;
     }
-    const uint64_t caller_size = out->struct_size;
+    const uint64_t   caller_size = out->struct_size;
     transcribe_token zero{};
     zero.struct_size = caller_size;
     copy_out_prefix(out, &zero, caller_size, sizeof(zero));
-    if (session == nullptr || !session->has_result || i < 0 ||
-        static_cast<size_t>(i) >= session->tokens.size())
-    {
+    if (session == nullptr || !session->has_result || i < 0 || static_cast<size_t>(i) >= session->tokens.size()) {
         return TRANSCRIBE_OK;
     }
-    const auto & t = session->tokens[static_cast<size_t>(i)];
+    const auto &     t = session->tokens[static_cast<size_t>(i)];
     transcribe_token staged{};
     staged.struct_size = caller_size;
     staged.id          = t.id;
@@ -2881,13 +2688,13 @@ namespace {
 // Non-owning view of one utterance's result. valid == false means "no such
 // utterance / empty result" and the accessors return their safe sentinels.
 struct BatchResultView {
-    const std::vector<transcribe_session::TokenEntry> *   tokens   = nullptr;
-    const std::vector<transcribe_session::WordEntry> *    words    = nullptr;
-    const std::vector<transcribe_session::SegmentEntry> * segments = nullptr;
-    const std::string *       full_text         = nullptr;
-    const std::string *       detected_language = nullptr;
-    transcribe_timestamp_kind result_kind       = TRANSCRIBE_TIMESTAMPS_NONE;
-    bool                      valid             = false;
+    const std::vector<transcribe_session::TokenEntry> *   tokens            = nullptr;
+    const std::vector<transcribe_session::WordEntry> *    words             = nullptr;
+    const std::vector<transcribe_session::SegmentEntry> * segments          = nullptr;
+    const std::string *                                   full_text         = nullptr;
+    const std::string *                                   detected_language = nullptr;
+    transcribe_timestamp_kind                             result_kind       = TRANSCRIBE_TIMESTAMPS_NONE;
+    bool                                                  valid             = false;
 };
 
 int batch_result_count(const transcribe_session * s) {
@@ -2934,15 +2741,13 @@ BatchResultView batch_result_view(const transcribe_session * s, int i) {
     return v;
 }
 
-} // namespace
+}  // namespace
 
 extern "C" int transcribe_batch_n_results(const struct transcribe_session * session) {
     return batch_result_count(session);
 }
 
-extern "C" transcribe_status transcribe_batch_status(
-    const struct transcribe_session * session, int i)
-{
+extern "C" transcribe_status transcribe_batch_status(const struct transcribe_session * session, int i) {
     if (session == nullptr || i < 0) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
@@ -2958,61 +2763,48 @@ extern "C" transcribe_status transcribe_batch_status(
     return TRANSCRIBE_ERR_INVALID_ARG;
 }
 
-extern "C" const char * transcribe_batch_full_text(
-    const struct transcribe_session * session, int i)
-{
+extern "C" const char * transcribe_batch_full_text(const struct transcribe_session * session, int i) {
     const BatchResultView v = batch_result_view(session, i);
     return v.valid ? v.full_text->c_str() : "";
 }
 
-extern "C" const char * transcribe_batch_detected_language(
-    const struct transcribe_session * session, int i)
-{
+extern "C" const char * transcribe_batch_detected_language(const struct transcribe_session * session, int i) {
     const BatchResultView v = batch_result_view(session, i);
     return v.valid ? v.detected_language->c_str() : "";
 }
 
-extern "C" transcribe_timestamp_kind transcribe_batch_returned_timestamp_kind(
-    const struct transcribe_session * session, int i)
-{
+extern "C" transcribe_timestamp_kind transcribe_batch_returned_timestamp_kind(const struct transcribe_session * session,
+                                                                              int                               i) {
     const BatchResultView v = batch_result_view(session, i);
     return v.valid ? v.result_kind : TRANSCRIBE_TIMESTAMPS_NONE;
 }
 
-extern "C" int transcribe_batch_n_segments(
-    const struct transcribe_session * session, int i)
-{
+extern "C" int transcribe_batch_n_segments(const struct transcribe_session * session, int i) {
     const BatchResultView v = batch_result_view(session, i);
     return v.valid ? static_cast<int>(v.segments->size()) : 0;
 }
 
-extern "C" int transcribe_batch_n_words(
-    const struct transcribe_session * session, int i)
-{
+extern "C" int transcribe_batch_n_words(const struct transcribe_session * session, int i) {
     const BatchResultView v = batch_result_view(session, i);
     return v.valid ? static_cast<int>(v.words->size()) : 0;
 }
 
-extern "C" int transcribe_batch_n_tokens(
-    const struct transcribe_session * session, int i)
-{
+extern "C" int transcribe_batch_n_tokens(const struct transcribe_session * session, int i) {
     const BatchResultView v = batch_result_view(session, i);
     return v.valid ? static_cast<int>(v.tokens->size()) : 0;
 }
 
-extern "C" transcribe_status transcribe_batch_get_segment(
-    const struct transcribe_session * session, int i, int j,
-    struct transcribe_segment * out)
-{
+extern "C" transcribe_status transcribe_batch_get_segment(const struct transcribe_session * session,
+                                                          int                               i,
+                                                          int                               j,
+                                                          struct transcribe_segment *       out) {
     if (out == nullptr) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
-    if (const auto st = check_struct_size(out->struct_size, k_min_segment_size);
-        st != TRANSCRIBE_OK)
-    {
+    if (const auto st = check_struct_size(out->struct_size, k_min_segment_size); st != TRANSCRIBE_OK) {
         return st;
     }
-    const uint64_t caller_size = out->struct_size;
+    const uint64_t     caller_size = out->struct_size;
     transcribe_segment zero{};
     zero.struct_size = caller_size;
     copy_out_prefix(out, &zero, caller_size, sizeof(zero));
@@ -3020,7 +2812,7 @@ extern "C" transcribe_status transcribe_batch_get_segment(
     if (!v.valid || j < 0 || static_cast<size_t>(j) >= v.segments->size()) {
         return TRANSCRIBE_OK;
     }
-    const auto & s = (*v.segments)[static_cast<size_t>(j)];
+    const auto &       s = (*v.segments)[static_cast<size_t>(j)];
     transcribe_segment staged{};
     staged.struct_size = caller_size;
     staged.t0_ms       = s.t0_ms;
@@ -3034,19 +2826,17 @@ extern "C" transcribe_status transcribe_batch_get_segment(
     return TRANSCRIBE_OK;
 }
 
-extern "C" transcribe_status transcribe_batch_get_word(
-    const struct transcribe_session * session, int i, int j,
-    struct transcribe_word * out)
-{
+extern "C" transcribe_status transcribe_batch_get_word(const struct transcribe_session * session,
+                                                       int                               i,
+                                                       int                               j,
+                                                       struct transcribe_word *          out) {
     if (out == nullptr) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
-    if (const auto st = check_struct_size(out->struct_size, k_min_word_size);
-        st != TRANSCRIBE_OK)
-    {
+    if (const auto st = check_struct_size(out->struct_size, k_min_word_size); st != TRANSCRIBE_OK) {
         return st;
     }
-    const uint64_t caller_size = out->struct_size;
+    const uint64_t  caller_size = out->struct_size;
     transcribe_word zero{};
     zero.struct_size = caller_size;
     copy_out_prefix(out, &zero, caller_size, sizeof(zero));
@@ -3054,7 +2844,7 @@ extern "C" transcribe_status transcribe_batch_get_word(
     if (!v.valid || j < 0 || static_cast<size_t>(j) >= v.words->size()) {
         return TRANSCRIBE_OK;
     }
-    const auto & w = (*v.words)[static_cast<size_t>(j)];
+    const auto &    w = (*v.words)[static_cast<size_t>(j)];
     transcribe_word staged{};
     staged.struct_size = caller_size;
     staged.t0_ms       = w.t0_ms;
@@ -3067,19 +2857,17 @@ extern "C" transcribe_status transcribe_batch_get_word(
     return TRANSCRIBE_OK;
 }
 
-extern "C" transcribe_status transcribe_batch_get_token(
-    const struct transcribe_session * session, int i, int j,
-    struct transcribe_token * out)
-{
+extern "C" transcribe_status transcribe_batch_get_token(const struct transcribe_session * session,
+                                                        int                               i,
+                                                        int                               j,
+                                                        struct transcribe_token *         out) {
     if (out == nullptr) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
-    if (const auto st = check_struct_size(out->struct_size, k_min_token_size);
-        st != TRANSCRIBE_OK)
-    {
+    if (const auto st = check_struct_size(out->struct_size, k_min_token_size); st != TRANSCRIBE_OK) {
         return st;
     }
-    const uint64_t caller_size = out->struct_size;
+    const uint64_t   caller_size = out->struct_size;
     transcribe_token zero{};
     zero.struct_size = caller_size;
     copy_out_prefix(out, &zero, caller_size, sizeof(zero));
@@ -3087,7 +2875,7 @@ extern "C" transcribe_status transcribe_batch_get_token(
     if (!v.valid || j < 0 || static_cast<size_t>(j) >= v.tokens->size()) {
         return TRANSCRIBE_OK;
     }
-    const auto & t = (*v.tokens)[static_cast<size_t>(j)];
+    const auto &     t = (*v.tokens)[static_cast<size_t>(j)];
     transcribe_token staged{};
     staged.struct_size = caller_size;
     staged.id          = t.id;
@@ -3101,16 +2889,13 @@ extern "C" transcribe_status transcribe_batch_get_token(
     return TRANSCRIBE_OK;
 }
 
-extern "C" transcribe_status transcribe_batch_get_timings(
-    const struct transcribe_session * session, int i,
-    struct transcribe_timings * out)
-{
+extern "C" transcribe_status transcribe_batch_get_timings(const struct transcribe_session * session,
+                                                          int                               i,
+                                                          struct transcribe_timings *       out) {
     if (session == nullptr || out == nullptr || i < 0) {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
-    if (const auto st = check_struct_size(out->struct_size, k_min_timings_size);
-        st != TRANSCRIBE_OK)
-    {
+    if (const auto st = check_struct_size(out->struct_size, k_min_timings_size); st != TRANSCRIBE_OK) {
         return st;
     }
     int64_t mel_us = 0, enc_us = 0, dec_us = 0;
@@ -3119,7 +2904,9 @@ extern "C" transcribe_status transcribe_batch_get_timings(
             return TRANSCRIBE_ERR_INVALID_ARG;
         }
         const auto & rs = session->batch_results[static_cast<size_t>(i)];
-        mel_us = rs.t_mel_us; enc_us = rs.t_encode_us; dec_us = rs.t_decode_us;
+        mel_us          = rs.t_mel_us;
+        enc_us          = rs.t_encode_us;
+        dec_us          = rs.t_decode_us;
     } else if (i == 0) {
         mel_us = session->t_mel_us;
         enc_us = session->t_encode_us;
@@ -3127,7 +2914,7 @@ extern "C" transcribe_status transcribe_batch_get_timings(
     } else {
         return TRANSCRIBE_ERR_INVALID_ARG;
     }
-    const uint64_t caller_size = out->struct_size;
+    const uint64_t     caller_size = out->struct_size;
     transcribe_timings staged{};
     staged.struct_size = caller_size;
     if (session->model != nullptr) {
diff --git a/tests/api_smoke.c b/tests/api_smoke.c
index 33d614fb..04ae026b 100644
--- a/tests/api_smoke.c
+++ b/tests/api_smoke.c
@@ -42,16 +42,14 @@ static int g_failures = 0;
         }                                                                   \
     } while (0)
 
-#define CHECK_STR_EMPTY(s)                                                  \
-    do {                                                                    \
-        const char * _s = (s);                                              \
-        if (_s == NULL || _s[0] != '\0') {                                  \
-            fprintf(stderr,                                                 \
-                    "FAIL %s:%d: expected empty string, got %s\n",          \
-                    __FILE__, __LINE__,                                     \
-                    _s == NULL ? "(null)" : _s);                            \
-            g_failures++;                                                   \
-        }                                                                   \
+#define CHECK_STR_EMPTY(s)                                                                     \
+    do {                                                                                       \
+        const char * _s = (s);                                                                 \
+        if (_s == NULL || _s[0] != '\0') {                                                     \
+            fprintf(stderr, "FAIL %s:%d: expected empty string, got %s\n", __FILE__, __LINE__, \
+                    _s == NULL ? "(null)" : _s);                                               \
+            g_failures++;                                                                      \
+        }                                                                                      \
     } while (0)
 
 static void test_status_string(void) {
@@ -109,9 +107,7 @@ static void test_version(void) {
 
     /* The numeric form stays consistent with the components. */
     CHECK(TRANSCRIBE_VERSION_NUMBER ==
-          TRANSCRIBE_VERSION_MAJOR * 10000 +
-          TRANSCRIBE_VERSION_MINOR * 100 +
-          TRANSCRIBE_VERSION_PATCH);
+          TRANSCRIBE_VERSION_MAJOR * 10000 + TRANSCRIBE_VERSION_MINOR * 100 + TRANSCRIBE_VERSION_PATCH);
 
     /* Commit is never NULL: "unknown" in a non-git build, a short SHA
      * otherwise. */
@@ -124,14 +120,10 @@ static void test_abi_metadata(void) {
     /* The native ABI accessors a binding uses to verify its struct layout.
      * Known ids report this build's sizeof/alignof; an unknown id reports 0
      * (the documented "cannot verify" sentinel, never a real size). */
-    CHECK(transcribe_abi_struct_size(TRANSCRIBE_ABI_RUN_PARAMS) ==
-          sizeof(struct transcribe_run_params));
-    CHECK(transcribe_abi_struct_align(TRANSCRIBE_ABI_RUN_PARAMS) ==
-          _Alignof(struct transcribe_run_params));
-    CHECK(transcribe_abi_struct_size(TRANSCRIBE_ABI_CAPABILITIES) ==
-          sizeof(struct transcribe_capabilities));
-    CHECK(transcribe_abi_struct_size(TRANSCRIBE_ABI_SEGMENT) ==
-          sizeof(struct transcribe_segment));
+    CHECK(transcribe_abi_struct_size(TRANSCRIBE_ABI_RUN_PARAMS) == sizeof(struct transcribe_run_params));
+    CHECK(transcribe_abi_struct_align(TRANSCRIBE_ABI_RUN_PARAMS) == _Alignof(struct transcribe_run_params));
+    CHECK(transcribe_abi_struct_size(TRANSCRIBE_ABI_CAPABILITIES) == sizeof(struct transcribe_capabilities));
+    CHECK(transcribe_abi_struct_size(TRANSCRIBE_ABI_SEGMENT) == sizeof(struct transcribe_segment));
     CHECK(transcribe_abi_struct_size((transcribe_abi_struct) 9999) == 0);
     CHECK(transcribe_abi_struct_align((transcribe_abi_struct) 9999) == 0);
 
@@ -157,9 +149,8 @@ static void test_backend_devices(void) {
 
     /* init_backends argument contract. */
     CHECK(transcribe_init_backends(NULL) == TRANSCRIBE_ERR_INVALID_ARG);
-    CHECK(transcribe_init_backends("")   == TRANSCRIBE_ERR_INVALID_ARG);
-    CHECK(transcribe_init_backends("/nonexistent-transcribe-artifact-dir") ==
-          TRANSCRIBE_ERR_FILE_NOT_FOUND);
+    CHECK(transcribe_init_backends("") == TRANSCRIBE_ERR_INVALID_ARG);
+    CHECK(transcribe_init_backends("/nonexistent-transcribe-artifact-dir") == TRANSCRIBE_ERR_FILE_NOT_FOUND);
 
     /* An existing directory with no modules: OK when backends are already
      * registered (static build), ERR_BACKEND when a dynamic build ends up
@@ -168,7 +159,7 @@ static void test_backend_devices(void) {
     const int st1 = transcribe_init_backends(".");
     CHECK(st1 == TRANSCRIBE_OK || st1 == TRANSCRIBE_ERR_BACKEND);
     const int n_after = transcribe_backend_device_count();
-    const int st2 = transcribe_init_backends(".");
+    const int st2     = transcribe_init_backends(".");
     CHECK(st2 == st1);
     CHECK(transcribe_backend_device_count() == n_after);
 
@@ -194,22 +185,20 @@ static void test_backend_devices(void) {
     CHECK(!transcribe_backend_available((transcribe_backend_request) 999));
 
     /* ABI accessors must know the new struct. */
-    CHECK(transcribe_abi_struct_size(TRANSCRIBE_ABI_BACKEND_DEVICE) ==
-          sizeof(struct transcribe_backend_device));
-    CHECK(transcribe_abi_struct_align(TRANSCRIBE_ABI_BACKEND_DEVICE) ==
-          _Alignof(struct transcribe_backend_device));
+    CHECK(transcribe_abi_struct_size(TRANSCRIBE_ABI_BACKEND_DEVICE) == sizeof(struct transcribe_backend_device));
+    CHECK(transcribe_abi_struct_align(TRANSCRIBE_ABI_BACKEND_DEVICE) == _Alignof(struct transcribe_backend_device));
 }
 
 static void test_log_level_values(void) {
     /* These numeric values must mirror GGML_LOG_LEVEL_* exactly. If this
      * test ever fails, the public contract documented in transcribe.h
      * has been broken. */
-    CHECK(TRANSCRIBE_LOG_LEVEL_NONE  == 0);
-    CHECK(TRANSCRIBE_LOG_LEVEL_INFO  == 1);
-    CHECK(TRANSCRIBE_LOG_LEVEL_WARN  == 2);
+    CHECK(TRANSCRIBE_LOG_LEVEL_NONE == 0);
+    CHECK(TRANSCRIBE_LOG_LEVEL_INFO == 1);
+    CHECK(TRANSCRIBE_LOG_LEVEL_WARN == 2);
     CHECK(TRANSCRIBE_LOG_LEVEL_ERROR == 3);
     CHECK(TRANSCRIBE_LOG_LEVEL_DEBUG == 4);
-    CHECK(TRANSCRIBE_LOG_LEVEL_CONT  == 5);
+    CHECK(TRANSCRIBE_LOG_LEVEL_CONT == 5);
 }
 
 static void test_log_set_null(void) {
@@ -224,32 +213,32 @@ static void test_init_macros(void) {
     struct transcribe_model_load_params mp_macro;
     transcribe_model_load_params_init(&mp_macro);
     CHECK(mp_macro.struct_size == sizeof(struct transcribe_model_load_params));
-    CHECK(mp_macro.backend     == TRANSCRIBE_BACKEND_AUTO);
-    CHECK(mp_macro.gpu_device  == 0);
+    CHECK(mp_macro.backend == TRANSCRIBE_BACKEND_AUTO);
+    CHECK(mp_macro.gpu_device == 0);
 
     struct transcribe_session_params cp_macro;
     transcribe_session_params_init(&cp_macro);
     CHECK(cp_macro.struct_size == sizeof(struct transcribe_session_params));
-    CHECK(cp_macro.n_threads   == 0);
-    CHECK(cp_macro.kv_type     == TRANSCRIBE_KV_TYPE_AUTO);
-    CHECK(cp_macro.n_ctx       == 0);  /* 0 = model max (session context cap) */
+    CHECK(cp_macro.n_threads == 0);
+    CHECK(cp_macro.kv_type == TRANSCRIBE_KV_TYPE_AUTO);
+    CHECK(cp_macro.n_ctx == 0); /* 0 = model max (session context cap) */
 
     struct transcribe_run_params rp_macro;
     transcribe_run_params_init(&rp_macro);
-    CHECK(rp_macro.struct_size        == sizeof(struct transcribe_run_params));
-    CHECK(rp_macro.task               == TRANSCRIBE_TASK_TRANSCRIBE);
-    CHECK(rp_macro.timestamps         == TRANSCRIBE_TIMESTAMPS_AUTO);
-    CHECK(rp_macro.pnc                == TRANSCRIBE_PNC_MODE_DEFAULT);
-    CHECK(rp_macro.itn                == TRANSCRIBE_ITN_MODE_DEFAULT);
-    CHECK(rp_macro.language           == NULL);
-    CHECK(rp_macro.target_language    == NULL);
-    CHECK(rp_macro.keep_special_tags  == false);
-    CHECK(rp_macro.family             == NULL);
+    CHECK(rp_macro.struct_size == sizeof(struct transcribe_run_params));
+    CHECK(rp_macro.task == TRANSCRIBE_TASK_TRANSCRIBE);
+    CHECK(rp_macro.timestamps == TRANSCRIBE_TIMESTAMPS_AUTO);
+    CHECK(rp_macro.pnc == TRANSCRIBE_PNC_MODE_DEFAULT);
+    CHECK(rp_macro.itn == TRANSCRIBE_ITN_MODE_DEFAULT);
+    CHECK(rp_macro.language == NULL);
+    CHECK(rp_macro.target_language == NULL);
+    CHECK(rp_macro.keep_special_tags == false);
+    CHECK(rp_macro.family == NULL);
 
     struct transcribe_stream_params sp_macro;
     transcribe_stream_params_init(&sp_macro);
     CHECK(sp_macro.struct_size == sizeof(struct transcribe_stream_params));
-    CHECK(sp_macro.family      == NULL);
+    CHECK(sp_macro.family == NULL);
     CHECK(sp_macro.commit_policy == TRANSCRIBE_STREAM_COMMIT_AUTO);
     CHECK(sp_macro.stable_prefix_agreement_n == 0);
 
@@ -260,26 +249,28 @@ static void test_init_macros(void) {
      * field values below confirm only that aggregate zero-init still
      * gives the documented zero-value field defaults — useful as a
      * sanity check on the struct layout, not as a calling convention. */
-    struct transcribe_run_params rp_zero = {0};
-    CHECK(rp_zero.task              == TRANSCRIBE_TASK_TRANSCRIBE);
+    struct transcribe_run_params rp_zero = { 0 };
+    CHECK(rp_zero.task == TRANSCRIBE_TASK_TRANSCRIBE);
     CHECK(rp_zero.keep_special_tags == false);
-    CHECK(rp_zero.struct_size       == 0);
+    CHECK(rp_zero.struct_size == 0);
 
     /* Output structs: struct_size set, rest zero-filled. The
      * zero-means-absent contract is what makes a new caller paired with
      * an older library see consistent tail-field reads. */
-    struct transcribe_stream_update upd_macro; transcribe_stream_update_init(&upd_macro);
-    CHECK(upd_macro.struct_size        == sizeof(struct transcribe_stream_update));
-    CHECK(upd_macro.result_changed     == false);
-    CHECK(upd_macro.is_final           == false);
-    CHECK(upd_macro.revision           == 0);
-    CHECK(upd_macro.input_received_ms  == 0);
+    struct transcribe_stream_update upd_macro;
+    transcribe_stream_update_init(&upd_macro);
+    CHECK(upd_macro.struct_size == sizeof(struct transcribe_stream_update));
+    CHECK(upd_macro.result_changed == false);
+    CHECK(upd_macro.is_final == false);
+    CHECK(upd_macro.revision == 0);
+    CHECK(upd_macro.input_received_ms == 0);
     CHECK(upd_macro.audio_committed_ms == 0);
-    CHECK(upd_macro.buffered_ms        == 0);
-    CHECK(upd_macro.committed_changed  == false);
-    CHECK(upd_macro.tentative_changed  == false);
+    CHECK(upd_macro.buffered_ms == 0);
+    CHECK(upd_macro.committed_changed == false);
+    CHECK(upd_macro.tentative_changed == false);
 
-    struct transcribe_stream_text text_macro; transcribe_stream_text_init(&text_macro);
+    struct transcribe_stream_text text_macro;
+    transcribe_stream_text_init(&text_macro);
     CHECK(text_macro.struct_size == sizeof(struct transcribe_stream_text));
     CHECK(text_macro.full_text == NULL);
     CHECK(text_macro.full_text_bytes == 0);
@@ -289,78 +280,82 @@ static void test_init_macros(void) {
     CHECK(text_macro.tentative_text_bytes == 0);
     CHECK(text_macro.raw_tentative_start_bytes == 0);
 
-    struct transcribe_capabilities caps_macro; transcribe_capabilities_init(&caps_macro);
-    CHECK(caps_macro.struct_size                        == sizeof(struct transcribe_capabilities));
-    CHECK(caps_macro.native_sample_rate                 == 0);
-    CHECK(caps_macro.n_languages                        == 0);
-    CHECK(caps_macro.languages                          == NULL);
-    CHECK(caps_macro.supports_language_detect           == false);
-    CHECK(caps_macro.supports_translate                 == false);
-    CHECK(caps_macro.supports_streaming                 == false);
-
-    struct transcribe_timings tm_macro; transcribe_timings_init(&tm_macro);
+    struct transcribe_capabilities caps_macro;
+    transcribe_capabilities_init(&caps_macro);
+    CHECK(caps_macro.struct_size == sizeof(struct transcribe_capabilities));
+    CHECK(caps_macro.native_sample_rate == 0);
+    CHECK(caps_macro.n_languages == 0);
+    CHECK(caps_macro.languages == NULL);
+    CHECK(caps_macro.supports_language_detect == false);
+    CHECK(caps_macro.supports_translate == false);
+    CHECK(caps_macro.supports_streaming == false);
+
+    struct transcribe_timings tm_macro;
+    transcribe_timings_init(&tm_macro);
     CHECK(tm_macro.struct_size == sizeof(struct transcribe_timings));
-    CHECK(tm_macro.load_ms     == 0.0f);
-    CHECK(tm_macro.mel_ms      == 0.0f);
-    CHECK(tm_macro.encode_ms   == 0.0f);
-    CHECK(tm_macro.decode_ms   == 0.0f);
+    CHECK(tm_macro.load_ms == 0.0f);
+    CHECK(tm_macro.mel_ms == 0.0f);
+    CHECK(tm_macro.encode_ms == 0.0f);
+    CHECK(tm_macro.decode_ms == 0.0f);
 
     /* Family extension init functions wire struct_size + kind correctly. */
-    struct transcribe_parakeet_stream_ext pk; transcribe_parakeet_stream_ext_init(&pk);
-    CHECK(pk.ext.size          == sizeof(struct transcribe_parakeet_stream_ext));
-    CHECK(pk.ext.kind          == TRANSCRIBE_EXT_KIND_PARAKEET_STREAM);
+    struct transcribe_parakeet_stream_ext pk;
+    transcribe_parakeet_stream_ext_init(&pk);
+    CHECK(pk.ext.size == sizeof(struct transcribe_parakeet_stream_ext));
+    CHECK(pk.ext.kind == TRANSCRIBE_EXT_KIND_PARAKEET_STREAM);
     CHECK(pk.att_context_right == -1);
 
     struct transcribe_parakeet_buffered_stream_ext pkb;
     transcribe_parakeet_buffered_stream_ext_init(&pkb);
-    CHECK(pkb.ext.size  == sizeof(struct transcribe_parakeet_buffered_stream_ext));
-    CHECK(pkb.ext.kind  == TRANSCRIBE_EXT_KIND_PARAKEET_BUFFERED_STREAM);
-    CHECK(pkb.left_ms   == -1);
-    CHECK(pkb.chunk_ms  == -1);
-    CHECK(pkb.right_ms  == -1);
+    CHECK(pkb.ext.size == sizeof(struct transcribe_parakeet_buffered_stream_ext));
+    CHECK(pkb.ext.kind == TRANSCRIBE_EXT_KIND_PARAKEET_BUFFERED_STREAM);
+    CHECK(pkb.left_ms == -1);
+    CHECK(pkb.chunk_ms == -1);
+    CHECK(pkb.right_ms == -1);
 
     struct transcribe_moonshine_streaming_stream_ext ms;
     transcribe_moonshine_streaming_stream_ext_init(&ms);
-    CHECK(ms.ext.size               == sizeof(struct transcribe_moonshine_streaming_stream_ext));
-    CHECK(ms.ext.kind               == TRANSCRIBE_EXT_KIND_MOONSHINE_STREAMING_STREAM);
+    CHECK(ms.ext.size == sizeof(struct transcribe_moonshine_streaming_stream_ext));
+    CHECK(ms.ext.kind == TRANSCRIBE_EXT_KIND_MOONSHINE_STREAMING_STREAM);
     CHECK(ms.min_decode_interval_ms == -1);
 
     struct transcribe_voxtral_realtime_stream_ext vr;
     transcribe_voxtral_realtime_stream_ext_init(&vr);
-    CHECK(vr.ext.size               == sizeof(struct transcribe_voxtral_realtime_stream_ext));
-    CHECK(vr.ext.kind               == TRANSCRIBE_EXT_KIND_VOXTRAL_REALTIME_STREAM);
-    CHECK(vr.num_delay_tokens       == -1);
+    CHECK(vr.ext.size == sizeof(struct transcribe_voxtral_realtime_stream_ext));
+    CHECK(vr.ext.kind == TRANSCRIBE_EXT_KIND_VOXTRAL_REALTIME_STREAM);
+    CHECK(vr.num_delay_tokens == -1);
     CHECK(vr.min_decode_interval_ms == -1);
 
     struct transcribe_whisper_chunk_trace wtr;
     transcribe_whisper_chunk_trace_init(&wtr);
     CHECK(wtr.struct_size == sizeof(struct transcribe_whisper_chunk_trace));
-    CHECK(wtr.t0_ms       == 0);
-    CHECK(wtr.t1_ms       == 0);
+    CHECK(wtr.t0_ms == 0);
+    CHECK(wtr.t1_ms == 0);
     CHECK(wtr.n_fallbacks == 0);
 
     /* Whisper run extension: kind + size wired by the init function,
      * and the field defaults match the family's shipping recipe. */
-    struct transcribe_whisper_run_ext wrx; transcribe_whisper_run_ext_init(&wrx);
-    CHECK(wrx.ext.size                  == sizeof(struct transcribe_whisper_run_ext));
-    CHECK(wrx.ext.kind                  == TRANSCRIBE_EXT_KIND_WHISPER_RUN);
-    CHECK(wrx.initial_prompt            == NULL);
-    CHECK(wrx.prompt_tokens             == NULL);
-    CHECK(wrx.n_prompt_tokens           == 0);
-    CHECK(wrx.prompt_condition          == TRANSCRIBE_WHISPER_PROMPT_FIRST_SEGMENT);
-    CHECK(wrx.condition_on_prev_tokens  == false);
-    CHECK(wrx.max_prev_context_tokens   == 223);
-    CHECK(wrx.temperature               == 0.0f);
-    CHECK(wrx.temperature_inc           == 0.2f);
-    CHECK(wrx.compression_ratio_thold   == 2.4f);
-    CHECK(wrx.logprob_thold             == -1.0f);
-    CHECK(wrx.no_speech_thold           == 0.6f);
-    CHECK(wrx.seed                      == 0u);
-    CHECK(wrx.max_initial_timestamp     == 1.0f);
+    struct transcribe_whisper_run_ext wrx;
+    transcribe_whisper_run_ext_init(&wrx);
+    CHECK(wrx.ext.size == sizeof(struct transcribe_whisper_run_ext));
+    CHECK(wrx.ext.kind == TRANSCRIBE_EXT_KIND_WHISPER_RUN);
+    CHECK(wrx.initial_prompt == NULL);
+    CHECK(wrx.prompt_tokens == NULL);
+    CHECK(wrx.n_prompt_tokens == 0);
+    CHECK(wrx.prompt_condition == TRANSCRIBE_WHISPER_PROMPT_FIRST_SEGMENT);
+    CHECK(wrx.condition_on_prev_tokens == false);
+    CHECK(wrx.max_prev_context_tokens == 223);
+    CHECK(wrx.temperature == 0.0f);
+    CHECK(wrx.temperature_inc == 0.2f);
+    CHECK(wrx.compression_ratio_thold == 2.4f);
+    CHECK(wrx.logprob_thold == -1.0f);
+    CHECK(wrx.no_speech_thold == 0.6f);
+    CHECK(wrx.seed == 0u);
+    CHECK(wrx.max_initial_timestamp == 1.0f);
 
     /* The disabled-sentinel defines must be usable as compile-time
      * constants with the right signs. */
-    CHECK(TRANSCRIBE_WHISPER_THOLD_DISABLED   > 0.0f);
+    CHECK(TRANSCRIBE_WHISPER_THOLD_DISABLED > 0.0f);
     CHECK(TRANSCRIBE_WHISPER_LOGPROB_DISABLED < 0.0f);
     CHECK(isinf(TRANSCRIBE_WHISPER_THOLD_DISABLED));
     CHECK(isinf(TRANSCRIBE_WHISPER_LOGPROB_DISABLED));
@@ -373,10 +368,11 @@ static void test_init_macros(void) {
  * actually emits log entries yet).
  */
 static int g_dummy_log_calls = 0;
+
 static void dummy_log(transcribe_log_level level, const char * msg, void * userdata) {
-    (void)level;
-    (void)msg;
-    (void)userdata;
+    (void) level;
+    (void) msg;
+    (void) userdata;
     g_dummy_log_calls++;
 }
 
@@ -400,34 +396,30 @@ static void test_log_set_publication(void) {
 static void test_load_invalid(void) {
     struct transcribe_model_load_params mp;
     transcribe_model_load_params_init(&mp);
-    struct transcribe_model *      m  = (struct transcribe_model *)0xdeadbeef;
+    struct transcribe_model * m = (struct transcribe_model *) 0xdeadbeef;
 
     /* NULL out_model -> INVALID_ARG. */
-    CHECK(transcribe_model_load_file("ignored", &mp, NULL)
-          == TRANSCRIBE_ERR_INVALID_ARG);
+    CHECK(transcribe_model_load_file("ignored", &mp, NULL) == TRANSCRIBE_ERR_INVALID_ARG);
 
     /* NULL path -> INVALID_ARG and out_model is cleared. */
-    CHECK(transcribe_model_load_file(NULL, &mp, &m)
-          == TRANSCRIBE_ERR_INVALID_ARG);
+    CHECK(transcribe_model_load_file(NULL, &mp, &m) == TRANSCRIBE_ERR_INVALID_ARG);
     CHECK(m == NULL);
 
     /* NULL params -> "all defaults", NOT an error. Proceeds past param
      * validation and fails only on the missing file. */
-    m = (struct transcribe_model *)0xdeadbeef;
-    CHECK(transcribe_model_load_file("/__transcribe_smoke_does_not_exist__.gguf",
-                                     NULL, &m)
-          == TRANSCRIBE_ERR_FILE_NOT_FOUND);
+    m = (struct transcribe_model *) 0xdeadbeef;
+    CHECK(transcribe_model_load_file("/__transcribe_smoke_does_not_exist__.gguf", NULL, &m) ==
+          TRANSCRIBE_ERR_FILE_NOT_FOUND);
     CHECK(m == NULL);
 
     /* {0} params (struct_size == 0) is REJECTED in pre-1.0: a struct
      * with zero struct_size is treated as a forgot-to-init bug, not as
      * a defaults shortcut, regardless of the rest of the field values.
      * Defaults are reached by passing a NULL pointer (above). */
-    struct transcribe_model_load_params mp0 = {0};
-    m = (struct transcribe_model *)0xdeadbeef;
-    CHECK(transcribe_model_load_file("/__transcribe_smoke_does_not_exist__.gguf",
-                                     &mp0, &m)
-          == TRANSCRIBE_ERR_BAD_STRUCT_SIZE);
+    struct transcribe_model_load_params mp0 = { 0 };
+    m                                       = (struct transcribe_model *) 0xdeadbeef;
+    CHECK(transcribe_model_load_file("/__transcribe_smoke_does_not_exist__.gguf", &mp0, &m) ==
+          TRANSCRIBE_ERR_BAD_STRUCT_SIZE);
     CHECK(m == NULL);
 
     /* gpu_device selection is validated during load against the live device
@@ -438,18 +430,16 @@ static void test_load_invalid(void) {
     struct transcribe_model_load_params mp_dev;
     transcribe_model_load_params_init(&mp_dev);
     mp_dev.gpu_device = 1;
-    m = (struct transcribe_model *)0xdeadbeef;
-    CHECK(transcribe_model_load_file("/__transcribe_smoke_does_not_exist__.gguf",
-                                     &mp_dev, &m)
-          == TRANSCRIBE_ERR_FILE_NOT_FOUND);
+    m                 = (struct transcribe_model *) 0xdeadbeef;
+    CHECK(transcribe_model_load_file("/__transcribe_smoke_does_not_exist__.gguf", &mp_dev, &m) ==
+          TRANSCRIBE_ERR_FILE_NOT_FOUND);
     CHECK(m == NULL);
 
     /* Otherwise-valid call against a path that does not exist on disk
      * -> FILE_NOT_FOUND. */
-    m = (struct transcribe_model *)0xdeadbeef;
-    CHECK(transcribe_model_load_file("/__transcribe_smoke_does_not_exist__.gguf",
-                                     &mp, &m)
-          == TRANSCRIBE_ERR_FILE_NOT_FOUND);
+    m = (struct transcribe_model *) 0xdeadbeef;
+    CHECK(transcribe_model_load_file("/__transcribe_smoke_does_not_exist__.gguf", &mp, &m) ==
+          TRANSCRIBE_ERR_FILE_NOT_FOUND);
     CHECK(m == NULL);
 
     /* Free on NULL is a no-op. */
@@ -457,13 +447,12 @@ static void test_load_invalid(void) {
 }
 
 static void test_context_invalid(void) {
-    struct transcribe_session_params cp; transcribe_session_params_init(&cp);
-    struct transcribe_session *      c  = (struct transcribe_session *)0xdeadbeef;
+    struct transcribe_session_params cp;
+    transcribe_session_params_init(&cp);
+    struct transcribe_session * c = (struct transcribe_session *) 0xdeadbeef;
 
-    CHECK(transcribe_session_init(NULL, &cp, NULL)
-          == TRANSCRIBE_ERR_INVALID_ARG);
-    CHECK(transcribe_session_init(NULL, &cp, &c)
-          == TRANSCRIBE_ERR_INVALID_ARG);
+    CHECK(transcribe_session_init(NULL, &cp, NULL) == TRANSCRIBE_ERR_INVALID_ARG);
+    CHECK(transcribe_session_init(NULL, &cp, &c) == TRANSCRIBE_ERR_INVALID_ARG);
     CHECK(c == NULL);
 
     /* model==NULL is checked before params, so it yields INVALID_ARG
@@ -475,43 +464,37 @@ static void test_context_invalid(void) {
 }
 
 static void test_run_invalid(void) {
-    struct transcribe_run_params rp; transcribe_run_params_init(&rp);
-    float                    pcm[8] = { 0.0f };
+    struct transcribe_run_params rp;
+    transcribe_run_params_init(&rp);
+    float pcm[8] = { 0.0f };
 
-    CHECK(transcribe_run(NULL, pcm, 8, &rp)
-          == TRANSCRIBE_ERR_INVALID_ARG);
-    CHECK(transcribe_run((struct transcribe_session *)0x1, NULL, 8, &rp)
-          == TRANSCRIBE_ERR_INVALID_ARG);
+    CHECK(transcribe_run(NULL, pcm, 8, &rp) == TRANSCRIBE_ERR_INVALID_ARG);
+    CHECK(transcribe_run((struct transcribe_session *) 0x1, NULL, 8, &rp) == TRANSCRIBE_ERR_INVALID_ARG);
     /* NULL params is no longer an error (means "all defaults"), so it
      * can't be probed with a fake session — it would proceed to
      * dereference it. NULL-params-defaults is exercised end-to-end in the
      * real-model smoke tests instead. */
     /* n_samples must be strictly positive: both negative and zero are
      * rejected before the session is dereferenced (matches stream_feed). */
-    CHECK(transcribe_run((struct transcribe_session *)0x1, pcm, -1, &rp)
-          == TRANSCRIBE_ERR_INVALID_ARG);
-    CHECK(transcribe_run((struct transcribe_session *)0x1, pcm, 0, &rp)
-          == TRANSCRIBE_ERR_INVALID_ARG);
+    CHECK(transcribe_run((struct transcribe_session *) 0x1, pcm, -1, &rp) == TRANSCRIBE_ERR_INVALID_ARG);
+    CHECK(transcribe_run((struct transcribe_session *) 0x1, pcm, 0, &rp) == TRANSCRIBE_ERR_INVALID_ARG);
 }
 
 static void test_open_invalid(void) {
-    struct transcribe_session * s = (struct transcribe_session *)0xdeadbeef;
+    struct transcribe_session * s = (struct transcribe_session *) 0xdeadbeef;
 
     /* NULL out_session -> INVALID_ARG. */
-    CHECK(transcribe_open("ignored", NULL, NULL, NULL)
-          == TRANSCRIBE_ERR_INVALID_ARG);
+    CHECK(transcribe_open("ignored", NULL, NULL, NULL) == TRANSCRIBE_ERR_INVALID_ARG);
 
     /* NULL path forwards to load_file -> INVALID_ARG; out_session cleared. */
-    CHECK(transcribe_open(NULL, NULL, NULL, &s)
-          == TRANSCRIBE_ERR_INVALID_ARG);
+    CHECK(transcribe_open(NULL, NULL, NULL, &s) == TRANSCRIBE_ERR_INVALID_ARG);
     CHECK(s == NULL);
 
     /* NULL load/session params == defaults; missing file -> FILE_NOT_FOUND
      * with no partial session leaked. */
-    s = (struct transcribe_session *)0xdeadbeef;
-    CHECK(transcribe_open("/__transcribe_smoke_does_not_exist__.gguf",
-                          NULL, NULL, &s)
-          == TRANSCRIBE_ERR_FILE_NOT_FOUND);
+    s = (struct transcribe_session *) 0xdeadbeef;
+    CHECK(transcribe_open("/__transcribe_smoke_does_not_exist__.gguf", NULL, NULL, &s) ==
+          TRANSCRIBE_ERR_FILE_NOT_FOUND);
     CHECK(s == NULL);
 
     /* close / get_model are NULL-safe. */
@@ -521,37 +504,32 @@ static void test_open_invalid(void) {
 
 static void test_model_introspection_null(void) {
     /* Per the contract, accessors are safe to call on NULL. */
-    struct transcribe_capabilities caps; transcribe_capabilities_init(&caps);
+    struct transcribe_capabilities caps;
+    transcribe_capabilities_init(&caps);
     /* Copy-out signature: NULL model -> INVALID_ARG; out buffer
      * untouched semantically (still zero-initialized by INIT). */
-    CHECK(transcribe_model_get_capabilities(NULL, &caps)
-          == TRANSCRIBE_ERR_INVALID_ARG);
+    CHECK(transcribe_model_get_capabilities(NULL, &caps) == TRANSCRIBE_ERR_INVALID_ARG);
     /* NULL out_caps -> INVALID_ARG. */
-    CHECK(transcribe_model_get_capabilities(
-              (const struct transcribe_model *)0x1, NULL)
-          == TRANSCRIBE_ERR_INVALID_ARG);
+    CHECK(transcribe_model_get_capabilities((const struct transcribe_model *) 0x1, NULL) == TRANSCRIBE_ERR_INVALID_ARG);
 
     CHECK_STR_EMPTY(transcribe_model_arch_string(NULL));
     CHECK_STR_EMPTY(transcribe_model_variant_string(NULL));
     CHECK_STR_EMPTY(transcribe_model_backend(NULL));
 
     /* The kind probe is safe on NULL and returns false for any slot. */
-    CHECK(transcribe_model_accepts_ext_kind(NULL,
-              TRANSCRIBE_EXT_SLOT_STREAM,
-              TRANSCRIBE_EXT_KIND_PARAKEET_STREAM) == false);
-    CHECK(transcribe_model_accepts_ext_kind(NULL,
-              TRANSCRIBE_EXT_SLOT_RUN,
-              TRANSCRIBE_EXT_KIND_WHISPER_RUN) == false);
+    CHECK(transcribe_model_accepts_ext_kind(NULL, TRANSCRIBE_EXT_SLOT_STREAM, TRANSCRIBE_EXT_KIND_PARAKEET_STREAM) ==
+          false);
+    CHECK(transcribe_model_accepts_ext_kind(NULL, TRANSCRIBE_EXT_SLOT_RUN, TRANSCRIBE_EXT_KIND_WHISPER_RUN) == false);
 
     /* The feature probe is also NULL-safe and returns false for every
      * known feature value plus any out-of-range enum. */
-    CHECK(transcribe_model_supports(NULL, TRANSCRIBE_FEATURE_INITIAL_PROMPT)       == false);
+    CHECK(transcribe_model_supports(NULL, TRANSCRIBE_FEATURE_INITIAL_PROMPT) == false);
     CHECK(transcribe_model_supports(NULL, TRANSCRIBE_FEATURE_TEMPERATURE_FALLBACK) == false);
-    CHECK(transcribe_model_supports(NULL, TRANSCRIBE_FEATURE_LONG_FORM)            == false);
-    CHECK(transcribe_model_supports(NULL, TRANSCRIBE_FEATURE_CANCELLATION)         == false);
-    CHECK(transcribe_model_supports(NULL, TRANSCRIBE_FEATURE_PNC)                  == false);
-    CHECK(transcribe_model_supports(NULL, TRANSCRIBE_FEATURE_ITN)                  == false);
-    CHECK(transcribe_model_supports(NULL, (transcribe_feature) 9999)               == false);
+    CHECK(transcribe_model_supports(NULL, TRANSCRIBE_FEATURE_LONG_FORM) == false);
+    CHECK(transcribe_model_supports(NULL, TRANSCRIBE_FEATURE_CANCELLATION) == false);
+    CHECK(transcribe_model_supports(NULL, TRANSCRIBE_FEATURE_PNC) == false);
+    CHECK(transcribe_model_supports(NULL, TRANSCRIBE_FEATURE_ITN) == false);
+    CHECK(transcribe_model_supports(NULL, (transcribe_feature) 9999) == false);
 }
 
 static void test_ext_check(void) {
@@ -559,34 +537,29 @@ static void test_ext_check(void) {
     CHECK(transcribe_ext_check(NULL, 0x12345678u, 8) == TRANSCRIBE_OK);
 
     /* Wrong kind -> INVALID_ARG. */
-    struct transcribe_parakeet_stream_ext pk; transcribe_parakeet_stream_ext_init(&pk);
-    CHECK(transcribe_ext_check(&pk.ext,
-                               TRANSCRIBE_EXT_KIND_PARAKEET_BUFFERED_STREAM,
-                               sizeof(struct transcribe_parakeet_buffered_stream_ext))
-          == TRANSCRIBE_ERR_INVALID_ARG);
+    struct transcribe_parakeet_stream_ext pk;
+    transcribe_parakeet_stream_ext_init(&pk);
+    CHECK(transcribe_ext_check(&pk.ext, TRANSCRIBE_EXT_KIND_PARAKEET_BUFFERED_STREAM,
+                               sizeof(struct transcribe_parakeet_buffered_stream_ext)) == TRANSCRIBE_ERR_INVALID_ARG);
 
     /* Right kind + size big enough -> OK. */
-    CHECK(transcribe_ext_check(&pk.ext,
-                               TRANSCRIBE_EXT_KIND_PARAKEET_STREAM,
-                               sizeof(struct transcribe_parakeet_stream_ext))
-          == TRANSCRIBE_OK);
+    CHECK(transcribe_ext_check(&pk.ext, TRANSCRIBE_EXT_KIND_PARAKEET_STREAM,
+                               sizeof(struct transcribe_parakeet_stream_ext)) == TRANSCRIBE_OK);
 
     /* Size too small even to cover the common header -> BAD_STRUCT_SIZE
      * before reading kind. */
-    struct transcribe_parakeet_stream_ext pk_tiny; transcribe_parakeet_stream_ext_init(&pk_tiny);
+    struct transcribe_parakeet_stream_ext pk_tiny;
+    transcribe_parakeet_stream_ext_init(&pk_tiny);
     pk_tiny.ext.size = sizeof(struct transcribe_ext) - 1;
-    CHECK(transcribe_ext_check(&pk_tiny.ext,
-                               TRANSCRIBE_EXT_KIND_PARAKEET_STREAM,
-                               sizeof(struct transcribe_parakeet_stream_ext))
-          == TRANSCRIBE_ERR_BAD_STRUCT_SIZE);
+    CHECK(transcribe_ext_check(&pk_tiny.ext, TRANSCRIBE_EXT_KIND_PARAKEET_STREAM,
+                               sizeof(struct transcribe_parakeet_stream_ext)) == TRANSCRIBE_ERR_BAD_STRUCT_SIZE);
 
     /* Right kind but size too small -> BAD_STRUCT_SIZE. */
-    struct transcribe_parakeet_stream_ext pk_small; transcribe_parakeet_stream_ext_init(&pk_small);
+    struct transcribe_parakeet_stream_ext pk_small;
+    transcribe_parakeet_stream_ext_init(&pk_small);
     pk_small.ext.size = sizeof(struct transcribe_ext); /* below the struct's prefix */
-    CHECK(transcribe_ext_check(&pk_small.ext,
-                               TRANSCRIBE_EXT_KIND_PARAKEET_STREAM,
-                               sizeof(struct transcribe_parakeet_stream_ext))
-          == TRANSCRIBE_ERR_BAD_STRUCT_SIZE);
+    CHECK(transcribe_ext_check(&pk_small.ext, TRANSCRIBE_EXT_KIND_PARAKEET_STREAM,
+                               sizeof(struct transcribe_parakeet_stream_ext)) == TRANSCRIBE_ERR_BAD_STRUCT_SIZE);
 }
 
 static void test_tokenize_null(void) {
@@ -594,13 +567,13 @@ static void test_tokenize_null(void) {
     /* NULL model -> INT_MIN (hard error). */
     CHECK(transcribe_tokenize(NULL, "hello", tokens, 8) == INT_MIN);
     /* NULL text -> INT_MIN. */
-    CHECK(transcribe_tokenize((const struct transcribe_model *)0x1,
-                              NULL, tokens, 8) == INT_MIN);
+    CHECK(transcribe_tokenize((const struct transcribe_model *) 0x1, NULL, tokens, 8) == INT_MIN);
 }
 
 static int g_abort_calls = 0;
+
 static bool abort_cb_false(void * u) {
-    (void)u;
+    (void) u;
     g_abort_calls++;
     return false;
 }
@@ -618,43 +591,42 @@ static void test_whisper_chunk_trace_null(void) {
      * the caller's struct_size). */
     CHECK(transcribe_get_whisper_chunk_count(NULL) == 0);
 
-    struct transcribe_whisper_chunk_trace tr; transcribe_whisper_chunk_trace_init(&tr);
+    struct transcribe_whisper_chunk_trace tr;
+    transcribe_whisper_chunk_trace_init(&tr);
     CHECK(transcribe_get_whisper_chunk_trace(NULL, 0, &tr) == TRANSCRIBE_OK);
-    CHECK(tr.struct_size         == sizeof(struct transcribe_whisper_chunk_trace));
-    CHECK(tr.t0_ms               == 0);
-    CHECK(tr.t1_ms               == 0);
-    CHECK(tr.temperature_used    == 0.0f);
-    CHECK(tr.compression_ratio   == 0.0f);
-    CHECK(tr.avg_logprob         == 0.0f);
-    CHECK(tr.no_speech_prob      == 0.0f);
+    CHECK(tr.struct_size == sizeof(struct transcribe_whisper_chunk_trace));
+    CHECK(tr.t0_ms == 0);
+    CHECK(tr.t1_ms == 0);
+    CHECK(tr.temperature_used == 0.0f);
+    CHECK(tr.compression_ratio == 0.0f);
+    CHECK(tr.avg_logprob == 0.0f);
+    CHECK(tr.no_speech_prob == 0.0f);
     CHECK(tr.no_speech_triggered == false);
-    CHECK(tr.n_fallbacks         == 0);
+    CHECK(tr.n_fallbacks == 0);
 
     /* Out-of-range index against NULL succeeds the same way. */
-    struct transcribe_whisper_chunk_trace tr2; transcribe_whisper_chunk_trace_init(&tr2);
+    struct transcribe_whisper_chunk_trace tr2;
+    transcribe_whisper_chunk_trace_init(&tr2);
     CHECK(transcribe_get_whisper_chunk_trace(NULL, 42, &tr2) == TRANSCRIBE_OK);
     CHECK(tr2.t0_ms == 0);
 
     /* NULL out_trace is rejected. */
-    CHECK(transcribe_get_whisper_chunk_trace(NULL, 0, NULL)
-          == TRANSCRIBE_ERR_INVALID_ARG);
+    CHECK(transcribe_get_whisper_chunk_trace(NULL, 0, NULL) == TRANSCRIBE_ERR_INVALID_ARG);
 
     /* Zero struct_size is rejected. */
-    struct transcribe_whisper_chunk_trace tr_bad = {0};
-    CHECK(transcribe_get_whisper_chunk_trace(NULL, 0, &tr_bad)
-          == TRANSCRIBE_ERR_BAD_STRUCT_SIZE);
+    struct transcribe_whisper_chunk_trace tr_bad = { 0 };
+    CHECK(transcribe_get_whisper_chunk_trace(NULL, 0, &tr_bad) == TRANSCRIBE_ERR_BAD_STRUCT_SIZE);
 }
 
 static void test_timings_null(void) {
     /* NULL ctx -> INVALID_ARG. NULL out -> INVALID_ARG. {0} out ->
      * BAD_STRUCT_SIZE. */
-    struct transcribe_timings tm; transcribe_timings_init(&tm);
+    struct transcribe_timings tm;
+    transcribe_timings_init(&tm);
     CHECK(transcribe_get_timings(NULL, &tm) == TRANSCRIBE_ERR_INVALID_ARG);
-    CHECK(transcribe_get_timings((const struct transcribe_session *)0x1, NULL)
-          == TRANSCRIBE_ERR_INVALID_ARG);
-    struct transcribe_timings tm0 = {0};
-    CHECK(transcribe_get_timings((const struct transcribe_session *)0x1, &tm0)
-          == TRANSCRIBE_ERR_BAD_STRUCT_SIZE);
+    CHECK(transcribe_get_timings((const struct transcribe_session *) 0x1, NULL) == TRANSCRIBE_ERR_INVALID_ARG);
+    struct transcribe_timings tm0 = { 0 };
+    CHECK(transcribe_get_timings((const struct transcribe_session *) 0x1, &tm0) == TRANSCRIBE_ERR_BAD_STRUCT_SIZE);
 }
 
 static void test_result_accessors_null(void) {
@@ -664,62 +636,64 @@ static void test_result_accessors_null(void) {
     CHECK_STR_EMPTY(transcribe_full_text(ctx));
     CHECK(transcribe_returned_timestamp_kind(ctx) == TRANSCRIBE_TIMESTAMPS_NONE);
     CHECK(transcribe_n_segments(ctx) == 0);
-    CHECK(transcribe_n_words(ctx)    == 0);
-    CHECK(transcribe_n_tokens(ctx)   == 0);
+    CHECK(transcribe_n_words(ctx) == 0);
+    CHECK(transcribe_n_tokens(ctx) == 0);
 
     /* Segment row: NULL ctx → OK, struct stays zero-init (text=NULL). */
-    struct transcribe_segment seg; transcribe_segment_init(&seg);
+    struct transcribe_segment seg;
+    transcribe_segment_init(&seg);
     CHECK(transcribe_get_segment(ctx, 0, &seg) == TRANSCRIBE_OK);
     CHECK(seg.struct_size == sizeof(struct transcribe_segment));
-    CHECK(seg.text        == NULL);
-    CHECK(seg.t0_ms       == 0);
-    CHECK(seg.t1_ms       == 0);
-    CHECK(seg.first_word  == 0);
-    CHECK(seg.n_words     == 0);
+    CHECK(seg.text == NULL);
+    CHECK(seg.t0_ms == 0);
+    CHECK(seg.t1_ms == 0);
+    CHECK(seg.first_word == 0);
+    CHECK(seg.n_words == 0);
     CHECK(seg.first_token == 0);
-    CHECK(seg.n_tokens    == 0);
+    CHECK(seg.n_tokens == 0);
 
     /* Word row. */
-    struct transcribe_word wrd; transcribe_word_init(&wrd);
+    struct transcribe_word wrd;
+    transcribe_word_init(&wrd);
     CHECK(transcribe_get_word(ctx, 0, &wrd) == TRANSCRIBE_OK);
     CHECK(wrd.struct_size == sizeof(struct transcribe_word));
-    CHECK(wrd.text        == NULL);
-    CHECK(wrd.t0_ms       == 0);
-    CHECK(wrd.t1_ms       == 0);
-    CHECK(wrd.seg_index   == 0);
+    CHECK(wrd.text == NULL);
+    CHECK(wrd.t0_ms == 0);
+    CHECK(wrd.t1_ms == 0);
+    CHECK(wrd.seg_index == 0);
     CHECK(wrd.first_token == 0);
-    CHECK(wrd.n_tokens    == 0);
+    CHECK(wrd.n_tokens == 0);
 
     /* Token row. p is 0.0f (not NaN) on the zero-init path; bindings
      * distinguish "row not present" via text==NULL, not via NaN-on-p. */
-    struct transcribe_token tok; transcribe_token_init(&tok);
+    struct transcribe_token tok;
+    transcribe_token_init(&tok);
     CHECK(transcribe_get_token(ctx, 0, &tok) == TRANSCRIBE_OK);
     CHECK(tok.struct_size == sizeof(struct transcribe_token));
-    CHECK(tok.text        == NULL);
-    CHECK(tok.id          == 0);
-    CHECK(tok.p           == 0.0f);
-    CHECK(tok.t0_ms       == 0);
-    CHECK(tok.t1_ms       == 0);
-    CHECK(tok.seg_index   == 0);
-    CHECK(tok.word_index  == 0);
+    CHECK(tok.text == NULL);
+    CHECK(tok.id == 0);
+    CHECK(tok.p == 0.0f);
+    CHECK(tok.t0_ms == 0);
+    CHECK(tok.t1_ms == 0);
+    CHECK(tok.seg_index == 0);
+    CHECK(tok.word_index == 0);
 
     /* NULL out_ptr -> INVALID_ARG. */
     CHECK(transcribe_get_segment(ctx, 0, NULL) == TRANSCRIBE_ERR_INVALID_ARG);
-    CHECK(transcribe_get_word   (ctx, 0, NULL) == TRANSCRIBE_ERR_INVALID_ARG);
-    CHECK(transcribe_get_token  (ctx, 0, NULL) == TRANSCRIBE_ERR_INVALID_ARG);
+    CHECK(transcribe_get_word(ctx, 0, NULL) == TRANSCRIBE_ERR_INVALID_ARG);
+    CHECK(transcribe_get_token(ctx, 0, NULL) == TRANSCRIBE_ERR_INVALID_ARG);
 
     /* Uninitialized struct_size (== 0) -> BAD_STRUCT_SIZE. */
-    struct transcribe_segment seg_bad = {0};
-    CHECK(transcribe_get_segment(ctx, 0, &seg_bad)
-          == TRANSCRIBE_ERR_BAD_STRUCT_SIZE);
+    struct transcribe_segment seg_bad = { 0 };
+    CHECK(transcribe_get_segment(ctx, 0, &seg_bad) == TRANSCRIBE_ERR_BAD_STRUCT_SIZE);
 }
 
 static void test_stream_state_values(void) {
     /* The state enum values are part of the public ABI — pin them. */
-    CHECK(TRANSCRIBE_STREAM_IDLE     == 0);
-    CHECK(TRANSCRIBE_STREAM_ACTIVE   == 1);
+    CHECK(TRANSCRIBE_STREAM_IDLE == 0);
+    CHECK(TRANSCRIBE_STREAM_ACTIVE == 1);
     CHECK(TRANSCRIBE_STREAM_FINISHED == 2);
-    CHECK(TRANSCRIBE_STREAM_FAILED   == 3);
+    CHECK(TRANSCRIBE_STREAM_FAILED == 3);
     CHECK(TRANSCRIBE_STREAM_COMMIT_AUTO == 0);
     CHECK(TRANSCRIBE_STREAM_COMMIT_ON_FINALIZE == 1);
     CHECK(TRANSCRIBE_STREAM_COMMIT_STABLE_PREFIX == 2);
@@ -729,14 +703,15 @@ static void test_stream_accessors_null(void) {
     const struct transcribe_session * ctx = NULL;
     /* Every streaming accessor is safe to call on NULL and returns the
      * documented sentinel. */
-    CHECK(transcribe_stream_get_state(ctx)             == TRANSCRIBE_STREAM_IDLE);
-    CHECK(transcribe_stream_revision(ctx)              == 0);
-    CHECK(transcribe_stream_n_committed_segments(ctx)  == 0);
-    CHECK(transcribe_stream_n_committed_words(ctx)     == 0);
-    CHECK(transcribe_stream_n_committed_tokens(ctx)    == 0);
-    CHECK(transcribe_stream_last_status(ctx)           == TRANSCRIBE_OK);
-
-    struct transcribe_stream_text text; transcribe_stream_text_init(&text);
+    CHECK(transcribe_stream_get_state(ctx) == TRANSCRIBE_STREAM_IDLE);
+    CHECK(transcribe_stream_revision(ctx) == 0);
+    CHECK(transcribe_stream_n_committed_segments(ctx) == 0);
+    CHECK(transcribe_stream_n_committed_words(ctx) == 0);
+    CHECK(transcribe_stream_n_committed_tokens(ctx) == 0);
+    CHECK(transcribe_stream_last_status(ctx) == TRANSCRIBE_OK);
+
+    struct transcribe_stream_text text;
+    transcribe_stream_text_init(&text);
     CHECK(transcribe_stream_get_text(ctx, &text) == TRANSCRIBE_OK);
     CHECK(text.full_text != NULL);
     CHECK(text.full_text[0] == '\0');
@@ -752,34 +727,28 @@ static void test_stream_accessors_null(void) {
 static void test_stream_entries_null(void) {
     /* NULL ctx into every entry point: begin/feed/finalize report
      * INVALID_ARG; reset is a no-op. */
-    struct transcribe_run_params rp; transcribe_run_params_init(&rp);
-    struct transcribe_stream_params sp; transcribe_stream_params_init(&sp);
-    float                           pcm[1] = { 0.0f };
-
-    CHECK(transcribe_stream_begin(NULL, &rp, &sp)
-          == TRANSCRIBE_ERR_INVALID_ARG);
-    CHECK(transcribe_stream_feed(NULL, pcm, 1, NULL)
-          == TRANSCRIBE_ERR_INVALID_ARG);
-    CHECK(transcribe_stream_finalize(NULL, NULL)
-          == TRANSCRIBE_ERR_INVALID_ARG);
+    struct transcribe_run_params rp;
+    transcribe_run_params_init(&rp);
+    struct transcribe_stream_params sp;
+    transcribe_stream_params_init(&sp);
+    float pcm[1] = { 0.0f };
+
+    CHECK(transcribe_stream_begin(NULL, &rp, &sp) == TRANSCRIBE_ERR_INVALID_ARG);
+    CHECK(transcribe_stream_feed(NULL, pcm, 1, NULL) == TRANSCRIBE_ERR_INVALID_ARG);
+    CHECK(transcribe_stream_finalize(NULL, NULL) == TRANSCRIBE_ERR_INVALID_ARG);
     /* reset is void; calling it on NULL must not crash. */
     transcribe_stream_reset(NULL);
 
     /* {0} update -> BAD_STRUCT_SIZE on feed/finalize. The struct_size
      * check fires before ctx is dereferenced, so passing a non-NULL
      * fake ctx pointer is fine here. */
-    struct transcribe_stream_update upd0 = {0};
-    CHECK(transcribe_stream_feed((struct transcribe_session *)0x1,
-                                 pcm, 1, &upd0)
-          == TRANSCRIBE_ERR_BAD_STRUCT_SIZE);
-    CHECK(transcribe_stream_finalize((struct transcribe_session *)0x1, &upd0)
-          == TRANSCRIBE_ERR_BAD_STRUCT_SIZE);
-
-    struct transcribe_stream_text text0 = {0};
-    CHECK(transcribe_stream_get_text(NULL, &text0)
-          == TRANSCRIBE_ERR_BAD_STRUCT_SIZE);
-    CHECK(transcribe_stream_get_text(NULL, NULL)
-          == TRANSCRIBE_ERR_INVALID_ARG);
+    struct transcribe_stream_update upd0 = { 0 };
+    CHECK(transcribe_stream_feed((struct transcribe_session *) 0x1, pcm, 1, &upd0) == TRANSCRIBE_ERR_BAD_STRUCT_SIZE);
+    CHECK(transcribe_stream_finalize((struct transcribe_session *) 0x1, &upd0) == TRANSCRIBE_ERR_BAD_STRUCT_SIZE);
+
+    struct transcribe_stream_text text0 = { 0 };
+    CHECK(transcribe_stream_get_text(NULL, &text0) == TRANSCRIBE_ERR_BAD_STRUCT_SIZE);
+    CHECK(transcribe_stream_get_text(NULL, NULL) == TRANSCRIBE_ERR_INVALID_ARG);
 }
 
 /* Input-limits ABI surface (no model needed): the session-limits struct, the
@@ -789,21 +758,19 @@ static void test_stream_entries_null(void) {
 static void test_session_limits_abi(void) {
     struct transcribe_session_limits lim;
     transcribe_session_limits_init(&lim);
-    CHECK(lim.struct_size            == sizeof(struct transcribe_session_limits));
-    CHECK(lim.effective_n_ctx        == 0);
+    CHECK(lim.struct_size == sizeof(struct transcribe_session_limits));
+    CHECK(lim.effective_n_ctx == 0);
     CHECK(lim.effective_max_audio_ms == 0);
-    CHECK(lim.max_kv_bytes           == 0);
+    CHECK(lim.max_kv_bytes == 0);
 
     /* NULL args -> INVALID_ARG (checked before struct_size / model deref). */
     CHECK(transcribe_session_get_limits(NULL, &lim) == TRANSCRIBE_ERR_INVALID_ARG);
-    CHECK(transcribe_session_get_limits((struct transcribe_session *)0x1, NULL)
-          == TRANSCRIBE_ERR_INVALID_ARG);
+    CHECK(transcribe_session_get_limits((struct transcribe_session *) 0x1, NULL) == TRANSCRIBE_ERR_INVALID_ARG);
 
     /* Non-NULL session + struct_size 0 -> BAD_STRUCT_SIZE, returned before the
      * session is dereferenced (mirrors the stream-param fake-handle tests). */
-    struct transcribe_session_limits lim0 = {0};
-    CHECK(transcribe_session_get_limits((struct transcribe_session *)0x1, &lim0)
-          == TRANSCRIBE_ERR_BAD_STRUCT_SIZE);
+    struct transcribe_session_limits lim0 = { 0 };
+    CHECK(transcribe_session_get_limits((struct transcribe_session *) 0x1, &lim0) == TRANSCRIBE_ERR_BAD_STRUCT_SIZE);
 
     /* Supplemental truncation flag on a NULL session is false, not a crash. */
     CHECK(transcribe_was_truncated(NULL) == false);
diff --git a/tests/backend_classification_unit.cpp b/tests/backend_classification_unit.cpp
index 8082fa3d..9618b93e 100644
--- a/tests/backend_classification_unit.cpp
+++ b/tests/backend_classification_unit.cpp
@@ -13,46 +13,34 @@ namespace {
 
 int g_failures = 0;
 
-#define CHECK_EQ(actual, expected)                                          \
-    do {                                                                    \
-        const auto _a = (actual);                                           \
-        const auto _e = (expected);                                         \
-        if (_a != _e) {                                                     \
-            std::fprintf(stderr, "FAIL %s:%d: got %s, expected %s\n",       \
-                         __FILE__, __LINE__,                               \
-                         transcribe::kind_name(_a),                        \
-                         transcribe::kind_name(_e));                       \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK_EQ(actual, expected)                                                                                   \
+    do {                                                                                                             \
+        const auto _a = (actual);                                                                                    \
+        const auto _e = (expected);                                                                                  \
+        if (_a != _e) {                                                                                              \
+            std::fprintf(stderr, "FAIL %s:%d: got %s, expected %s\n", __FILE__, __LINE__, transcribe::kind_name(_a), \
+                         transcribe::kind_name(_e));                                                                 \
+            ++g_failures;                                                                                            \
+        }                                                                                                            \
     } while (0)
 
-} // namespace
+}  // namespace
 
 int main() {
     using transcribe::BackendKind;
     using transcribe::classify_backend_type;
 
-    CHECK_EQ(classify_backend_type(GGML_BACKEND_DEVICE_TYPE_CPU, "CPU"),
-             BackendKind::Cpu);
-    CHECK_EQ(classify_backend_type(GGML_BACKEND_DEVICE_TYPE_ACCEL, "BLAS"),
-             BackendKind::Accel);
-
-    CHECK_EQ(classify_backend_type(GGML_BACKEND_DEVICE_TYPE_GPU, "MTL"),
-             BackendKind::Metal);
-    CHECK_EQ(classify_backend_type(GGML_BACKEND_DEVICE_TYPE_GPU, "MTL0"),
-             BackendKind::Metal);
-    CHECK_EQ(classify_backend_type(GGML_BACKEND_DEVICE_TYPE_GPU, "Metal"),
-             BackendKind::Metal);
-    CHECK_EQ(classify_backend_type(GGML_BACKEND_DEVICE_TYPE_IGPU, "Vulkan"),
-             BackendKind::Vulkan);
-    CHECK_EQ(classify_backend_type(GGML_BACKEND_DEVICE_TYPE_GPU, "CUDA"),
-             BackendKind::Cuda);
-    CHECK_EQ(classify_backend_type(GGML_BACKEND_DEVICE_TYPE_GPU, "SYCL"),
-             BackendKind::Sycl);
-    CHECK_EQ(classify_backend_type(GGML_BACKEND_DEVICE_TYPE_GPU, "WebGPU"),
-             BackendKind::OtherGpu);
-    CHECK_EQ(classify_backend_type(GGML_BACKEND_DEVICE_TYPE_GPU, nullptr),
-             BackendKind::OtherGpu);
+    CHECK_EQ(classify_backend_type(GGML_BACKEND_DEVICE_TYPE_CPU, "CPU"), BackendKind::Cpu);
+    CHECK_EQ(classify_backend_type(GGML_BACKEND_DEVICE_TYPE_ACCEL, "BLAS"), BackendKind::Accel);
+
+    CHECK_EQ(classify_backend_type(GGML_BACKEND_DEVICE_TYPE_GPU, "MTL"), BackendKind::Metal);
+    CHECK_EQ(classify_backend_type(GGML_BACKEND_DEVICE_TYPE_GPU, "MTL0"), BackendKind::Metal);
+    CHECK_EQ(classify_backend_type(GGML_BACKEND_DEVICE_TYPE_GPU, "Metal"), BackendKind::Metal);
+    CHECK_EQ(classify_backend_type(GGML_BACKEND_DEVICE_TYPE_IGPU, "Vulkan"), BackendKind::Vulkan);
+    CHECK_EQ(classify_backend_type(GGML_BACKEND_DEVICE_TYPE_GPU, "CUDA"), BackendKind::Cuda);
+    CHECK_EQ(classify_backend_type(GGML_BACKEND_DEVICE_TYPE_GPU, "SYCL"), BackendKind::Sycl);
+    CHECK_EQ(classify_backend_type(GGML_BACKEND_DEVICE_TYPE_GPU, "WebGPU"), BackendKind::OtherGpu);
+    CHECK_EQ(classify_backend_type(GGML_BACKEND_DEVICE_TYPE_GPU, nullptr), BackendKind::OtherGpu);
 
     return g_failures == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
 }
diff --git a/tests/backend_init_unit.cpp b/tests/backend_init_unit.cpp
index 8f60c426..8e45e803 100644
--- a/tests/backend_init_unit.cpp
+++ b/tests/backend_init_unit.cpp
@@ -14,11 +14,10 @@
 //     nonzero GPU index exists, binds that exact registry device.
 //   - Invalid enum: returns TRANSCRIBE_ERR_INVALID_ARG.
 
-#include "transcribe-load-common.h"
-#include "transcribe-backend.h"
-
-#include "ggml.h"
 #include "ggml-backend.h"
+#include "ggml.h"
+#include "transcribe-backend.h"
+#include "transcribe-load-common.h"
 
 #include <cstddef>
 #include <cstdio>
@@ -28,58 +27,52 @@ namespace {
 
 int g_failures = 0;
 
-#define CHECK(cond)                                                         \
-    do {                                                                    \
-        if (!(cond)) {                                                      \
-            std::fprintf(stderr, "FAIL %s:%d: %s\n",                        \
-                         __FILE__, __LINE__, #cond);                        \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK(cond)                                                              \
+    do {                                                                         \
+        if (!(cond)) {                                                           \
+            std::fprintf(stderr, "FAIL %s:%d: %s\n", __FILE__, __LINE__, #cond); \
+            ++g_failures;                                                        \
+        }                                                                        \
     } while (0)
 
-#define CHECK_EQ(actual, expected)                                          \
-    do {                                                                    \
-        const auto _a = (actual);                                           \
-        const auto _e = (expected);                                         \
-        if (_a != _e) {                                                     \
-            std::fprintf(stderr, "FAIL %s:%d: got %d, expected %d\n",       \
-                         __FILE__, __LINE__,                                \
-                         static_cast<int>(_a),                              \
-                         static_cast<int>(_e));                             \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK_EQ(actual, expected)                                                                              \
+    do {                                                                                                        \
+        const auto _a = (actual);                                                                               \
+        const auto _e = (expected);                                                                             \
+        if (_a != _e) {                                                                                         \
+            std::fprintf(stderr, "FAIL %s:%d: got %d, expected %d\n", __FILE__, __LINE__, static_cast<int>(_a), \
+                         static_cast<int>(_e));                                                                 \
+            ++g_failures;                                                                                       \
+        }                                                                                                       \
     } while (0)
 
 // Bail macro for setup prerequisites: if the condition fails, log and
 // return EXIT_FAILURE immediately rather than crashing on a null deref.
-#define REQUIRE(cond)                                                       \
-    do {                                                                    \
-        if (!(cond)) {                                                      \
-            std::fprintf(stderr, "SETUP FAIL %s:%d: %s\n",                  \
-                         __FILE__, __LINE__, #cond);                        \
-            return EXIT_FAILURE;                                            \
-        }                                                                   \
+#define REQUIRE(cond)                                                                  \
+    do {                                                                               \
+        if (!(cond)) {                                                                 \
+            std::fprintf(stderr, "SETUP FAIL %s:%d: %s\n", __FILE__, __LINE__, #cond); \
+            return EXIT_FAILURE;                                                       \
+        }                                                                              \
     } while (0)
 
 // Free every backend in the scheduler list. Mirrors what the model
 // destructor does: reverse order, then clear.
 void free_plan(transcribe::BackendPlan & plan) {
-    for (auto it = plan.scheduler_list.rbegin();
-         it != plan.scheduler_list.rend(); ++it) {
+    for (auto it = plan.scheduler_list.rbegin(); it != plan.scheduler_list.rend(); ++it) {
         ggml_backend_free(*it);
     }
     plan.scheduler_list.clear();
-    plan.primary = nullptr;
+    plan.primary      = nullptr;
     plan.primary_kind = transcribe::BackendKind::Unknown;
 }
 
 bool is_gpu_device(ggml_backend_dev_t dev) {
     const auto type = ggml_backend_dev_type(dev);
-    return type == GGML_BACKEND_DEVICE_TYPE_GPU ||
-           type == GGML_BACKEND_DEVICE_TYPE_IGPU;
+    return type == GGML_BACKEND_DEVICE_TYPE_GPU || type == GGML_BACKEND_DEVICE_TYPE_IGPU;
 }
 
-} // namespace
+}  // namespace
 
 int main() {
     using namespace transcribe;
@@ -89,9 +82,8 @@ int main() {
     // 1. Strict CPU
     // ---------------------------------------------------------------
     {
-        BackendPlan plan;
-        transcribe_status st = init_backends(
-            TRANSCRIBE_BACKEND_CPU, 0, "test-cpu", plan);
+        BackendPlan       plan;
+        transcribe_status st = init_backends(TRANSCRIBE_BACKEND_CPU, 0, "test-cpu", plan);
         REQUIRE(st == TRANSCRIBE_OK);
         CHECK_EQ(plan.primary_kind, BackendKind::Cpu);
         REQUIRE(plan.primary != nullptr);
@@ -99,8 +91,7 @@ int main() {
 
         // The sole scheduler handle must classify as CPU via the
         // device-level classifier, not string matching.
-        ggml_backend_dev_t dev =
-            ggml_backend_get_device(plan.scheduler_list[0]);
+        ggml_backend_dev_t dev = ggml_backend_get_device(plan.scheduler_list[0]);
         REQUIRE(dev != nullptr);
         CHECK_EQ(classify_device(dev), BackendKind::Cpu);
 
@@ -112,9 +103,8 @@ int main() {
     // include extra accel handles depending on what ggml registered.
     // ---------------------------------------------------------------
     {
-        BackendPlan plan;
-        transcribe_status st = init_backends(
-            TRANSCRIBE_BACKEND_CPU_ACCEL, 0, "test-cpu-accel", plan);
+        BackendPlan       plan;
+        transcribe_status st = init_backends(TRANSCRIBE_BACKEND_CPU_ACCEL, 0, "test-cpu-accel", plan);
         REQUIRE(st == TRANSCRIBE_OK);
         CHECK_EQ(plan.primary_kind, BackendKind::Cpu);
         REQUIRE(plan.primary != nullptr);
@@ -122,8 +112,7 @@ int main() {
 
         // CPU must sit last in the scheduler list (ggml requirement);
         // any additional handles ahead of it are accel devices.
-        ggml_backend_dev_t last_dev =
-            ggml_backend_get_device(plan.scheduler_list.back());
+        ggml_backend_dev_t last_dev = ggml_backend_get_device(plan.scheduler_list.back());
         REQUIRE(last_dev != nullptr);
         CHECK_EQ(classify_device(last_dev), BackendKind::Cpu);
 
@@ -139,9 +128,8 @@ int main() {
     // restrictions). We cannot pre-judge from the registry; instead
     // call init_backends() and assert based on what it returns.
     {
-        BackendPlan plan;
-        transcribe_status st = init_backends(
-            TRANSCRIBE_BACKEND_METAL, 0, "test-metal", plan);
+        BackendPlan       plan;
+        transcribe_status st = init_backends(TRANSCRIBE_BACKEND_METAL, 0, "test-metal", plan);
 
         if (st == TRANSCRIBE_OK) {
             CHECK_EQ(plan.primary_kind, BackendKind::Metal);
@@ -157,9 +145,8 @@ int main() {
     // 3. Explicit Vulkan — same pattern as Metal
     // ---------------------------------------------------------------
     {
-        BackendPlan plan;
-        transcribe_status st = init_backends(
-            TRANSCRIBE_BACKEND_VULKAN, 0, "test-vulkan", plan);
+        BackendPlan       plan;
+        transcribe_status st = init_backends(TRANSCRIBE_BACKEND_VULKAN, 0, "test-vulkan", plan);
 
         if (st == TRANSCRIBE_OK) {
             CHECK_EQ(plan.primary_kind, BackendKind::Vulkan);
@@ -175,9 +162,8 @@ int main() {
     // 4. Explicit CUDA — same pattern as Metal / Vulkan
     // ---------------------------------------------------------------
     {
-        BackendPlan plan;
-        transcribe_status st = init_backends(
-            TRANSCRIBE_BACKEND_CUDA, 0, "test-cuda", plan);
+        BackendPlan       plan;
+        transcribe_status st = init_backends(TRANSCRIBE_BACKEND_CUDA, 0, "test-cuda", plan);
 
         if (st == TRANSCRIBE_OK) {
             CHECK_EQ(plan.primary_kind, BackendKind::Cuda);
@@ -198,9 +184,8 @@ int main() {
     // fail initialization, so we assert based on the returned
     // primary_kind rather than pre-judging from the registry.
     {
-        BackendPlan plan;
-        transcribe_status st = init_backends(
-            TRANSCRIBE_BACKEND_AUTO, 0, "test-auto", plan);
+        BackendPlan       plan;
+        transcribe_status st = init_backends(TRANSCRIBE_BACKEND_AUTO, 0, "test-auto", plan);
         REQUIRE(st == TRANSCRIBE_OK);
         CHECK(plan.primary != nullptr);
         CHECK(plan.primary_kind != BackendKind::Unknown);
@@ -221,10 +206,8 @@ int main() {
     // 6. Invalid enum — returns TRANSCRIBE_ERR_INVALID_ARG
     // ---------------------------------------------------------------
     {
-        BackendPlan plan;
-        transcribe_status st = init_backends(
-            static_cast<transcribe_backend_request>(999),
-            0, "test-invalid", plan);
+        BackendPlan       plan;
+        transcribe_status st = init_backends(static_cast<transcribe_backend_request>(999), 0, "test-invalid", plan);
         CHECK_EQ(st, TRANSCRIBE_ERR_INVALID_ARG);
     }
 
@@ -232,24 +215,19 @@ int main() {
     // 7. Explicit gpu_device validation
     // ---------------------------------------------------------------
     {
-        BackendPlan plan;
-        transcribe_status st = init_backends(
-            TRANSCRIBE_BACKEND_AUTO, -1, "test-gpu-negative", plan);
+        BackendPlan       plan;
+        transcribe_status st = init_backends(TRANSCRIBE_BACKEND_AUTO, -1, "test-gpu-negative", plan);
         CHECK_EQ(st, TRANSCRIBE_ERR_INVALID_ARG);
     }
     {
-        BackendPlan plan;
-        transcribe_status st = init_backends(
-            TRANSCRIBE_BACKEND_CPU, 1, "test-gpu-cpu-request", plan);
+        BackendPlan       plan;
+        transcribe_status st = init_backends(TRANSCRIBE_BACKEND_CPU, 1, "test-gpu-cpu-request", plan);
         CHECK_EQ(st, TRANSCRIBE_ERR_INVALID_ARG);
     }
     {
-        BackendPlan plan;
-        const int out_of_range =
-            static_cast<int>(ggml_backend_dev_count()) + 1;
-        transcribe_status st = init_backends(
-            TRANSCRIBE_BACKEND_AUTO, out_of_range,
-            "test-gpu-out-of-range", plan);
+        BackendPlan       plan;
+        const int         out_of_range = static_cast<int>(ggml_backend_dev_count()) + 1;
+        transcribe_status st = init_backends(TRANSCRIBE_BACKEND_AUTO, out_of_range, "test-gpu-out-of-range", plan);
         CHECK_EQ(st, TRANSCRIBE_ERR_INVALID_ARG);
     }
 
@@ -257,10 +235,9 @@ int main() {
     for (size_t i = 1; i < n_dev; ++i) {
         ggml_backend_dev_t dev = ggml_backend_dev_get(i);
         if (dev != nullptr && !is_gpu_device(dev)) {
-            BackendPlan plan;
-            transcribe_status st = init_backends(
-                TRANSCRIBE_BACKEND_AUTO, static_cast<int>(i),
-                "test-gpu-non-gpu", plan);
+            BackendPlan       plan;
+            transcribe_status st =
+                init_backends(TRANSCRIBE_BACKEND_AUTO, static_cast<int>(i), "test-gpu-non-gpu", plan);
             CHECK_EQ(st, TRANSCRIBE_ERR_INVALID_ARG);
             break;
         }
@@ -269,10 +246,9 @@ int main() {
     for (size_t i = 1; i < n_dev; ++i) {
         ggml_backend_dev_t dev = ggml_backend_dev_get(i);
         if (dev != nullptr && is_gpu_device(dev)) {
-            BackendPlan plan;
-            transcribe_status st = init_backends(
-                TRANSCRIBE_BACKEND_AUTO, static_cast<int>(i),
-                "test-gpu-explicit", plan);
+            BackendPlan       plan;
+            transcribe_status st =
+                init_backends(TRANSCRIBE_BACKEND_AUTO, static_cast<int>(i), "test-gpu-explicit", plan);
             if (st == TRANSCRIBE_OK) {
                 CHECK(plan.primary != nullptr);
                 CHECK(ggml_backend_get_device(plan.primary) == dev);
diff --git a/tests/cohere_e2e_smoke.cpp b/tests/cohere_e2e_smoke.cpp
index 13cf54d3..66fa5ce7 100644
--- a/tests/cohere_e2e_smoke.cpp
+++ b/tests/cohere_e2e_smoke.cpp
@@ -34,7 +34,6 @@
 // correctness without needing a real model file.
 
 #include "transcribe.h"
-
 #include "wav.h"
 
 #include <sys/stat.h>
@@ -47,49 +46,43 @@
 #include <vector>
 
 #ifndef TRANSCRIBE_TEST_SAMPLES_DIR
-#  define TRANSCRIBE_TEST_SAMPLES_DIR "samples"
+#    define TRANSCRIBE_TEST_SAMPLES_DIR "samples"
 #endif
 
 namespace {
 
 int g_failures = 0;
 
-#define CHECK(cond)                                                         \
-    do {                                                                    \
-        if (!(cond)) {                                                      \
-            std::fprintf(stderr, "FAIL %s:%d: %s\n",                        \
-                         __FILE__, __LINE__, #cond);                        \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK(cond)                                                              \
+    do {                                                                         \
+        if (!(cond)) {                                                           \
+            std::fprintf(stderr, "FAIL %s:%d: %s\n", __FILE__, __LINE__, #cond); \
+            ++g_failures;                                                        \
+        }                                                                        \
     } while (0)
 
-#define CHECK_EQ_INT(actual, expected)                                      \
-    do {                                                                    \
-        const long long _a = static_cast<long long>(actual);                \
-        const long long _e = static_cast<long long>(expected);              \
-        if (_a != _e) {                                                     \
-            std::fprintf(stderr,                                            \
-                         "FAIL %s:%d: %s = %lld, expected %lld\n",          \
-                         __FILE__, __LINE__, #actual, _a, _e);              \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK_EQ_INT(actual, expected)                                                                           \
+    do {                                                                                                         \
+        const long long _a = static_cast<long long>(actual);                                                     \
+        const long long _e = static_cast<long long>(expected);                                                   \
+        if (_a != _e) {                                                                                          \
+            std::fprintf(stderr, "FAIL %s:%d: %s = %lld, expected %lld\n", __FILE__, __LINE__, #actual, _a, _e); \
+            ++g_failures;                                                                                        \
+        }                                                                                                        \
     } while (0)
 
-#define CHECK_STR_EQ(a, b)                                                  \
-    do {                                                                    \
-        const std::string _av = (a);                                        \
-        const std::string _bv = (b);                                        \
-        if (_av != _bv) {                                                   \
-            std::fprintf(stderr,                                            \
-                         "FAIL %s:%d: \"%s\" != \"%s\"\n",                  \
-                         __FILE__, __LINE__,                                \
-                         _av.c_str(), _bv.c_str());                         \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK_STR_EQ(a, b)                                                                                        \
+    do {                                                                                                          \
+        const std::string _av = (a);                                                                              \
+        const std::string _bv = (b);                                                                              \
+        if (_av != _bv) {                                                                                         \
+            std::fprintf(stderr, "FAIL %s:%d: \"%s\" != \"%s\"\n", __FILE__, __LINE__, _av.c_str(), _bv.c_str()); \
+            ++g_failures;                                                                                         \
+        }                                                                                                         \
     } while (0)
 
 bool file_exists(const std::string & path) {
-    struct stat st {};
+    struct stat st{};
     return ::stat(path.c_str(), &st) == 0;
 }
 
@@ -102,21 +95,24 @@ bool file_exists(const std::string & path) {
 // a shared header: the porting policy is no-refactor-during-port, and
 // a one-function helper in two tests is cheaper than a new header.
 int edit_distance(const std::string & a, const std::string & b) {
-    const int n = static_cast<int>(a.size());
-    const int m = static_cast<int>(b.size());
+    const int        n = static_cast<int>(a.size());
+    const int        m = static_cast<int>(b.size());
     std::vector<int> prev(static_cast<size_t>(m + 1));
     std::vector<int> curr(static_cast<size_t>(m + 1));
-    for (int j = 0; j <= m; ++j) prev[static_cast<size_t>(j)] = j;
+    for (int j = 0; j <= m; ++j) {
+        prev[static_cast<size_t>(j)] = j;
+    }
     for (int i = 1; i <= n; ++i) {
         curr[0] = i;
         for (int j = 1; j <= m; ++j) {
-            const int cost = (a[static_cast<size_t>(i - 1)] ==
-                              b[static_cast<size_t>(j - 1)]) ? 0 : 1;
-            const int del = prev[static_cast<size_t>(j)]     + 1;
-            const int ins = curr[static_cast<size_t>(j - 1)] + 1;
-            const int sub = prev[static_cast<size_t>(j - 1)] + cost;
-            int best = del < ins ? del : ins;
-            if (sub < best) best = sub;
+            const int cost = (a[static_cast<size_t>(i - 1)] == b[static_cast<size_t>(j - 1)]) ? 0 : 1;
+            const int del  = prev[static_cast<size_t>(j)] + 1;
+            const int ins  = curr[static_cast<size_t>(j - 1)] + 1;
+            const int sub  = prev[static_cast<size_t>(j - 1)] + cost;
+            int       best = del < ins ? del : ins;
+            if (sub < best) {
+                best = sub;
+            }
             curr[static_cast<size_t>(j)] = best;
         }
         prev.swap(curr);
@@ -134,7 +130,7 @@ const char * const k_jfk_reference_text =
 
 constexpr int k_max_edit_distance = 3;
 
-} // namespace
+}  // namespace
 
 int main() {
     // ---- Resolve model path ------------------------------------------
@@ -145,7 +141,7 @@ int main() {
             std::fprintf(stderr,
                          "cohere_e2e_smoke: TRANSCRIBE_COHERE_GGUF not set. "
                          "Skipping.\n");
-            return 77; // CTest "skipped"
+            return 77;  // CTest "skipped"
         }
         model_path = env;
     }
@@ -156,7 +152,7 @@ int main() {
                      "Set TRANSCRIBE_COHERE_GGUF to a valid GGUF path. "
                      "Skipping.\n",
                      model_path.c_str());
-        return 77; // CTest "skipped"
+        return 77;  // CTest "skipped"
     }
 
     // ---- Resolve audio path ------------------------------------------
@@ -171,8 +167,7 @@ int main() {
     }
 
     if (!file_exists(wav_path)) {
-        std::fprintf(stderr,
-                     "cohere_e2e_smoke: wav not found: %s\n", wav_path.c_str());
+        std::fprintf(stderr, "cohere_e2e_smoke: wav not found: %s\n", wav_path.c_str());
         return EXIT_FAILURE;
     }
 
@@ -182,15 +177,15 @@ int main() {
     // ---- Load model --------------------------------------------------
     const auto t_start = std::chrono::steady_clock::now();
 
-    transcribe_model_load_params mp; transcribe_model_load_params_init(&mp);
+    transcribe_model_load_params mp;
+    transcribe_model_load_params_init(&mp);
     mp.backend = TRANSCRIBE_BACKEND_CPU;  // strict CPU for cross-platform determinism
+
     struct transcribe_model * model = nullptr;
     {
-        const transcribe_status st =
-            transcribe_model_load_file(model_path.c_str(), &mp, &model);
+        const transcribe_status st = transcribe_model_load_file(model_path.c_str(), &mp, &model);
         if (st != TRANSCRIBE_OK || model == nullptr) {
-            std::fprintf(stderr, "FAIL load: %s\n",
-                         transcribe_status_string(st));
+            std::fprintf(stderr, "FAIL load: %s\n", transcribe_status_string(st));
             return EXIT_FAILURE;
         }
     }
@@ -200,8 +195,7 @@ int main() {
     {
         const char * backend = transcribe_model_backend(model);
         if (backend == nullptr || backend[0] == '\0') {
-            std::fprintf(stderr,
-                         "FAIL: backend = \"\" after load, expected non-empty\n");
+            std::fprintf(stderr, "FAIL: backend = \"\" after load, expected non-empty\n");
             ++g_failures;
         } else {
             std::fprintf(stderr, "cohere_e2e_smoke: backend=%s\n", backend);
@@ -210,46 +204,43 @@ int main() {
 
     // ---- Load wav ----------------------------------------------------
     std::vector<float> pcm;
-    std::string load_err;
+    std::string        load_err;
     if (!transcribe_cli::load_wav_mono_16k(wav_path, pcm, load_err)) {
-        std::fprintf(stderr, "cohere_e2e_smoke: wav load: %s\n",
-                     load_err.c_str());
+        std::fprintf(stderr, "cohere_e2e_smoke: wav load: %s\n", load_err.c_str());
         transcribe_model_free(model);
         return EXIT_FAILURE;
     }
-    std::fprintf(stderr, "cohere_e2e_smoke: loaded %zu samples (%.2f s)\n",
-                 pcm.size(), static_cast<double>(pcm.size()) / 16000.0);
+    std::fprintf(stderr, "cohere_e2e_smoke: loaded %zu samples (%.2f s)\n", pcm.size(),
+                 static_cast<double>(pcm.size()) / 16000.0);
 
     // ---- Init context + run ------------------------------------------
-    transcribe_session_params cp; transcribe_session_params_init(&cp);
+    transcribe_session_params cp;
+    transcribe_session_params_init(&cp);
+
     struct transcribe_session * ctx = nullptr;
     {
-        const transcribe_status st =
-            transcribe_session_init(model, &cp, &ctx);
+        const transcribe_status st = transcribe_session_init(model, &cp, &ctx);
         if (st != TRANSCRIBE_OK || ctx == nullptr) {
-            std::fprintf(stderr, "cohere_e2e_smoke: ctx init: %s\n",
-                         transcribe_status_string(st));
+            std::fprintf(stderr, "cohere_e2e_smoke: ctx init: %s\n", transcribe_status_string(st));
             transcribe_model_free(model);
             return EXIT_FAILURE;
         }
     }
 
-    transcribe_run_params rp; transcribe_run_params_init(&rp);
+    transcribe_run_params rp;
+    transcribe_run_params_init(&rp);
     {
-        const transcribe_status st =
-            transcribe_run(ctx, pcm.data(), static_cast<int>(pcm.size()), &rp);
+        const transcribe_status st = transcribe_run(ctx, pcm.data(), static_cast<int>(pcm.size()), &rp);
         if (st != TRANSCRIBE_OK) {
-            std::fprintf(stderr, "FAIL run: %s\n",
-                         transcribe_status_string(st));
+            std::fprintf(stderr, "FAIL run: %s\n", transcribe_status_string(st));
             transcribe_session_free(ctx);
             transcribe_model_free(model);
             return EXIT_FAILURE;
         }
     }
 
-    const auto t_end = std::chrono::steady_clock::now();
-    const double wall_ms = std::chrono::duration<double, std::milli>(
-        t_end - t_start).count();
+    const auto   t_end   = std::chrono::steady_clock::now();
+    const double wall_ms = std::chrono::duration<double, std::milli>(t_end - t_start).count();
 
     // ---- Verify output text ------------------------------------------
     const char * full = transcribe_full_text(ctx);
@@ -267,20 +258,17 @@ int main() {
     // rewrite) but not so tight that a one-character detokenizer
     // tweak trips the gate.
     const int dist = edit_distance(actual, k_jfk_reference_text);
-    std::fprintf(stderr,
-                 "cohere_e2e_smoke: edit_distance=%d (tolerance=%d)\n",
-                 dist, k_max_edit_distance);
+    std::fprintf(stderr, "cohere_e2e_smoke: edit_distance=%d (tolerance=%d)\n", dist, k_max_edit_distance);
     if (dist > k_max_edit_distance) {
-        std::fprintf(stderr,
-                     "FAIL: text edit distance %d exceeds %d\n",
-                     dist, k_max_edit_distance);
+        std::fprintf(stderr, "FAIL: text edit distance %d exceeds %d\n", dist, k_max_edit_distance);
         std::fprintf(stderr, "  reference: %s\n", k_jfk_reference_text);
         std::fprintf(stderr, "  actual:    %s\n", actual.c_str());
         ++g_failures;
     }
 
     // ---- Verify timing -----------------------------------------------
-    transcribe_timings t; transcribe_timings_init(&t);
+    transcribe_timings t;
+    transcribe_timings_init(&t);
     CHECK(transcribe_get_timings(ctx, &t) == TRANSCRIBE_OK);
     std::fprintf(stderr,
                  "cohere_e2e_smoke: timings load=%.2f mel=%.2f "
@@ -298,9 +286,7 @@ int main() {
     // If it takes longer, something is hung or degenerate.
     std::fprintf(stderr, "cohere_e2e_smoke: wall=%.2f ms\n", wall_ms);
     if (wall_ms > 120000.0) {
-        std::fprintf(stderr,
-                     "FAIL: wall time %.0f ms exceeds 120 s budget\n",
-                     wall_ms);
+        std::fprintf(stderr, "FAIL: wall time %.0f ms exceeds 120 s budget\n", wall_ms);
         ++g_failures;
     }
 
@@ -310,7 +296,8 @@ int main() {
 
     // At least one segment with non-empty text.
     if (n_segments > 0) {
-        transcribe_segment seg; transcribe_segment_init(&seg);
+        transcribe_segment seg;
+        transcribe_segment_init(&seg);
         CHECK_EQ_INT(transcribe_get_segment(ctx, 0, &seg), TRANSCRIBE_OK);
         CHECK(seg.text != nullptr && seg.text[0] != '\0');
     }
@@ -324,12 +311,13 @@ int main() {
     // NONE. segment_n_{words,tokens} are both zero because the
     // family does not expose sub-segment structure.
     CHECK(transcribe_returned_timestamp_kind(ctx) == TRANSCRIBE_TIMESTAMPS_NONE);
-    CHECK_EQ_INT(transcribe_n_words(ctx),  0);
+    CHECK_EQ_INT(transcribe_n_words(ctx), 0);
     CHECK_EQ_INT(transcribe_n_tokens(ctx), 0);
     if (n_segments > 0) {
-        transcribe_segment seg; transcribe_segment_init(&seg);
+        transcribe_segment seg;
+        transcribe_segment_init(&seg);
         CHECK_EQ_INT(transcribe_get_segment(ctx, 0, &seg), TRANSCRIBE_OK);
-        CHECK_EQ_INT(seg.n_words,  0);
+        CHECK_EQ_INT(seg.n_words, 0);
         CHECK_EQ_INT(seg.n_tokens, 0);
     }
 
@@ -347,25 +335,25 @@ int main() {
     // is the "transcribe_run replaces the previous result" rule
     // from include/transcribe.h applied to the failure path.
     {
-        transcribe_run_params rp2; transcribe_run_params_init(&rp2);
-        rp2.timestamps = TRANSCRIBE_TIMESTAMPS_WORD;
-        const transcribe_status st =
-            transcribe_run(ctx, pcm.data(), static_cast<int>(pcm.size()), &rp2);
+        transcribe_run_params rp2;
+        transcribe_run_params_init(&rp2);
+        rp2.timestamps             = TRANSCRIBE_TIMESTAMPS_WORD;
+        const transcribe_status st = transcribe_run(ctx, pcm.data(), static_cast<int>(pcm.size()), &rp2);
         CHECK(st == TRANSCRIBE_ERR_UNSUPPORTED_TIMESTAMPS);
         // The prior successful result must be gone: no stale text,
         // no stale segments/words/tokens, returned_timestamp_kind
         // back to the pre-run sentinel.
         CHECK(std::strcmp(transcribe_full_text(ctx), "") == 0);
         CHECK_EQ_INT(transcribe_n_segments(ctx), 0);
-        CHECK_EQ_INT(transcribe_n_words(ctx),    0);
-        CHECK_EQ_INT(transcribe_n_tokens(ctx),   0);
+        CHECK_EQ_INT(transcribe_n_words(ctx), 0);
+        CHECK_EQ_INT(transcribe_n_tokens(ctx), 0);
         CHECK(transcribe_returned_timestamp_kind(ctx) == TRANSCRIBE_TIMESTAMPS_NONE);
     }
     {
-        transcribe_run_params rp2; transcribe_run_params_init(&rp2);
-        rp2.timestamps = TRANSCRIBE_TIMESTAMPS_SEGMENT;
-        const transcribe_status st =
-            transcribe_run(ctx, pcm.data(), static_cast<int>(pcm.size()), &rp2);
+        transcribe_run_params rp2;
+        transcribe_run_params_init(&rp2);
+        rp2.timestamps             = TRANSCRIBE_TIMESTAMPS_SEGMENT;
+        const transcribe_status st = transcribe_run(ctx, pcm.data(), static_cast<int>(pcm.size()), &rp2);
         CHECK(st == TRANSCRIBE_ERR_UNSUPPORTED_TIMESTAMPS);
         CHECK(std::strcmp(transcribe_full_text(ctx), "") == 0);
         CHECK_EQ_INT(transcribe_n_segments(ctx), 0);
diff --git a/tests/cohere_real_smoke.cpp b/tests/cohere_real_smoke.cpp
index 0f62e556..1e1816ea 100644
--- a/tests/cohere_real_smoke.cpp
+++ b/tests/cohere_real_smoke.cpp
@@ -54,13 +54,11 @@
 // exist for the real 2.0B dimensions and cannot be exercised by a
 // synthetic fixture.
 
-#include "transcribe.h"
-
 #include "arch/cohere/cohere.h"
 #include "arch/cohere/weights.h"
-#include "transcribe-model.h"
-
 #include "ggml.h"
+#include "transcribe-model.h"
+#include "transcribe.h"
 
 #include <sys/stat.h>
 
@@ -73,51 +71,44 @@ namespace {
 
 int g_failures = 0;
 
-#define CHECK(cond)                                                         \
-    do {                                                                    \
-        if (!(cond)) {                                                      \
-            std::fprintf(stderr, "FAIL %s:%d: %s\n",                        \
-                         __FILE__, __LINE__, #cond);                        \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK(cond)                                                              \
+    do {                                                                         \
+        if (!(cond)) {                                                           \
+            std::fprintf(stderr, "FAIL %s:%d: %s\n", __FILE__, __LINE__, #cond); \
+            ++g_failures;                                                        \
+        }                                                                        \
     } while (0)
 
-#define CHECK_EQ_INT(actual, expected)                                      \
-    do {                                                                    \
-        const long long _a = static_cast<long long>(actual);                \
-        const long long _e = static_cast<long long>(expected);              \
-        if (_a != _e) {                                                     \
-            std::fprintf(stderr,                                            \
-                         "FAIL %s:%d: %s = %lld, expected %lld\n",          \
-                         __FILE__, __LINE__, #actual, _a, _e);              \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK_EQ_INT(actual, expected)                                                                           \
+    do {                                                                                                         \
+        const long long _a = static_cast<long long>(actual);                                                     \
+        const long long _e = static_cast<long long>(expected);                                                   \
+        if (_a != _e) {                                                                                          \
+            std::fprintf(stderr, "FAIL %s:%d: %s = %lld, expected %lld\n", __FILE__, __LINE__, #actual, _a, _e); \
+            ++g_failures;                                                                                        \
+        }                                                                                                        \
     } while (0)
 
-#define CHECK_STR_EQ(a, b)                                                  \
-    do {                                                                    \
-        const std::string _av = (a);                                        \
-        const std::string _bv = (b);                                        \
-        if (_av != _bv) {                                                   \
-            std::fprintf(stderr,                                            \
-                         "FAIL %s:%d: \"%s\" != \"%s\"\n",                  \
-                         __FILE__, __LINE__,                                \
-                         _av.c_str(), _bv.c_str());                         \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK_STR_EQ(a, b)                                                                                        \
+    do {                                                                                                          \
+        const std::string _av = (a);                                                                              \
+        const std::string _bv = (b);                                                                              \
+        if (_av != _bv) {                                                                                         \
+            std::fprintf(stderr, "FAIL %s:%d: \"%s\" != \"%s\"\n", __FILE__, __LINE__, _av.c_str(), _bv.c_str()); \
+            ++g_failures;                                                                                         \
+        }                                                                                                         \
     } while (0)
 
 bool file_exists(const std::string & path) {
-    struct stat st {};
+    struct stat st{};
     return ::stat(path.c_str(), &st) == 0;
 }
 
-const transcribe::cohere::CohereModel *
-cohere_view(const struct transcribe_model * m) {
+const transcribe::cohere::CohereModel * cohere_view(const struct transcribe_model * m) {
     return static_cast<const transcribe::cohere::CohereModel *>(m);
 }
 
-} // namespace
+}  // namespace
 
 int main() {
     const char * env = std::getenv("TRANSCRIBE_COHERE_GGUF");
@@ -127,27 +118,24 @@ int main() {
                      "set; skipping. Convert a real model with:\n"
                      "  uv run scripts/convert-cohere.py "
                      "<model-dir> --repo-id CohereLabs/cohere-transcribe-03-2026\n"
-                     "and re-run with TRANSCRIBE_COHERE_GGUF=models/cohere-transcribe-03-2026/cohere-transcribe-03-2026-BF16.gguf\n");
+                     "and re-run with "
+                     "TRANSCRIBE_COHERE_GGUF=models/cohere-transcribe-03-2026/cohere-transcribe-03-2026-BF16.gguf\n");
         return 77;
     }
     const std::string fixture = env;
 
     if (!file_exists(fixture)) {
-        std::fprintf(stderr,
-                     "cohere_real_smoke: file not found: %s\n",
-                     fixture.c_str());
+        std::fprintf(stderr, "cohere_real_smoke: file not found: %s\n", fixture.c_str());
         return 77;
     }
 
-    transcribe_model_load_params mp; transcribe_model_load_params_init(&mp);
+    transcribe_model_load_params mp;
+    transcribe_model_load_params_init(&mp);
     struct transcribe_model * model = nullptr;
 
-    const transcribe_status st =
-        transcribe_model_load_file(fixture.c_str(), &mp, &model);
+    const transcribe_status st = transcribe_model_load_file(fixture.c_str(), &mp, &model);
     if (st != TRANSCRIBE_OK) {
-        std::fprintf(stderr,
-                     "FAIL load: expected OK, got %s\n",
-                     transcribe_status_string(st));
+        std::fprintf(stderr, "FAIL load: expected OK, got %s\n", transcribe_status_string(st));
         return EXIT_FAILURE;
     }
     if (model == nullptr) {
@@ -159,25 +147,23 @@ int main() {
     // "Metal" (Apple Silicon, default) or "CPU" (fallback). The
     // exact label depends on the build platform; we just assert
     // it is non-empty.
-    CHECK_STR_EQ(transcribe_model_arch_string(model),    "cohere_asr");
+    CHECK_STR_EQ(transcribe_model_arch_string(model), "cohere_asr");
     CHECK_STR_EQ(transcribe_model_variant_string(model), "cohere-transcribe-03-2026");
     {
         const std::string backend = transcribe_model_backend(model);
         if (backend.empty()) {
-            std::fprintf(stderr,
-                         "FAIL: backend = \"\" after load, expected non-empty\n");
+            std::fprintf(stderr, "FAIL: backend = \"\" after load, expected non-empty\n");
             ++g_failures;
         } else {
-            std::fprintf(stderr, "cohere_real_smoke: backend=%s\n",
-                         backend.c_str());
+            std::fprintf(stderr, "cohere_real_smoke: backend=%s\n", backend.c_str());
         }
     }
 
     // Family invariants + language catalog.
-    transcribe_capabilities caps_buf; transcribe_capabilities_init(&caps_buf);
-    const bool caps_ok =
-        transcribe_model_get_capabilities(model, &caps_buf) == TRANSCRIBE_OK;
-    const transcribe_capabilities * caps = caps_ok ? &caps_buf : nullptr;
+    transcribe_capabilities caps_buf;
+    transcribe_capabilities_init(&caps_buf);
+    const bool                      caps_ok = transcribe_model_get_capabilities(model, &caps_buf) == TRANSCRIBE_OK;
+    const transcribe_capabilities * caps    = caps_ok ? &caps_buf : nullptr;
     CHECK(caps != nullptr);
     if (caps != nullptr) {
         CHECK_EQ_INT(caps->native_sample_rate, 16000);
@@ -209,45 +195,45 @@ int main() {
     const auto & hp = cm->hparams;
 
     // Encoder (Conformer, 48 layers, d_model 1280, 8 heads).
-    CHECK_EQ_INT(hp.enc_n_layers,             48);
-    CHECK_EQ_INT(hp.enc_d_model,              1280);
-    CHECK_EQ_INT(hp.enc_n_heads,              8);
-    CHECK_EQ_INT(hp.enc_head_dim(),           160);  // 1280 / 8
+    CHECK_EQ_INT(hp.enc_n_layers, 48);
+    CHECK_EQ_INT(hp.enc_d_model, 1280);
+    CHECK_EQ_INT(hp.enc_n_heads, 8);
+    CHECK_EQ_INT(hp.enc_head_dim(), 160);  // 1280 / 8
     // ff_expansion_factor == 4 -> d_ff == d_model * 4 == 5120
-    CHECK_EQ_INT(hp.enc_d_ff,                 5120);
-    CHECK_EQ_INT(hp.enc_conv_kernel,          9);
-    CHECK_EQ_INT(hp.enc_subsampling_factor,   8);
+    CHECK_EQ_INT(hp.enc_d_ff, 5120);
+    CHECK_EQ_INT(hp.enc_conv_kernel, 9);
+    CHECK_EQ_INT(hp.enc_subsampling_factor, 8);
     CHECK_EQ_INT(hp.enc_subsampling_channels, 256);
-    CHECK_EQ_INT(hp.enc_pos_emb_max_len,      5000);
+    CHECK_EQ_INT(hp.enc_pos_emb_max_len, 5000);
     CHECK(hp.enc_use_bias == true);
 
     // Decoder (autoregressive Transformer, 8 layers, hidden 1024,
     // 8 heads, inner 4096, relu activation, max_seq 1024).
-    CHECK_EQ_INT(hp.dec_n_layers,  8);
-    CHECK_EQ_INT(hp.dec_hidden,    1024);
-    CHECK_EQ_INT(hp.dec_n_heads,   8);
+    CHECK_EQ_INT(hp.dec_n_layers, 8);
+    CHECK_EQ_INT(hp.dec_hidden, 1024);
+    CHECK_EQ_INT(hp.dec_n_heads, 8);
     CHECK_EQ_INT(hp.dec_head_dim(), 128);  // 1024 / 8
-    CHECK_EQ_INT(hp.dec_inner,     4096);
-    CHECK_EQ_INT(hp.dec_max_seq,   1024);
+    CHECK_EQ_INT(hp.dec_inner, 4096);
+    CHECK_EQ_INT(hp.dec_max_seq, 1024);
     CHECK_STR_EQ(hp.dec_activation, "relu");
 
     // Frontend (mel feature extractor).
-    CHECK_STR_EQ(hp.fe_type,       "mel");
-    CHECK_EQ_INT(hp.fe_num_mels,    128);
+    CHECK_STR_EQ(hp.fe_type, "mel");
+    CHECK_EQ_INT(hp.fe_num_mels, 128);
     CHECK_EQ_INT(hp.fe_sample_rate, 16000);
-    CHECK_EQ_INT(hp.fe_n_fft,       512);
-    CHECK_EQ_INT(hp.fe_win_length,  400);   // 0.025 s * 16000
-    CHECK_EQ_INT(hp.fe_hop_length,  160);   // 0.010 s * 16000
-    CHECK_STR_EQ(hp.fe_window,      "hann");
-    CHECK_STR_EQ(hp.fe_normalize,   "per_feature");
-    CHECK_STR_EQ(hp.fe_pad_mode,    "constant");
-    CHECK(hp.fe_dither       == 0.0f);
+    CHECK_EQ_INT(hp.fe_n_fft, 512);
+    CHECK_EQ_INT(hp.fe_win_length, 400);  // 0.025 s * 16000
+    CHECK_EQ_INT(hp.fe_hop_length, 160);  // 0.010 s * 16000
+    CHECK_STR_EQ(hp.fe_window, "hann");
+    CHECK_STR_EQ(hp.fe_normalize, "per_feature");
+    CHECK_STR_EQ(hp.fe_pad_mode, "constant");
+    CHECK(hp.fe_dither == 0.0f);
     CHECK(hp.fe_pre_emphasis == 0.97f);
-    CHECK(hp.fe_f_min        == 0.0f);
-    CHECK(hp.fe_f_max        == 8000.0f);
+    CHECK(hp.fe_f_min == 0.0f);
+    CHECK(hp.fe_f_max == 8000.0f);
 
     // Block vectors sized from hparams.
-    CHECK_EQ_INT(cm->weights.blocks.size(),     48);
+    CHECK_EQ_INT(cm->weights.blocks.size(), 48);
     CHECK_EQ_INT(cm->weights.dec_blocks.size(), 8);
 
     // Total tensor count: derived rigorously from the converter
@@ -269,15 +255,14 @@ int main() {
     // collectively prove every tensor in the catalog was present
     // and correctly shaped. We still sanity-check the arithmetic.
     {
-        const int expected_total =
-              12           // PRE_ENCODE_TABLE
-            + 48 * 39      // ENCODER_BLOCK_TABLE per layer
-            + 2            // ENC_DEC_PROJ_TABLE
-            + 4            // DEC_EMBED_TABLE
-            + 8 * 26       // DECODER_BLOCK_TABLE per layer
-            + 2            // DEC_FINAL_NORM_TABLE
-            + 1            // HEAD_TABLE
-            + 2;           // frontend fb + window
+        const int expected_total = 12         // PRE_ENCODE_TABLE
+                                   + 48 * 39  // ENCODER_BLOCK_TABLE per layer
+                                   + 2        // ENC_DEC_PROJ_TABLE
+                                   + 4        // DEC_EMBED_TABLE
+                                   + 8 * 26   // DECODER_BLOCK_TABLE per layer
+                                   + 2        // DEC_FINAL_NORM_TABLE
+                                   + 1        // HEAD_TABLE
+                                   + 2;       // frontend fb + window
         CHECK_EQ_INT(expected_total, 2103);
     }
 
@@ -325,7 +310,7 @@ int main() {
         const auto * t = cm->weights.dec_embed.token_w;
         CHECK(t != nullptr);
         if (t != nullptr) {
-            CHECK_EQ_INT(t->ne[0], 1024);                 // dec_hidden
+            CHECK_EQ_INT(t->ne[0], 1024);  // dec_hidden
             CHECK_EQ_INT(t->ne[1], hp.vocab_size);
             CHECK(hp.vocab_size > 0);
         }
diff --git a/tests/cohere_smoke.cpp b/tests/cohere_smoke.cpp
index c7345840..c62c0b2d 100644
--- a/tests/cohere_smoke.cpp
+++ b/tests/cohere_smoke.cpp
@@ -38,14 +38,12 @@
 //   - cohere_e2e_smoke.cpp:   real-model gated end-to-end transcription
 //                             test (loads jfk.wav, checks transcript).
 
-#include "transcribe.h"
-
 #include "arch/cohere/cohere.h"
 #include "arch/cohere/weights.h"
-#include "transcribe-model.h"
-
-#include "ggml.h"
 #include "ggml-backend.h"
+#include "ggml.h"
+#include "transcribe-model.h"
+#include "transcribe.h"
 
 #include <sys/stat.h>
 
@@ -55,7 +53,7 @@
 #include <string>
 
 #ifndef TRANSCRIBE_TEST_FIXTURES_DIR
-#  error "TRANSCRIBE_TEST_FIXTURES_DIR must be defined by the build system"
+#    error "TRANSCRIBE_TEST_FIXTURES_DIR must be defined by the build system"
 #endif
 
 namespace {
@@ -64,51 +62,44 @@ const std::string g_fixtures_dir = TRANSCRIBE_TEST_FIXTURES_DIR;
 
 int g_failures = 0;
 
-#define CHECK(cond)                                                         \
-    do {                                                                    \
-        if (!(cond)) {                                                      \
-            std::fprintf(stderr, "FAIL %s:%d: %s\n",                        \
-                         __FILE__, __LINE__, #cond);                        \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK(cond)                                                              \
+    do {                                                                         \
+        if (!(cond)) {                                                           \
+            std::fprintf(stderr, "FAIL %s:%d: %s\n", __FILE__, __LINE__, #cond); \
+            ++g_failures;                                                        \
+        }                                                                        \
     } while (0)
 
-#define CHECK_EQ_INT(actual, expected)                                      \
-    do {                                                                    \
-        const long long _a = static_cast<long long>(actual);                \
-        const long long _e = static_cast<long long>(expected);              \
-        if (_a != _e) {                                                     \
-            std::fprintf(stderr,                                            \
-                         "FAIL %s:%d: %s = %lld, expected %lld\n",          \
-                         __FILE__, __LINE__, #actual, _a, _e);              \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK_EQ_INT(actual, expected)                                                                           \
+    do {                                                                                                         \
+        const long long _a = static_cast<long long>(actual);                                                     \
+        const long long _e = static_cast<long long>(expected);                                                   \
+        if (_a != _e) {                                                                                          \
+            std::fprintf(stderr, "FAIL %s:%d: %s = %lld, expected %lld\n", __FILE__, __LINE__, #actual, _a, _e); \
+            ++g_failures;                                                                                        \
+        }                                                                                                        \
     } while (0)
 
-#define CHECK_STR_EQ(a, b)                                                  \
-    do {                                                                    \
-        const std::string _av = (a);                                        \
-        const std::string _bv = (b);                                        \
-        if (_av != _bv) {                                                   \
-            std::fprintf(stderr,                                            \
-                         "FAIL %s:%d: \"%s\" != \"%s\"\n",                  \
-                         __FILE__, __LINE__,                                \
-                         _av.c_str(), _bv.c_str());                         \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK_STR_EQ(a, b)                                                                                        \
+    do {                                                                                                          \
+        const std::string _av = (a);                                                                              \
+        const std::string _bv = (b);                                                                              \
+        if (_av != _bv) {                                                                                         \
+            std::fprintf(stderr, "FAIL %s:%d: \"%s\" != \"%s\"\n", __FILE__, __LINE__, _av.c_str(), _bv.c_str()); \
+            ++g_failures;                                                                                         \
+        }                                                                                                         \
     } while (0)
 
 bool file_exists(const std::string & path) {
-    struct stat st {};
+    struct stat st{};
     return ::stat(path.c_str(), &st) == 0;
 }
 
-const transcribe::cohere::CohereModel *
-cohere_view(const struct transcribe_model * m) {
+const transcribe::cohere::CohereModel * cohere_view(const struct transcribe_model * m) {
     return static_cast<const transcribe::cohere::CohereModel *>(m);
 }
 
-} // namespace
+}  // namespace
 
 int main() {
     const std::string fixture = g_fixtures_dir + "/arch_cohere_minimal.gguf";
@@ -119,7 +110,7 @@ int main() {
                      "regenerate with:\n"
                      "  cmake --build build --target fixtures\n",
                      fixture.c_str());
-        return 77; // CTest "skipped"
+        return 77;  // CTest "skipped"
     }
 
     // Force CPU backend: the fuse_batch_norm + promote_conv_pw_to_f32
@@ -127,16 +118,14 @@ int main() {
     // backend guaranteed to be present everywhere we run this test;
     // it also exercises promote_conv_pw_to_f32_on_cpu, which is a
     // no-op on GPU backends.
-    transcribe_model_load_params mp; transcribe_model_load_params_init(&mp);
-    mp.backend = TRANSCRIBE_BACKEND_CPU;
+    transcribe_model_load_params mp;
+    transcribe_model_load_params_init(&mp);
+    mp.backend                      = TRANSCRIBE_BACKEND_CPU;
     struct transcribe_model * model = nullptr;
 
-    const transcribe_status st =
-        transcribe_model_load_file(fixture.c_str(), &mp, &model);
+    const transcribe_status st = transcribe_model_load_file(fixture.c_str(), &mp, &model);
     if (st != TRANSCRIBE_OK) {
-        std::fprintf(stderr,
-                     "FAIL load: expected OK, got %s\n",
-                     transcribe_status_string(st));
+        std::fprintf(stderr, "FAIL load: expected OK, got %s\n", transcribe_status_string(st));
         return EXIT_FAILURE;
     }
     if (model == nullptr) {
@@ -152,8 +141,7 @@ int main() {
     {
         const char * backend = transcribe_model_backend(model);
         if (backend == nullptr || backend[0] == '\0') {
-            std::fprintf(stderr,
-                         "FAIL: backend = \"\" after load, expected non-empty\n");
+            std::fprintf(stderr, "FAIL: backend = \"\" after load, expected non-empty\n");
             ++g_failures;
         }
     }
@@ -169,52 +157,52 @@ int main() {
     // COHERE_HP. If either side drifts the test fails loudly.
     const auto & hp = cm->hparams;
     // Encoder.
-    CHECK_EQ_INT(hp.enc_n_layers,             2);
-    CHECK_EQ_INT(hp.enc_d_model,              8);
-    CHECK_EQ_INT(hp.enc_n_heads,              2);
-    CHECK_EQ_INT(hp.enc_d_ff,                 16);
-    CHECK_EQ_INT(hp.enc_conv_kernel,          3);
-    CHECK_EQ_INT(hp.enc_subsampling_factor,   2);
+    CHECK_EQ_INT(hp.enc_n_layers, 2);
+    CHECK_EQ_INT(hp.enc_d_model, 8);
+    CHECK_EQ_INT(hp.enc_n_heads, 2);
+    CHECK_EQ_INT(hp.enc_d_ff, 16);
+    CHECK_EQ_INT(hp.enc_conv_kernel, 3);
+    CHECK_EQ_INT(hp.enc_subsampling_factor, 2);
     CHECK_EQ_INT(hp.enc_subsampling_channels, 4);
-    CHECK_EQ_INT(hp.enc_pos_emb_max_len,      32);
-    CHECK_EQ_INT(hp.enc_use_bias,             1); // fixture sets true
-    CHECK_EQ_INT(hp.enc_head_dim(),           4); // 8 / 2
+    CHECK_EQ_INT(hp.enc_pos_emb_max_len, 32);
+    CHECK_EQ_INT(hp.enc_use_bias, 1);    // fixture sets true
+    CHECK_EQ_INT(hp.enc_head_dim(), 4);  // 8 / 2
 
     // Decoder.
     CHECK_EQ_INT(hp.dec_n_layers, 2);
-    CHECK_EQ_INT(hp.dec_hidden,   8);
-    CHECK_EQ_INT(hp.dec_n_heads,  2);
-    CHECK_EQ_INT(hp.dec_inner,    16);
-    CHECK_EQ_INT(hp.dec_max_seq,  32);
-    CHECK_EQ_INT(hp.dec_head_dim(), 4); // 8 / 2
+    CHECK_EQ_INT(hp.dec_hidden, 8);
+    CHECK_EQ_INT(hp.dec_n_heads, 2);
+    CHECK_EQ_INT(hp.dec_inner, 16);
+    CHECK_EQ_INT(hp.dec_max_seq, 32);
+    CHECK_EQ_INT(hp.dec_head_dim(), 4);  // 8 / 2
     CHECK_STR_EQ(hp.dec_activation, "relu");
 
     // Token IDs / vocab. vocab_size is derived from the tokenizer
     // (set in load() after read_cohere_hparams), so we check it
     // post-load against TOY_VOCAB length.
-    CHECK_EQ_INT(hp.vocab_size,              16);
-    CHECK_EQ_INT(hp.decoder_start_token_id,  1);
-    CHECK_EQ_INT(hp.bos_token_id,            1);
-    CHECK_EQ_INT(hp.eos_token_id,            2);
+    CHECK_EQ_INT(hp.vocab_size, 16);
+    CHECK_EQ_INT(hp.decoder_start_token_id, 1);
+    CHECK_EQ_INT(hp.bos_token_id, 1);
+    CHECK_EQ_INT(hp.eos_token_id, 2);
 
     // Head defaults (fixture sets both true).
-    CHECK_EQ_INT(hp.head_log_softmax,  1);
+    CHECK_EQ_INT(hp.head_log_softmax, 1);
     CHECK_EQ_INT(hp.head_tied_weights, 1);
 
     // Frontend.
-    CHECK_STR_EQ(hp.fe_type,        "mel");
-    CHECK_EQ_INT(hp.fe_num_mels,    4);
+    CHECK_STR_EQ(hp.fe_type, "mel");
+    CHECK_EQ_INT(hp.fe_num_mels, 4);
     CHECK_EQ_INT(hp.fe_sample_rate, 16000);
-    CHECK_EQ_INT(hp.fe_n_fft,       16);
-    CHECK_EQ_INT(hp.fe_win_length,  8);
-    CHECK_EQ_INT(hp.fe_hop_length,  4);
-    CHECK_STR_EQ(hp.fe_window,      "hann");
-    CHECK_STR_EQ(hp.fe_normalize,   "per_feature");
-    CHECK_STR_EQ(hp.fe_pad_mode,    "reflect");
-    CHECK(hp.fe_dither       == 1e-5f);
+    CHECK_EQ_INT(hp.fe_n_fft, 16);
+    CHECK_EQ_INT(hp.fe_win_length, 8);
+    CHECK_EQ_INT(hp.fe_hop_length, 4);
+    CHECK_STR_EQ(hp.fe_window, "hann");
+    CHECK_STR_EQ(hp.fe_normalize, "per_feature");
+    CHECK_STR_EQ(hp.fe_pad_mode, "reflect");
+    CHECK(hp.fe_dither == 1e-5f);
     CHECK(hp.fe_pre_emphasis == 0.97f);
-    CHECK(hp.fe_f_min        == 0.0f);
-    CHECK(hp.fe_f_max        == 8000.0f);
+    CHECK(hp.fe_f_min == 0.0f);
+    CHECK(hp.fe_f_max == 8000.0f);
 
     // ----- Pre-encode slots populated -----
     const auto & pe = cm->weights.pre_encode;
@@ -228,8 +216,8 @@ int main() {
     CHECK(pe.conv5_b != nullptr);
     CHECK(pe.conv6_w != nullptr);
     CHECK(pe.conv6_b != nullptr);
-    CHECK(pe.out_w   != nullptr);
-    CHECK(pe.out_b   != nullptr);
+    CHECK(pe.out_w != nullptr);
+    CHECK(pe.out_b != nullptr);
 
     // ----- Encoder block slots populated for every layer -----
     CHECK_EQ_INT(cm->weights.blocks.size(), 2);
@@ -239,56 +227,56 @@ int main() {
         // every category got populated. Cohere differs from Parakeet
         // by carrying FFN bias on every linear, so we explicitly
         // check those biases here.
-        CHECK(b.norm_ff1_w  != nullptr);
-        CHECK(b.ff1_lin1_w  != nullptr);
-        CHECK(b.ff1_lin1_b  != nullptr);
-        CHECK(b.ff1_lin2_w  != nullptr);
-        CHECK(b.ff1_lin2_b  != nullptr);
+        CHECK(b.norm_ff1_w != nullptr);
+        CHECK(b.ff1_lin1_w != nullptr);
+        CHECK(b.ff1_lin1_b != nullptr);
+        CHECK(b.ff1_lin2_w != nullptr);
+        CHECK(b.ff1_lin2_b != nullptr);
         CHECK(b.norm_attn_w != nullptr);
-        CHECK(b.attn_q_w    != nullptr);
+        CHECK(b.attn_q_w != nullptr);
         // attn_q_b is fused into pos_bias_u/v at load time
         // (fuse_encoder_q_bias); after fusion it MUST be null so the
         // graph builder skips the redundant add.
-        CHECK(b.attn_q_b    == nullptr);
-        CHECK(b.attn_k_w    != nullptr);
-        CHECK(b.attn_k_b    != nullptr);
-        CHECK(b.attn_v_w    != nullptr);
-        CHECK(b.attn_v_b    != nullptr);
-        CHECK(b.attn_out_w  != nullptr);
-        CHECK(b.attn_out_b  != nullptr);
-        CHECK(b.attn_pos_w  != nullptr);
-        CHECK(b.attn_pos_u  != nullptr);
-        CHECK(b.attn_pos_v  != nullptr);
+        CHECK(b.attn_q_b == nullptr);
+        CHECK(b.attn_k_w != nullptr);
+        CHECK(b.attn_k_b != nullptr);
+        CHECK(b.attn_v_w != nullptr);
+        CHECK(b.attn_v_b != nullptr);
+        CHECK(b.attn_out_w != nullptr);
+        CHECK(b.attn_out_b != nullptr);
+        CHECK(b.attn_pos_w != nullptr);
+        CHECK(b.attn_pos_u != nullptr);
+        CHECK(b.attn_pos_v != nullptr);
         CHECK(b.norm_conv_w != nullptr);
-        CHECK(b.conv_pw1_w  != nullptr);
-        CHECK(b.conv_pw1_b  != nullptr);
-        CHECK(b.conv_dw_w   != nullptr);
-        CHECK(b.conv_dw_b   != nullptr);
-        CHECK(b.conv_pw2_w  != nullptr);
-        CHECK(b.conv_pw2_b  != nullptr);
-        CHECK(b.conv_bn_w   != nullptr);
-        CHECK(b.conv_bn_rm  != nullptr);
-        CHECK(b.conv_bn_rv  != nullptr);
+        CHECK(b.conv_pw1_w != nullptr);
+        CHECK(b.conv_pw1_b != nullptr);
+        CHECK(b.conv_dw_w != nullptr);
+        CHECK(b.conv_dw_b != nullptr);
+        CHECK(b.conv_pw2_w != nullptr);
+        CHECK(b.conv_pw2_b != nullptr);
+        CHECK(b.conv_bn_w != nullptr);
+        CHECK(b.conv_bn_rm != nullptr);
+        CHECK(b.conv_bn_rv != nullptr);
         // BN fuse runs at load: both fused tensors must be populated.
         CHECK(b.conv_bn_fused_scale != nullptr);
-        CHECK(b.conv_bn_fused_bias  != nullptr);
-        CHECK(b.norm_ff2_w  != nullptr);
-        CHECK(b.ff2_lin1_w  != nullptr);
-        CHECK(b.ff2_lin1_b  != nullptr);
-        CHECK(b.ff2_lin2_w  != nullptr);
-        CHECK(b.ff2_lin2_b  != nullptr);
-        CHECK(b.norm_out_w  != nullptr);
+        CHECK(b.conv_bn_fused_bias != nullptr);
+        CHECK(b.norm_ff2_w != nullptr);
+        CHECK(b.ff2_lin1_w != nullptr);
+        CHECK(b.ff2_lin1_b != nullptr);
+        CHECK(b.ff2_lin2_w != nullptr);
+        CHECK(b.ff2_lin2_b != nullptr);
+        CHECK(b.norm_out_w != nullptr);
     }
 
     // ----- Encoder-decoder projection -----
     CHECK(cm->weights.enc_dec_proj.weight != nullptr);
-    CHECK(cm->weights.enc_dec_proj.bias   != nullptr);
+    CHECK(cm->weights.enc_dec_proj.bias != nullptr);
 
     // ----- Decoder embedding -----
     CHECK(cm->weights.dec_embed.token_w != nullptr);
     CHECK(cm->weights.dec_embed.pos_enc != nullptr);
-    CHECK(cm->weights.dec_embed.norm_w  != nullptr);
-    CHECK(cm->weights.dec_embed.norm_b  != nullptr);
+    CHECK(cm->weights.dec_embed.norm_w != nullptr);
+    CHECK(cm->weights.dec_embed.norm_b != nullptr);
 
     // ----- Decoder block slots populated for every layer -----
     CHECK_EQ_INT(cm->weights.dec_blocks.size(), 2);
@@ -296,30 +284,30 @@ int main() {
         const auto & db = cm->weights.dec_blocks[i];
         // Self-attention.
         CHECK(db.norm_self_w != nullptr);
-        CHECK(db.self_q_w    != nullptr);
-        CHECK(db.self_q_b    != nullptr);
-        CHECK(db.self_k_w    != nullptr);
-        CHECK(db.self_k_b    != nullptr);
-        CHECK(db.self_v_w    != nullptr);
-        CHECK(db.self_v_b    != nullptr);
-        CHECK(db.self_out_w  != nullptr);
-        CHECK(db.self_out_b  != nullptr);
+        CHECK(db.self_q_w != nullptr);
+        CHECK(db.self_q_b != nullptr);
+        CHECK(db.self_k_w != nullptr);
+        CHECK(db.self_k_b != nullptr);
+        CHECK(db.self_v_w != nullptr);
+        CHECK(db.self_v_b != nullptr);
+        CHECK(db.self_out_w != nullptr);
+        CHECK(db.self_out_b != nullptr);
         // Cross-attention.
         CHECK(db.norm_cross_w != nullptr);
-        CHECK(db.cross_q_w    != nullptr);
-        CHECK(db.cross_q_b    != nullptr);
-        CHECK(db.cross_k_w    != nullptr);
-        CHECK(db.cross_k_b    != nullptr);
-        CHECK(db.cross_v_w    != nullptr);
-        CHECK(db.cross_v_b    != nullptr);
-        CHECK(db.cross_out_w  != nullptr);
-        CHECK(db.cross_out_b  != nullptr);
+        CHECK(db.cross_q_w != nullptr);
+        CHECK(db.cross_q_b != nullptr);
+        CHECK(db.cross_k_w != nullptr);
+        CHECK(db.cross_k_b != nullptr);
+        CHECK(db.cross_v_w != nullptr);
+        CHECK(db.cross_v_b != nullptr);
+        CHECK(db.cross_out_w != nullptr);
+        CHECK(db.cross_out_b != nullptr);
         // FFN.
         CHECK(db.norm_ff_w != nullptr);
-        CHECK(db.ff_in_w   != nullptr);
-        CHECK(db.ff_in_b   != nullptr);
-        CHECK(db.ff_out_w  != nullptr);
-        CHECK(db.ff_out_b  != nullptr);
+        CHECK(db.ff_in_w != nullptr);
+        CHECK(db.ff_in_b != nullptr);
+        CHECK(db.ff_out_w != nullptr);
+        CHECK(db.ff_out_b != nullptr);
     }
 
     // ----- Decoder final norm + head -----
@@ -335,12 +323,10 @@ int main() {
         CHECK_EQ_INT(pe.conv0_w->ne[0], 3);
         CHECK_EQ_INT(pe.conv0_w->ne[1], 3);
         CHECK_EQ_INT(pe.conv0_w->ne[2], 1);
-        CHECK_EQ_INT(pe.conv0_w->ne[3], 4); // channels
+        CHECK_EQ_INT(pe.conv0_w->ne[3], 4);  // channels
     }
     // First encoder block's q projection: square [d_model, d_model].
-    if (!cm->weights.blocks.empty() &&
-        cm->weights.blocks[0].attn_q_w != nullptr)
-    {
+    if (!cm->weights.blocks.empty() && cm->weights.blocks[0].attn_q_w != nullptr) {
         const auto * t = cm->weights.blocks[0].attn_q_w;
         CHECK_EQ_INT(t->ne[0], 8);
         CHECK_EQ_INT(t->ne[1], 8);
@@ -379,8 +365,7 @@ int main() {
         float v = 0.0f;
         ggml_backend_tensor_get(pe.conv0_w, &v, 0, sizeof(float));
         if (v != 0.0f) {
-            std::fprintf(stderr,
-                         "FAIL pre_encode.conv0_w[0]: got %f, expected 0.0\n", v);
+            std::fprintf(stderr, "FAIL pre_encode.conv0_w[0]: got %f, expected 0.0\n", v);
             ++g_failures;
         }
     } else {
@@ -391,8 +376,7 @@ int main() {
         float v = 0.0f;
         ggml_backend_tensor_get(pe.conv0_b, &v, 0, sizeof(float));
         if (v != 1.0f) {
-            std::fprintf(stderr,
-                         "FAIL pre_encode.conv0_b[0]: got %f, expected 1.0\n", v);
+            std::fprintf(stderr, "FAIL pre_encode.conv0_b[0]: got %f, expected 1.0\n", v);
             ++g_failures;
         }
     } else {
diff --git a/tests/conv_pw_promote_unit.cpp b/tests/conv_pw_promote_unit.cpp
index 90cfdcfb..59b06811 100644
--- a/tests/conv_pw_promote_unit.cpp
+++ b/tests/conv_pw_promote_unit.cpp
@@ -14,12 +14,11 @@
 //     dst slots are unchanged.
 //   - Empty slots: no-op, no crash.
 
-#include "transcribe-load-common.h"
-#include "transcribe-backend.h"
-
-#include "ggml.h"
 #include "ggml-alloc.h"
 #include "ggml-backend.h"
+#include "ggml.h"
+#include "transcribe-backend.h"
+#include "transcribe-load-common.h"
 
 #include <cmath>
 #include <cstdio>
@@ -30,40 +29,36 @@ namespace {
 
 int g_failures = 0;
 
-#define CHECK(cond)                                                         \
-    do {                                                                    \
-        if (!(cond)) {                                                      \
-            std::fprintf(stderr, "FAIL %s:%d: %s\n",                        \
-                         __FILE__, __LINE__, #cond);                        \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK(cond)                                                              \
+    do {                                                                         \
+        if (!(cond)) {                                                           \
+            std::fprintf(stderr, "FAIL %s:%d: %s\n", __FILE__, __LINE__, #cond); \
+            ++g_failures;                                                        \
+        }                                                                        \
     } while (0)
 
-#define CHECK_EQ(actual, expected)                                          \
-    do {                                                                    \
-        const auto _a = (actual);                                           \
-        const auto _e = (expected);                                         \
-        if (_a != _e) {                                                     \
-            std::fprintf(stderr, "FAIL %s:%d: got %d, expected %d\n",       \
-                         __FILE__, __LINE__,                                \
-                         static_cast<int>(_a),                              \
-                         static_cast<int>(_e));                             \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK_EQ(actual, expected)                                                                              \
+    do {                                                                                                        \
+        const auto _a = (actual);                                                                               \
+        const auto _e = (expected);                                                                             \
+        if (_a != _e) {                                                                                         \
+            std::fprintf(stderr, "FAIL %s:%d: got %d, expected %d\n", __FILE__, __LINE__, static_cast<int>(_a), \
+                         static_cast<int>(_e));                                                                 \
+            ++g_failures;                                                                                       \
+        }                                                                                                       \
     } while (0)
 
 // Bail macro for setup prerequisites: if the condition fails, log and
 // return EXIT_FAILURE immediately rather than crashing on a null deref.
-#define REQUIRE(cond)                                                       \
-    do {                                                                    \
-        if (!(cond)) {                                                      \
-            std::fprintf(stderr, "SETUP FAIL %s:%d: %s\n",                  \
-                         __FILE__, __LINE__, #cond);                        \
-            return EXIT_FAILURE;                                            \
-        }                                                                   \
+#define REQUIRE(cond)                                                                  \
+    do {                                                                               \
+        if (!(cond)) {                                                                 \
+            std::fprintf(stderr, "SETUP FAIL %s:%d: %s\n", __FILE__, __LINE__, #cond); \
+            return EXIT_FAILURE;                                                       \
+        }                                                                              \
     } while (0)
 
-} // namespace
+}  // namespace
 
 int main() {
     using namespace transcribe;
@@ -73,18 +68,17 @@ int main() {
     // -----------------------------------------------------------------
     // Set up a CPU backend and a small F16 tensor.
     // -----------------------------------------------------------------
-    ggml_backend_t cpu_be =
-        ggml_backend_init_by_type(GGML_BACKEND_DEVICE_TYPE_CPU, nullptr);
+    ggml_backend_t cpu_be = ggml_backend_init_by_type(GGML_BACKEND_DEVICE_TYPE_CPU, nullptr);
     if (cpu_be == nullptr) {
         std::fprintf(stderr, "SKIP: could not init CPU backend\n");
         return 77;
     }
 
     // Create a ggml context with two small F16 tensors.
-    const int64_t n_elem = 16;
-    const size_t ctx_size = 2 * ggml_tensor_overhead() + 256;
-    ggml_init_params init_params = {ctx_size, nullptr, true};
-    ggml_context * ctx = ggml_init(init_params);
+    const int64_t    n_elem      = 16;
+    const size_t     ctx_size    = 2 * ggml_tensor_overhead() + 256;
+    ggml_init_params init_params = { ctx_size, nullptr, true };
+    ggml_context *   ctx         = ggml_init(init_params);
     REQUIRE(ctx != nullptr);
 
     ggml_tensor * t1 = ggml_new_tensor_1d(ctx, GGML_TYPE_F16, n_elem);
@@ -95,8 +89,7 @@ int main() {
     ggml_set_name(t2, "test.conv_pw2");
 
     // Allocate and fill with known F16 values.
-    ggml_backend_buffer_t src_buffer =
-        ggml_backend_alloc_ctx_tensors(ctx, cpu_be);
+    ggml_backend_buffer_t src_buffer = ggml_backend_alloc_ctx_tensors(ctx, cpu_be);
     REQUIRE(src_buffer != nullptr);
 
     // Write deterministic F16 values: 1.0, 2.0, ..., 16.0 for t1;
@@ -106,13 +99,11 @@ int main() {
         for (int64_t i = 0; i < n_elem; ++i) {
             f16_data[i] = ggml_fp32_to_fp16(static_cast<float>(i + 1));
         }
-        ggml_backend_tensor_set(t1, f16_data.data(), 0,
-                                n_elem * sizeof(ggml_fp16_t));
+        ggml_backend_tensor_set(t1, f16_data.data(), 0, n_elem * sizeof(ggml_fp16_t));
         for (int64_t i = 0; i < n_elem; ++i) {
             f16_data[i] = ggml_fp32_to_fp16(-static_cast<float>(i + 1));
         }
-        ggml_backend_tensor_set(t2, f16_data.data(), 0,
-                                n_elem * sizeof(ggml_fp16_t));
+        ggml_backend_tensor_set(t2, f16_data.data(), 0, n_elem * sizeof(ggml_fp16_t));
     }
 
     // -----------------------------------------------------------------
@@ -124,18 +115,17 @@ int main() {
         plan.primary_kind = BackendKind::Cpu;
         plan.scheduler_list.push_back(cpu_be);
 
-        ggml_tensor * slot1 = t1;
-        ggml_tensor * slot2 = t2;
+        ggml_tensor *              slot1 = t1;
+        ggml_tensor *              slot2 = t2;
         std::vector<ConvPwF32Slot> slots = {
-            {&slot1, t1},
-            {&slot2, t2},
+            { &slot1, t1 },
+            { &slot2, t2 },
         };
 
-        ggml_context *          out_ctx    = nullptr;
-        ggml_backend_buffer_t   out_buffer = nullptr;
+        ggml_context *        out_ctx    = nullptr;
+        ggml_backend_buffer_t out_buffer = nullptr;
 
-        transcribe_status st = promote_conv_pw_f16_to_f32_on_cpu(
-            plan, slots, "test-promote", &out_ctx, &out_buffer);
+        transcribe_status st = promote_conv_pw_f16_to_f32_on_cpu(plan, slots, "test-promote", &out_ctx, &out_buffer);
 
         CHECK_EQ(st, TRANSCRIBE_OK);
         REQUIRE(out_ctx != nullptr);
@@ -150,16 +140,14 @@ int main() {
         // Read back F32 values and verify round-trip.
         std::vector<float> f32_out(n_elem);
 
-        ggml_backend_tensor_get(slot1, f32_out.data(), 0,
-                                n_elem * sizeof(float));
+        ggml_backend_tensor_get(slot1, f32_out.data(), 0, n_elem * sizeof(float));
         for (int64_t i = 0; i < n_elem; ++i) {
             // F16 round-trip is exact for small integers.
             float expected = static_cast<float>(i + 1);
             CHECK(std::fabs(f32_out[i] - expected) < 1e-4f);
         }
 
-        ggml_backend_tensor_get(slot2, f32_out.data(), 0,
-                                n_elem * sizeof(float));
+        ggml_backend_tensor_get(slot2, f32_out.data(), 0, n_elem * sizeof(float));
         for (int64_t i = 0; i < n_elem; ++i) {
             float expected = -static_cast<float>(i + 1);
             CHECK(std::fabs(f32_out[i] - expected) < 1e-4f);
@@ -185,16 +173,15 @@ int main() {
         plan.primary_kind = BackendKind::Metal;
         plan.scheduler_list.push_back(cpu_be);
 
-        ggml_tensor * slot1 = t1;
+        ggml_tensor *              slot1 = t1;
         std::vector<ConvPwF32Slot> slots = {
-            {&slot1, t1},
+            { &slot1, t1 },
         };
 
-        ggml_context *          out_ctx    = nullptr;
-        ggml_backend_buffer_t   out_buffer = nullptr;
+        ggml_context *        out_ctx    = nullptr;
+        ggml_backend_buffer_t out_buffer = nullptr;
 
-        transcribe_status st = promote_conv_pw_f16_to_f32_on_cpu(
-            plan, slots, "test-noop", &out_ctx, &out_buffer);
+        transcribe_status st = promote_conv_pw_f16_to_f32_on_cpu(plan, slots, "test-noop", &out_ctx, &out_buffer);
 
         CHECK_EQ(st, TRANSCRIBE_OK);
         // No-op: outparams not touched, slot not repointed.
@@ -212,13 +199,12 @@ int main() {
         plan.primary_kind = BackendKind::Cpu;
         plan.scheduler_list.push_back(cpu_be);
 
-        std::vector<ConvPwF32Slot> slots; // empty
+        std::vector<ConvPwF32Slot> slots;  // empty
 
-        ggml_context *          out_ctx    = nullptr;
-        ggml_backend_buffer_t   out_buffer = nullptr;
+        ggml_context *        out_ctx    = nullptr;
+        ggml_backend_buffer_t out_buffer = nullptr;
 
-        transcribe_status st = promote_conv_pw_f16_to_f32_on_cpu(
-            plan, slots, "test-empty", &out_ctx, &out_buffer);
+        transcribe_status st = promote_conv_pw_f16_to_f32_on_cpu(plan, slots, "test-empty", &out_ctx, &out_buffer);
 
         CHECK_EQ(st, TRANSCRIBE_OK);
         CHECK(out_ctx == nullptr);
diff --git a/tests/debug_dump_unit.cpp b/tests/debug_dump_unit.cpp
index 52492dc9..02e6d332 100644
--- a/tests/debug_dump_unit.cpp
+++ b/tests/debug_dump_unit.cpp
@@ -24,12 +24,13 @@
 //   - The compare_tensors.py side. That's exercised by numerical
 //     validation runs.
 
-#include "transcribe-debug.h"
-
-#include "ggml.h"
 #include "ggml-alloc.h"
 #include "ggml-backend.h"
 #include "ggml-cpu.h"
+#include "ggml.h"
+#include "transcribe-debug.h"
+
+#include <unistd.h>  // ::getpid()
 
 #include <cstdio>
 #include <cstdlib>
@@ -41,33 +42,28 @@
 #include <string>
 #include <vector>
 
-#include <unistd.h>   // ::getpid()
-
 namespace fs = std::filesystem;
 
 namespace {
 
 int g_failures = 0;
 
-#define CHECK(cond)                                                         \
-    do {                                                                    \
-        if (!(cond)) {                                                      \
-            std::fprintf(stderr, "FAIL %s:%d: %s\n",                        \
-                         __FILE__, __LINE__, #cond);                        \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK(cond)                                                              \
+    do {                                                                         \
+        if (!(cond)) {                                                           \
+            std::fprintf(stderr, "FAIL %s:%d: %s\n", __FILE__, __LINE__, #cond); \
+            ++g_failures;                                                        \
+        }                                                                        \
     } while (0)
 
-#define CHECK_EQ_INT(actual, expected)                                      \
-    do {                                                                    \
-        const long long _a = static_cast<long long>(actual);                \
-        const long long _e = static_cast<long long>(expected);              \
-        if (_a != _e) {                                                     \
-            std::fprintf(stderr,                                            \
-                         "FAIL %s:%d: %s = %lld, expected %lld\n",          \
-                         __FILE__, __LINE__, #actual, _a, _e);              \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK_EQ_INT(actual, expected)                                                                           \
+    do {                                                                                                         \
+        const long long _a = static_cast<long long>(actual);                                                     \
+        const long long _e = static_cast<long long>(expected);                                                   \
+        if (_a != _e) {                                                                                          \
+            std::fprintf(stderr, "FAIL %s:%d: %s = %lld, expected %lld\n", __FILE__, __LINE__, #actual, _a, _e); \
+            ++g_failures;                                                                                        \
+        }                                                                                                        \
     } while (0)
 
 // Create a fresh temporary directory under the system temp dir,
@@ -75,17 +71,21 @@ int g_failures = 0;
 fs::path make_unique_dump_dir() {
     fs::path base = fs::temp_directory_path() / "transcribe-debug-dump-test";
     base /= std::to_string(::getpid());
-    fs::remove_all(base); // ensure clean state in case of leftover
+    fs::remove_all(base);  // ensure clean state in case of leftover
     fs::create_directories(base);
     return base;
 }
 
 std::vector<uint8_t> read_file(const fs::path & p) {
     std::ifstream f(p, std::ios::binary);
-    if (!f) return {};
+    if (!f) {
+        return {};
+    }
     f.seekg(0, std::ios::end);
     const std::streampos len = f.tellg();
-    if (len < 0) return {};
+    if (len < 0) {
+        return {};
+    }
     f.seekg(0, std::ios::beg);
     std::vector<uint8_t> out(static_cast<size_t>(len));
     f.read(reinterpret_cast<char *>(out.data()), len);
@@ -94,7 +94,9 @@ std::vector<uint8_t> read_file(const fs::path & p) {
 
 std::string read_text(const fs::path & p) {
     std::ifstream f(p);
-    if (!f) return {};
+    if (!f) {
+        return {};
+    }
     std::stringstream ss;
     ss << f.rdbuf();
     return ss.str();
@@ -104,7 +106,7 @@ bool contains(const std::string & haystack, const std::string & needle) {
     return haystack.find(needle) != std::string::npos;
 }
 
-} // namespace
+}  // namespace
 
 int main() {
     // ----- Setup ------------------------------------------------------
@@ -119,18 +121,15 @@ int main() {
     }
 
     if (!transcribe::debug::init()) {
-        std::fprintf(stderr, "FAIL: debug::init() returned false despite "
+        std::fprintf(stderr,
+                     "FAIL: debug::init() returned false despite "
                      "TRANSCRIBE_DUMP_DIR being set\n");
         return EXIT_FAILURE;
     }
     CHECK(transcribe::debug::enabled());
-    if (transcribe::debug::dump_dir() == nullptr ||
-        std::strcmp(transcribe::debug::dump_dir(), dump_dir.c_str()) != 0)
-    {
+    if (transcribe::debug::dump_dir() == nullptr || std::strcmp(transcribe::debug::dump_dir(), dump_dir.c_str()) != 0) {
         std::fprintf(stderr, "FAIL: dump_dir() = \"%s\", expected \"%s\"\n",
-                     transcribe::debug::dump_dir() ?
-                       transcribe::debug::dump_dir() : "(null)",
-                     dump_dir.c_str());
+                     transcribe::debug::dump_dir() ? transcribe::debug::dump_dir() : "(null)", dump_dir.c_str());
         ++g_failures;
     }
 
@@ -140,13 +139,15 @@ int main() {
     // fast-to-slow ordering). On disk this should land as
     // numpy/row-major shape [5, 3]. The data is arange(0..15) so
     // expected min=0, max=14, mean=7.
-    ggml_init_params init {};
-    init.mem_size   = 4 * 1024 * 1024;
-    init.mem_buffer = nullptr;
-    init.no_alloc   = true;
+    ggml_init_params init{};
+    init.mem_size      = 4 * 1024 * 1024;
+    init.mem_buffer    = nullptr;
+    init.no_alloc      = true;
     ggml_context * ctx = ggml_init(init);
     CHECK(ctx != nullptr);
-    if (ctx == nullptr) return EXIT_FAILURE;
+    if (ctx == nullptr) {
+        return EXIT_FAILURE;
+    }
 
     ggml_tensor * t = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, 3, 5);
     CHECK(t != nullptr);
@@ -164,7 +165,9 @@ int main() {
     // to mutate or read.
     ggml_backend_t backend = ggml_backend_cpu_init();
     CHECK(backend != nullptr);
-    if (backend == nullptr) return EXIT_FAILURE;
+    if (backend == nullptr) {
+        return EXIT_FAILURE;
+    }
     ggml_backend_buffer_t buffer = ggml_backend_alloc_ctx_tensors(ctx, backend);
     CHECK(buffer != nullptr);
 
@@ -191,9 +194,7 @@ int main() {
             const float * f = reinterpret_cast<const float *>(bytes.data());
             for (int i = 0; i < 15; ++i) {
                 if (f[i] != src[i]) {
-                    std::fprintf(stderr,
-                                 "FAIL .f32[%d] = %f, expected %f\n",
-                                 i, f[i], src[i]);
+                    std::fprintf(stderr, "FAIL .f32[%d] = %f, expected %f\n", i, f[i], src[i]);
                     ++g_failures;
                 }
             }
diff --git a/tests/decoder_smoke.cpp b/tests/decoder_smoke.cpp
index d993ad80..5b038c98 100644
--- a/tests/decoder_smoke.cpp
+++ b/tests/decoder_smoke.cpp
@@ -34,7 +34,6 @@
 // on v3 rather than silently mis-validating.
 
 #include "transcribe.h"
-
 #include "wav.h"
 
 #include <sys/stat.h>
@@ -50,29 +49,26 @@ namespace {
 
 int g_failures = 0;
 
-#define CHECK(cond)                                                         \
-    do {                                                                    \
-        if (!(cond)) {                                                      \
-            std::fprintf(stderr, "FAIL %s:%d: %s\n",                        \
-                         __FILE__, __LINE__, #cond);                        \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK(cond)                                                              \
+    do {                                                                         \
+        if (!(cond)) {                                                           \
+            std::fprintf(stderr, "FAIL %s:%d: %s\n", __FILE__, __LINE__, #cond); \
+            ++g_failures;                                                        \
+        }                                                                        \
     } while (0)
 
-#define CHECK_EQ_INT(actual, expected)                                      \
-    do {                                                                    \
-        const long long _a = static_cast<long long>(actual);                \
-        const long long _e = static_cast<long long>(expected);              \
-        if (_a != _e) {                                                     \
-            std::fprintf(stderr,                                            \
-                         "FAIL %s:%d: %s = %lld, expected %lld\n",          \
-                         __FILE__, __LINE__, #actual, _a, _e);              \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK_EQ_INT(actual, expected)                                                                           \
+    do {                                                                                                         \
+        const long long _a = static_cast<long long>(actual);                                                     \
+        const long long _e = static_cast<long long>(expected);                                                   \
+        if (_a != _e) {                                                                                          \
+            std::fprintf(stderr, "FAIL %s:%d: %s = %lld, expected %lld\n", __FILE__, __LINE__, #actual, _a, _e); \
+            ++g_failures;                                                                                        \
+        }                                                                                                        \
     } while (0)
 
 bool file_exists(const std::string & path) {
-    struct stat st {};
+    struct stat st{};
     return ::stat(path.c_str(), &st) == 0;
 }
 
@@ -82,21 +78,24 @@ bool file_exists(const std::string & path) {
 // jfk.wav's reference text is ~110 characters so this is trivially
 // fast at the test gate.
 int edit_distance(const std::string & a, const std::string & b) {
-    const int n = static_cast<int>(a.size());
-    const int m = static_cast<int>(b.size());
+    const int        n = static_cast<int>(a.size());
+    const int        m = static_cast<int>(b.size());
     std::vector<int> prev(static_cast<size_t>(m + 1));
     std::vector<int> curr(static_cast<size_t>(m + 1));
-    for (int j = 0; j <= m; ++j) prev[static_cast<size_t>(j)] = j;
+    for (int j = 0; j <= m; ++j) {
+        prev[static_cast<size_t>(j)] = j;
+    }
     for (int i = 1; i <= n; ++i) {
         curr[0] = i;
         for (int j = 1; j <= m; ++j) {
-            const int cost = (a[static_cast<size_t>(i - 1)] ==
-                              b[static_cast<size_t>(j - 1)]) ? 0 : 1;
-            const int del = prev[static_cast<size_t>(j)]     + 1;
-            const int ins = curr[static_cast<size_t>(j - 1)] + 1;
-            const int sub = prev[static_cast<size_t>(j - 1)] + cost;
-            int best = del < ins ? del : ins;
-            if (sub < best) best = sub;
+            const int cost = (a[static_cast<size_t>(i - 1)] == b[static_cast<size_t>(j - 1)]) ? 0 : 1;
+            const int del  = prev[static_cast<size_t>(j)] + 1;
+            const int ins  = curr[static_cast<size_t>(j - 1)] + 1;
+            const int sub  = prev[static_cast<size_t>(j - 1)] + cost;
+            int       best = del < ins ? del : ins;
+            if (sub < best) {
+                best = sub;
+            }
             curr[static_cast<size_t>(j)] = best;
         }
         prev.swap(curr);
@@ -114,7 +113,7 @@ const char * const k_jfk_reference_text =
 
 constexpr int k_max_edit_distance = 3;
 
-} // namespace
+}  // namespace
 
 int main() {
     // ---- Resolve env -----------------------------------------------
@@ -126,28 +125,25 @@ int main() {
         return 77;
     }
     if (!file_exists(gguf_env)) {
-        std::fprintf(stderr,
-                     "decoder_smoke: gguf file not found: %s\n", gguf_env);
+        std::fprintf(stderr, "decoder_smoke: gguf file not found: %s\n", gguf_env);
         return 77;
     }
 
-    const std::string wav_path =
-        std::string(TRANSCRIBE_TEST_SAMPLES_DIR) + "/jfk.wav";
+    const std::string wav_path = std::string(TRANSCRIBE_TEST_SAMPLES_DIR) + "/jfk.wav";
     if (!file_exists(wav_path)) {
-        std::fprintf(stderr, "decoder_smoke: wav not found: %s\n",
-                     wav_path.c_str());
+        std::fprintf(stderr, "decoder_smoke: wav not found: %s\n", wav_path.c_str());
         return EXIT_FAILURE;
     }
 
     // ---- Load model ------------------------------------------------
-    transcribe_model_load_params mp; transcribe_model_load_params_init(&mp);
+    transcribe_model_load_params mp;
+    transcribe_model_load_params_init(&mp);
+
     struct transcribe_model * model = nullptr;
     {
-        const transcribe_status st =
-            transcribe_model_load_file(gguf_env, &mp, &model);
+        const transcribe_status st = transcribe_model_load_file(gguf_env, &mp, &model);
         if (st != TRANSCRIBE_OK || model == nullptr) {
-            std::fprintf(stderr, "decoder_smoke: load failed: %s\n",
-                         transcribe_status_string(st));
+            std::fprintf(stderr, "decoder_smoke: load failed: %s\n", transcribe_status_string(st));
             return EXIT_FAILURE;
         }
     }
@@ -160,7 +156,8 @@ int main() {
         if (variant != "tdt-0.6b-v2") {
             std::fprintf(stderr,
                          "decoder_smoke: golden is for tdt-0.6b-v2 only, "
-                         "got \"%s\"\n", variant.c_str());
+                         "got \"%s\"\n",
+                         variant.c_str());
             transcribe_model_free(model);
             return EXIT_FAILURE;
         }
@@ -171,23 +168,22 @@ int main() {
 
     // ---- Load wav --------------------------------------------------
     std::vector<float> pcm;
-    std::string load_err;
+    std::string        load_err;
     if (!transcribe_cli::load_wav_mono_16k(wav_path, pcm, load_err)) {
-        std::fprintf(stderr, "decoder_smoke: wav load: %s\n",
-                     load_err.c_str());
+        std::fprintf(stderr, "decoder_smoke: wav load: %s\n", load_err.c_str());
         transcribe_model_free(model);
         return EXIT_FAILURE;
     }
 
     // ---- Init context + run ----------------------------------------
-    transcribe_session_params cp; transcribe_session_params_init(&cp);
+    transcribe_session_params cp;
+    transcribe_session_params_init(&cp);
+
     struct transcribe_session * ctx = nullptr;
     {
-        const transcribe_status st =
-            transcribe_session_init(model, &cp, &ctx);
+        const transcribe_status st = transcribe_session_init(model, &cp, &ctx);
         if (st != TRANSCRIBE_OK || ctx == nullptr) {
-            std::fprintf(stderr, "decoder_smoke: ctx init: %s\n",
-                         transcribe_status_string(st));
+            std::fprintf(stderr, "decoder_smoke: ctx init: %s\n", transcribe_status_string(st));
             transcribe_model_free(model);
             return EXIT_FAILURE;
         }
@@ -198,19 +194,18 @@ int main() {
     // check this so a regression that pre-populates ghost results
     // before the first run is caught.
     CHECK_EQ_INT(transcribe_n_segments(ctx), 0);
-    CHECK_EQ_INT(transcribe_n_words(ctx),    0);
-    CHECK_EQ_INT(transcribe_n_tokens(ctx),   0);
+    CHECK_EQ_INT(transcribe_n_words(ctx), 0);
+    CHECK_EQ_INT(transcribe_n_tokens(ctx), 0);
     CHECK(std::strcmp(transcribe_full_text(ctx), "") == 0);
     CHECK(transcribe_returned_timestamp_kind(ctx) == TRANSCRIBE_TIMESTAMPS_NONE);
 
-    transcribe_run_params rp; transcribe_run_params_init(&rp);
+    transcribe_run_params rp;
+    transcribe_run_params_init(&rp);
     rp.timestamps = TRANSCRIBE_TIMESTAMPS_TOKEN;
     {
-        const transcribe_status st =
-            transcribe_run(ctx, pcm.data(), static_cast<int>(pcm.size()), &rp);
+        const transcribe_status st = transcribe_run(ctx, pcm.data(), static_cast<int>(pcm.size()), &rp);
         if (st != TRANSCRIBE_OK) {
-            std::fprintf(stderr, "decoder_smoke: run: %s\n",
-                         transcribe_status_string(st));
+            std::fprintf(stderr, "decoder_smoke: run: %s\n", transcribe_status_string(st));
             transcribe_session_free(ctx);
             transcribe_model_free(model);
             return EXIT_FAILURE;
@@ -224,13 +219,9 @@ int main() {
     std::fprintf(stdout, "decoder_smoke: text=\"%s\"\n", actual.c_str());
 
     const int dist = edit_distance(actual, k_jfk_reference_text);
-    std::fprintf(stdout,
-                 "decoder_smoke: edit_distance=%d (tolerance=%d)\n",
-                 dist, k_max_edit_distance);
+    std::fprintf(stdout, "decoder_smoke: edit_distance=%d (tolerance=%d)\n", dist, k_max_edit_distance);
     if (dist > k_max_edit_distance) {
-        std::fprintf(stderr,
-                     "FAIL: text edit distance %d exceeds %d\n",
-                     dist, k_max_edit_distance);
+        std::fprintf(stderr, "FAIL: text edit distance %d exceeds %d\n", dist, k_max_edit_distance);
         std::fprintf(stderr, "  reference: %s\n", k_jfk_reference_text);
         std::fprintf(stderr, "  actual:    %s\n", actual.c_str());
         ++g_failures;
@@ -242,10 +233,11 @@ int main() {
     const int n_tokens = transcribe_n_tokens(ctx);
     CHECK(n_tokens > 0);
 
-    int   prev_t0  = -1;
-    int   n_with_p = 0;
+    int prev_t0  = -1;
+    int n_with_p = 0;
     for (int i = 0; i < n_tokens; ++i) {
-        transcribe_token tok; transcribe_token_init(&tok);
+        transcribe_token tok;
+        transcribe_token_init(&tok);
         CHECK_EQ_INT(transcribe_get_token(ctx, i, &tok), TRANSCRIBE_OK);
 
         CHECK(tok.id >= 0);
@@ -256,7 +248,9 @@ int main() {
         CHECK_EQ_INT(tok.seg_index, 0);
         CHECK(tok.word_index >= 0);
         CHECK(tok.p >= 0.0f && tok.p <= 1.0001f && !std::isnan(tok.p));
-        if (tok.p > 0.0f) ++n_with_p;
+        if (tok.p > 0.0f) {
+            ++n_with_p;
+        }
         prev_t0 = static_cast<int>(tok.t0_ms);
     }
     // At least most tokens should carry a positive confidence (the
@@ -275,34 +269,31 @@ int main() {
     // order of ~20 words.
     CHECK(n_words >= 15 && n_words <= 30);
 
-    int last_word_t1 = -1;
+    int last_word_t1      = -1;
     int n_words_with_text = 0;
     for (int i = 0; i < n_words; ++i) {
-        transcribe_word wrd; transcribe_word_init(&wrd);
+        transcribe_word wrd;
+        transcribe_word_init(&wrd);
         CHECK_EQ_INT(transcribe_get_word(ctx, i, &wrd), TRANSCRIBE_OK);
 
         CHECK(wrd.text != nullptr);
-        if (wrd.text != nullptr && wrd.text[0] != '\0') ++n_words_with_text;
+        if (wrd.text != nullptr && wrd.text[0] != '\0') {
+            ++n_words_with_text;
+        }
         CHECK_EQ_INT(wrd.seg_index, 0);
         CHECK(wrd.first_token >= 0 && wrd.first_token < n_tokens);
         CHECK(wrd.n_tokens > 0 && wrd.first_token + wrd.n_tokens <= n_tokens);
         CHECK(wrd.t0_ms >= 0);
         CHECK(wrd.t1_ms >= wrd.t0_ms);
-        CHECK(wrd.t0_ms >= last_word_t1 - 200); // allow some inter-word slop
+        CHECK(wrd.t0_ms >= last_word_t1 - 200);  // allow some inter-word slop
         // No leading space on a word — the result builder strips it.
         if (wrd.text != nullptr && wrd.text[0] == ' ') {
-            std::fprintf(stderr,
-                         "FAIL: word %d has leading space: \"%s\"\n",
-                         i, wrd.text);
+            std::fprintf(stderr, "FAIL: word %d has leading space: \"%s\"\n", i, wrd.text);
             ++g_failures;
         }
         // No SentencePiece marker should leak into a word's text.
-        if (wrd.text != nullptr &&
-            std::strstr(wrd.text, k_sp_marker) != nullptr)
-        {
-            std::fprintf(stderr,
-                         "FAIL: word %d contains raw SP marker: \"%s\"\n",
-                         i, wrd.text);
+        if (wrd.text != nullptr && std::strstr(wrd.text, k_sp_marker) != nullptr) {
+            std::fprintf(stderr, "FAIL: word %d contains raw SP marker: \"%s\"\n", i, wrd.text);
             ++g_failures;
         }
         last_word_t1 = static_cast<int>(wrd.t1_ms);
@@ -313,48 +304,52 @@ int main() {
     const int n_segments = transcribe_n_segments(ctx);
     CHECK_EQ_INT(n_segments, 1);
 
-    transcribe_segment seg0; transcribe_segment_init(&seg0);
+    transcribe_segment seg0;
+    transcribe_segment_init(&seg0);
     CHECK_EQ_INT(transcribe_get_segment(ctx, 0, &seg0), TRANSCRIBE_OK);
 
     CHECK(seg0.text != nullptr);
     CHECK(seg0.text != nullptr && seg0.text[0] != '\0');
     CHECK(seg0.t0_ms >= 0);
     CHECK(seg0.t1_ms > seg0.t0_ms);
-    CHECK_EQ_INT(seg0.first_word,  0);
-    CHECK_EQ_INT(seg0.n_words,     n_words);
+    CHECK_EQ_INT(seg0.first_word, 0);
+    CHECK_EQ_INT(seg0.n_words, n_words);
     CHECK_EQ_INT(seg0.first_token, 0);
-    CHECK_EQ_INT(seg0.n_tokens,    n_tokens);
+    CHECK_EQ_INT(seg0.n_tokens, n_tokens);
     // Segment text should equal full_text.
     CHECK(seg0.text != nullptr && std::strcmp(seg0.text, full) == 0);
     // Segment time should span the audio.
-    CHECK(seg0.t1_ms <= 12000); // jfk.wav is ~11 s; allow 1 s slack
+    CHECK(seg0.t1_ms <= 12000);  // jfk.wav is ~11 s; allow 1 s slack
 
     // ---- Out-of-bounds accessors leave the caller's struct zero-init.
     {
-        transcribe_token oob; transcribe_token_init(&oob);
+        transcribe_token oob;
+        transcribe_token_init(&oob);
         CHECK_EQ_INT(transcribe_get_token(ctx, n_tokens, &oob), TRANSCRIBE_OK);
         CHECK(oob.text == nullptr);
         CHECK_EQ_INT(oob.id, 0);
         CHECK_EQ_INT(transcribe_get_token(ctx, -1, &oob), TRANSCRIBE_OK);
         CHECK(oob.text == nullptr);
 
-        transcribe_word oob_w; transcribe_word_init(&oob_w);
+        transcribe_word oob_w;
+        transcribe_word_init(&oob_w);
         CHECK_EQ_INT(transcribe_get_word(ctx, n_words, &oob_w), TRANSCRIBE_OK);
         CHECK_EQ_INT(oob_w.n_tokens, 0);
 
-        transcribe_segment oob_s; transcribe_segment_init(&oob_s);
+        transcribe_segment oob_s;
+        transcribe_segment_init(&oob_s);
         CHECK_EQ_INT(transcribe_get_segment(ctx, 5, &oob_s), TRANSCRIBE_OK);
         CHECK(oob_s.text == nullptr);
     }
 
     // ---- Timings ---------------------------------------------------
-    transcribe_timings t; transcribe_timings_init(&t);
+    transcribe_timings t;
+    transcribe_timings_init(&t);
     CHECK(transcribe_get_timings(ctx, &t) == TRANSCRIBE_OK);
-    std::fprintf(stdout,
-                 "decoder_smoke: timings load=%.2f mel=%.2f encode=%.2f decode=%.2f\n",
-                 t.load_ms, t.mel_ms, t.encode_ms, t.decode_ms);
-    CHECK(t.load_ms   > 0.0f);
-    CHECK(t.mel_ms    > 0.0f);
+    std::fprintf(stdout, "decoder_smoke: timings load=%.2f mel=%.2f encode=%.2f decode=%.2f\n", t.load_ms, t.mel_ms,
+                 t.encode_ms, t.decode_ms);
+    CHECK(t.load_ms > 0.0f);
+    CHECK(t.mel_ms > 0.0f);
     CHECK(t.encode_ms > 0.0f);
     CHECK(t.decode_ms > 0.0f);
 
@@ -366,17 +361,18 @@ int main() {
     // ceiling contract: the request is an upper bound, not an exact
     // match. The default run above already covered AUTO→TOKEN.
     {
-        transcribe_run_params rp2; transcribe_run_params_init(&rp2);
-        rp2.timestamps = TRANSCRIBE_TIMESTAMPS_WORD;
-        const transcribe_status st =
-            transcribe_run(ctx, pcm.data(), static_cast<int>(pcm.size()), &rp2);
+        transcribe_run_params rp2;
+        transcribe_run_params_init(&rp2);
+        rp2.timestamps             = TRANSCRIBE_TIMESTAMPS_WORD;
+        const transcribe_status st = transcribe_run(ctx, pcm.data(), static_cast<int>(pcm.size()), &rp2);
         CHECK(st == TRANSCRIBE_OK);
         CHECK(transcribe_returned_timestamp_kind(ctx) == TRANSCRIBE_TIMESTAMPS_WORD);
         // Word table still present with real timings.
         const int w_n_words = transcribe_n_words(ctx);
         CHECK(w_n_words > 0);
         if (w_n_words > 0) {
-            transcribe_word w0; transcribe_word_init(&w0);
+            transcribe_word w0;
+            transcribe_word_init(&w0);
             CHECK_EQ_INT(transcribe_get_word(ctx, 0, &w0), TRANSCRIBE_OK);
             CHECK(w0.t1_ms >= w0.t0_ms);
         }
@@ -386,53 +382,57 @@ int main() {
         // word_n_tokens cannot index into a cleared table.
         CHECK_EQ_INT(transcribe_n_tokens(ctx), 0);
         for (int i = 0; i < w_n_words; ++i) {
-            transcribe_word wi; transcribe_word_init(&wi);
+            transcribe_word wi;
+            transcribe_word_init(&wi);
             CHECK_EQ_INT(transcribe_get_word(ctx, i, &wi), TRANSCRIBE_OK);
             CHECK_EQ_INT(wi.first_token, 0);
-            CHECK_EQ_INT(wi.n_tokens,    0);
+            CHECK_EQ_INT(wi.n_tokens, 0);
         }
         // Segment's token back-references also zeroed.
         {
-            transcribe_segment s0; transcribe_segment_init(&s0);
+            transcribe_segment s0;
+            transcribe_segment_init(&s0);
             CHECK_EQ_INT(transcribe_get_segment(ctx, 0, &s0), TRANSCRIBE_OK);
             CHECK_EQ_INT(s0.first_token, 0);
-            CHECK_EQ_INT(s0.n_tokens,    0);
+            CHECK_EQ_INT(s0.n_tokens, 0);
         }
         // Full text still populated.
         const char * full2 = transcribe_full_text(ctx);
         CHECK(full2 != nullptr && full2[0] != '\0');
     }
     {
-        transcribe_run_params rp2; transcribe_run_params_init(&rp2);
-        rp2.timestamps = TRANSCRIBE_TIMESTAMPS_SEGMENT;
-        const transcribe_status st =
-            transcribe_run(ctx, pcm.data(), static_cast<int>(pcm.size()), &rp2);
+        transcribe_run_params rp2;
+        transcribe_run_params_init(&rp2);
+        rp2.timestamps             = TRANSCRIBE_TIMESTAMPS_SEGMENT;
+        const transcribe_status st = transcribe_run(ctx, pcm.data(), static_cast<int>(pcm.size()), &rp2);
         CHECK(st == TRANSCRIBE_OK);
         CHECK(transcribe_returned_timestamp_kind(ctx) == TRANSCRIBE_TIMESTAMPS_SEGMENT);
-        CHECK_EQ_INT(transcribe_n_words(ctx),  0);
+        CHECK_EQ_INT(transcribe_n_words(ctx), 0);
         CHECK_EQ_INT(transcribe_n_tokens(ctx), 0);
         CHECK_EQ_INT(transcribe_n_segments(ctx), 1);
         // Segment timings are still real at SEGMENT granularity.
         {
-            transcribe_segment s0; transcribe_segment_init(&s0);
+            transcribe_segment s0;
+            transcribe_segment_init(&s0);
             CHECK_EQ_INT(transcribe_get_segment(ctx, 0, &s0), TRANSCRIBE_OK);
             CHECK(s0.t1_ms > s0.t0_ms);
             CHECK(s0.text != nullptr && s0.text[0] != '\0');
         }
     }
     {
-        transcribe_run_params rp2; transcribe_run_params_init(&rp2);
-        rp2.timestamps = TRANSCRIBE_TIMESTAMPS_NONE;
-        const transcribe_status st =
-            transcribe_run(ctx, pcm.data(), static_cast<int>(pcm.size()), &rp2);
+        transcribe_run_params rp2;
+        transcribe_run_params_init(&rp2);
+        rp2.timestamps             = TRANSCRIBE_TIMESTAMPS_NONE;
+        const transcribe_status st = transcribe_run(ctx, pcm.data(), static_cast<int>(pcm.size()), &rp2);
         CHECK(st == TRANSCRIBE_OK);
         CHECK(transcribe_returned_timestamp_kind(ctx) == TRANSCRIBE_TIMESTAMPS_NONE);
-        CHECK_EQ_INT(transcribe_n_words(ctx),  0);
+        CHECK_EQ_INT(transcribe_n_words(ctx), 0);
         CHECK_EQ_INT(transcribe_n_tokens(ctx), 0);
         // Segment survives as the text carrier; its t0/t1 are zeroed.
         CHECK_EQ_INT(transcribe_n_segments(ctx), 1);
         {
-            transcribe_segment s0; transcribe_segment_init(&s0);
+            transcribe_segment s0;
+            transcribe_segment_init(&s0);
             CHECK_EQ_INT(transcribe_get_segment(ctx, 0, &s0), TRANSCRIBE_OK);
             CHECK_EQ_INT(s0.t0_ms, 0);
             CHECK_EQ_INT(s0.t1_ms, 0);
@@ -452,24 +452,23 @@ int main() {
     {
         // First, seed the context with a real successful run so
         // there is a previous result to clobber.
-        transcribe_run_params rp_ok; transcribe_run_params_init(&rp_ok);
-        rp_ok.timestamps = TRANSCRIBE_TIMESTAMPS_TOKEN;
-        const transcribe_status st_ok =
-            transcribe_run(ctx, pcm.data(), static_cast<int>(pcm.size()), &rp_ok);
+        transcribe_run_params rp_ok;
+        transcribe_run_params_init(&rp_ok);
+        rp_ok.timestamps              = TRANSCRIBE_TIMESTAMPS_TOKEN;
+        const transcribe_status st_ok = transcribe_run(ctx, pcm.data(), static_cast<int>(pcm.size()), &rp_ok);
         CHECK(st_ok == TRANSCRIBE_OK);
         CHECK(transcribe_n_tokens(ctx) > 0);
 
-        transcribe_run_params rp_bad; transcribe_run_params_init(&rp_bad);
-        rp_bad.timestamps =
-            static_cast<transcribe_timestamp_kind>(9999);
-        const transcribe_status st_bad =
-            transcribe_run(ctx, pcm.data(), static_cast<int>(pcm.size()), &rp_bad);
+        transcribe_run_params rp_bad;
+        transcribe_run_params_init(&rp_bad);
+        rp_bad.timestamps              = static_cast<transcribe_timestamp_kind>(9999);
+        const transcribe_status st_bad = transcribe_run(ctx, pcm.data(), static_cast<int>(pcm.size()), &rp_bad);
         CHECK(st_bad == TRANSCRIBE_ERR_INVALID_ARG);
         // All accessors return their safe sentinels.
         CHECK(std::strcmp(transcribe_full_text(ctx), "") == 0);
         CHECK_EQ_INT(transcribe_n_segments(ctx), 0);
-        CHECK_EQ_INT(transcribe_n_words(ctx),    0);
-        CHECK_EQ_INT(transcribe_n_tokens(ctx),   0);
+        CHECK_EQ_INT(transcribe_n_words(ctx), 0);
+        CHECK_EQ_INT(transcribe_n_tokens(ctx), 0);
         CHECK(transcribe_returned_timestamp_kind(ctx) == TRANSCRIBE_TIMESTAMPS_NONE);
     }
 
diff --git a/tests/loader_smoke.cpp b/tests/loader_smoke.cpp
index deb15216..a7912555 100644
--- a/tests/loader_smoke.cpp
+++ b/tests/loader_smoke.cpp
@@ -47,7 +47,7 @@
 #include <string>
 
 #ifndef TRANSCRIBE_TEST_FIXTURES_DIR
-#  error "TRANSCRIBE_TEST_FIXTURES_DIR must be defined by the build system"
+#    error "TRANSCRIBE_TEST_FIXTURES_DIR must be defined by the build system"
 #endif
 
 namespace {
@@ -56,17 +56,16 @@ const std::string g_fixtures_dir = TRANSCRIBE_TEST_FIXTURES_DIR;
 
 int g_failures = 0;
 
-#define CHECK(cond)                                                         \
-    do {                                                                    \
-        if (!(cond)) {                                                      \
-            std::fprintf(stderr, "FAIL %s:%d: %s\n",                        \
-                         __FILE__, __LINE__, #cond);                        \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK(cond)                                                              \
+    do {                                                                         \
+        if (!(cond)) {                                                           \
+            std::fprintf(stderr, "FAIL %s:%d: %s\n", __FILE__, __LINE__, #cond); \
+            ++g_failures;                                                        \
+        }                                                                        \
     } while (0)
 
 bool file_exists(const std::string & path) {
-    struct stat st {};
+    struct stat st{};
     return ::stat(path.c_str(), &st) == 0;
 }
 
@@ -76,19 +75,14 @@ bool file_exists(const std::string & path) {
 // regeneration hint instead of a confusing test failure.
 bool fixtures_present() {
     static const char * const required[] = {
-        "arch_parakeet.gguf",
-        "arch_sensevoice.gguf",
-        "arch_funasr_nano.gguf",
-        "arch_unknown.gguf",
-        "corrupt_magic.gguf",
+        "arch_parakeet.gguf", "arch_sensevoice.gguf", "arch_funasr_nano.gguf",
+        "arch_unknown.gguf",  "corrupt_magic.gguf",
     };
     bool ok = true;
     for (const char * name : required) {
         const std::string p = g_fixtures_dir + "/" + name;
         if (!file_exists(p)) {
-            std::fprintf(stderr,
-                         "loader_smoke: fixture not found: %s\n",
-                         p.c_str());
+            std::fprintf(stderr, "loader_smoke: fixture not found: %s\n", p.c_str());
             ok = false;
         }
     }
@@ -102,22 +96,19 @@ bool fixtures_present() {
     return ok;
 }
 
-void check_load(const char *      fixture_name,
-                transcribe_status expected) {
+void check_load(const char * fixture_name, transcribe_status expected) {
     const std::string p = g_fixtures_dir + "/" + fixture_name;
 
-    transcribe_model_load_params mp; transcribe_model_load_params_init(&mp);
+    transcribe_model_load_params mp;
+    transcribe_model_load_params_init(&mp);
     // Sentinel so we can verify the loader clears out_model on every
     // failure path, not just on success.
-    struct transcribe_model * m = (struct transcribe_model *)0xdeadbeef;
+    struct transcribe_model * m = (struct transcribe_model *) 0xdeadbeef;
 
     const transcribe_status st = transcribe_model_load_file(p.c_str(), &mp, &m);
 
     if (st != expected) {
-        std::fprintf(stderr,
-                     "FAIL %s: expected %s, got %s\n",
-                     fixture_name,
-                     transcribe_status_string(expected),
+        std::fprintf(stderr, "FAIL %s: expected %s, got %s\n", fixture_name, transcribe_status_string(expected),
                      transcribe_status_string(st));
         ++g_failures;
     }
@@ -127,9 +118,7 @@ void check_load(const char *      fixture_name,
     // exercise non-OK paths; the success path lives in
     // transcribe_tokenizer_smoke.
     if (m != nullptr) {
-        std::fprintf(stderr,
-                     "FAIL %s: out_model not cleared (got %p)\n",
-                     fixture_name, (void *)m);
+        std::fprintf(stderr, "FAIL %s: out_model not cleared (got %p)\n", fixture_name, (void *) m);
         ++g_failures;
     }
 }
@@ -139,16 +128,14 @@ void check_load(const char *      fixture_name,
 // from ERR_GGUF. The leading slash + sentinel-y name avoids any chance
 // of colliding with a real file the developer happens to have.
 void test_missing_path() {
-    transcribe_model_load_params mp; transcribe_model_load_params_init(&mp);
-    struct transcribe_model * m = (struct transcribe_model *)0xdeadbeef;
+    transcribe_model_load_params mp;
+    transcribe_model_load_params_init(&mp);
+    struct transcribe_model * m = (struct transcribe_model *) 0xdeadbeef;
 
-    const transcribe_status st = transcribe_model_load_file(
-        "/__transcribe_loader_smoke_missing__.gguf", &mp, &m);
+    const transcribe_status st = transcribe_model_load_file("/__transcribe_loader_smoke_missing__.gguf", &mp, &m);
 
     if (st != TRANSCRIBE_ERR_FILE_NOT_FOUND) {
-        std::fprintf(stderr,
-                     "FAIL missing-path: expected FILE_NOT_FOUND, got %s\n",
-                     transcribe_status_string(st));
+        std::fprintf(stderr, "FAIL missing-path: expected FILE_NOT_FOUND, got %s\n", transcribe_status_string(st));
         ++g_failures;
     }
     if (m != nullptr) {
@@ -163,16 +150,14 @@ void test_missing_path() {
 // TRANSCRIBE_ERR_GGUF means. We use the fixtures directory itself,
 // which is guaranteed to exist by the build dependency on `fixtures`.
 void test_directory_path() {
-    transcribe_model_load_params mp; transcribe_model_load_params_init(&mp);
-    struct transcribe_model * m = (struct transcribe_model *)0xdeadbeef;
+    transcribe_model_load_params mp;
+    transcribe_model_load_params_init(&mp);
+    struct transcribe_model * m = (struct transcribe_model *) 0xdeadbeef;
 
-    const transcribe_status st = transcribe_model_load_file(
-        g_fixtures_dir.c_str(), &mp, &m);
+    const transcribe_status st = transcribe_model_load_file(g_fixtures_dir.c_str(), &mp, &m);
 
     if (st != TRANSCRIBE_ERR_GGUF) {
-        std::fprintf(stderr,
-                     "FAIL directory-path: expected ERR_GGUF, got %s\n",
-                     transcribe_status_string(st));
+        std::fprintf(stderr, "FAIL directory-path: expected ERR_GGUF, got %s\n", transcribe_status_string(st));
         ++g_failures;
     }
     if (m != nullptr) {
@@ -181,14 +166,13 @@ void test_directory_path() {
     }
 }
 
-} // namespace
+}  // namespace
 
 int main() {
     test_missing_path();
 
     if (!fixtures_present()) {
-        std::fprintf(stderr,
-                     "loader_smoke: skipping fixture-dependent cases\n");
+        std::fprintf(stderr, "loader_smoke: skipping fixture-dependent cases\n");
         // 77 -> CTest "skipped" via SKIP_RETURN_CODE. This branch is a
         // backstop; the build dependency on `fixtures` should make sure
         // we never reach it under normal use.
@@ -201,15 +185,15 @@ int main() {
     // payload. The Parakeet handler now requires tokenizer.ggml.* and
     // surfaces the missing payload as TRANSCRIBE_ERR_GGUF — the loader
     // dispatched correctly, the family handler then rejected the file.
-    check_load("arch_parakeet.gguf",   TRANSCRIBE_ERR_GGUF);
+    check_load("arch_parakeet.gguf", TRANSCRIBE_ERR_GGUF);
     // Same shape for sensevoice / funasr_nano: the arch is in the
     // dispatch table, the handler runs, then rejects on the missing
     // hparam / tensor payload. Distinguishes "registered family but
     // bad GGUF" from "unknown architecture".
-    check_load("arch_sensevoice.gguf",  TRANSCRIBE_ERR_GGUF);
+    check_load("arch_sensevoice.gguf", TRANSCRIBE_ERR_GGUF);
     check_load("arch_funasr_nano.gguf", TRANSCRIBE_ERR_GGUF);
-    check_load("arch_unknown.gguf",    TRANSCRIBE_ERR_UNSUPPORTED_ARCH);
-    check_load("corrupt_magic.gguf",   TRANSCRIBE_ERR_GGUF);
+    check_load("arch_unknown.gguf", TRANSCRIBE_ERR_UNSUPPORTED_ARCH);
+    check_load("corrupt_magic.gguf", TRANSCRIBE_ERR_GGUF);
 
     if (g_failures > 0) {
         std::fprintf(stderr, "loader_smoke: %d failures\n", g_failures);
diff --git a/tests/log_unit.cpp b/tests/log_unit.cpp
index 6f5e82fe..22ea4070 100644
--- a/tests/log_unit.cpp
+++ b/tests/log_unit.cpp
@@ -17,11 +17,10 @@
 // The log sink is process-global state; this binary owns it exclusively,
 // and each test installs the state it needs.
 
+#include "ggml.h"
 #include "transcribe-log.h"
 #include "transcribe.h"
 
-#include "ggml.h"
-
 #include <cstdio>
 #include <cstdlib>
 #include <string>
@@ -32,13 +31,12 @@ namespace {
 
 int g_failures = 0;
 
-#define CHECK(cond)                                                         \
-    do {                                                                    \
-        if (!(cond)) {                                                      \
-            std::fprintf(stderr, "FAIL %s:%d: %s\n",                        \
-                         __FILE__, __LINE__, #cond);                        \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK(cond)                                                              \
+    do {                                                                         \
+        if (!(cond)) {                                                           \
+            std::fprintf(stderr, "FAIL %s:%d: %s\n", __FILE__, __LINE__, #cond); \
+            ++g_failures;                                                        \
+        }                                                                        \
     } while (0)
 
 // Recording sink. userdata carries the vector so the tests also pin that
@@ -85,8 +83,8 @@ void test_ggml_bridge_installed_and_maps_levels() {
     transcribe_log_set(recording_cb, &rec);
 
     // transcribe_log_set must have routed ggml's logger to its bridge.
-    ggml_log_callback bridge = nullptr;
-    void * bridge_userdata = nullptr;
+    ggml_log_callback bridge          = nullptr;
+    void *            bridge_userdata = nullptr;
     ggml_log_get(&bridge, &bridge_userdata);
     CHECK(bridge != nullptr);
     if (bridge == nullptr) {
@@ -98,10 +96,10 @@ void test_ggml_bridge_installed_and_maps_levels() {
     // INFO=1 WARN=2 ERROR=3 DEBUG=4): each ggml level must arrive as the
     // SAME-MEANING transcribe level, not the same number.
     bridge(GGML_LOG_LEVEL_DEBUG, "d\n", bridge_userdata);
-    bridge(GGML_LOG_LEVEL_INFO,  "i\n", bridge_userdata);
-    bridge(GGML_LOG_LEVEL_WARN,  "w\n", bridge_userdata);
+    bridge(GGML_LOG_LEVEL_INFO, "i\n", bridge_userdata);
+    bridge(GGML_LOG_LEVEL_WARN, "w\n", bridge_userdata);
     bridge(GGML_LOG_LEVEL_ERROR, "e\n", bridge_userdata);
-    bridge(GGML_LOG_LEVEL_CONT,  ".",   bridge_userdata);
+    bridge(GGML_LOG_LEVEL_CONT, ".", bridge_userdata);
 
     CHECK(rec.size() == 5);
     if (rec.size() == 5) {
@@ -147,8 +145,8 @@ void test_ggml_bridge_honors_disable() {
     Record rec;
     transcribe_log_set(recording_cb, &rec);
 
-    ggml_log_callback bridge = nullptr;
-    void * bridge_userdata = nullptr;
+    ggml_log_callback bridge          = nullptr;
+    void *            bridge_userdata = nullptr;
     ggml_log_get(&bridge, &bridge_userdata);
     CHECK(bridge != nullptr);
     if (bridge == nullptr) {
@@ -162,7 +160,7 @@ void test_ggml_bridge_honors_disable() {
     CHECK(rec.empty());
 }
 
-} // namespace
+}  // namespace
 
 int main() {
     test_callback_receives_log_msg();
diff --git a/tests/mel_unit.cpp b/tests/mel_unit.cpp
index 1514021b..4033c5fa 100644
--- a/tests/mel_unit.cpp
+++ b/tests/mel_unit.cpp
@@ -26,26 +26,24 @@ namespace {
 
 int g_failures = 0;
 
-#define CHECK(cond)                                                         \
-    do {                                                                    \
-        if (!(cond)) {                                                      \
-            std::fprintf(stderr, "FAIL %s:%d: %s\n",                        \
-                         __FILE__, __LINE__, #cond);                        \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK(cond)                                                              \
+    do {                                                                         \
+        if (!(cond)) {                                                           \
+            std::fprintf(stderr, "FAIL %s:%d: %s\n", __FILE__, __LINE__, #cond); \
+            ++g_failures;                                                        \
+        }                                                                        \
     } while (0)
 
-#define CHECK_NEAR(actual, expected, tol)                                   \
-    do {                                                                    \
-        const double _a = static_cast<double>(actual);                      \
-        const double _e = static_cast<double>(expected);                    \
-        const double _d = std::fabs(_a - _e);                               \
-        if (_d > (tol)) {                                                   \
-            std::fprintf(stderr,                                            \
-                "FAIL %s:%d: %s = %.17g, expected %.17g, diff %.6g > %.6g\n", \
-                __FILE__, __LINE__, #actual, _a, _e, _d, (tol));            \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK_NEAR(actual, expected, tol)                                                                          \
+    do {                                                                                                           \
+        const double _a = static_cast<double>(actual);                                                             \
+        const double _e = static_cast<double>(expected);                                                           \
+        const double _d = std::fabs(_a - _e);                                                                      \
+        if (_d > (tol)) {                                                                                          \
+            std::fprintf(stderr, "FAIL %s:%d: %s = %.17g, expected %.17g, diff %.6g > %.6g\n", __FILE__, __LINE__, \
+                         #actual, _a, _e, _d, (tol));                                                              \
+            ++g_failures;                                                                                          \
+        }                                                                                                          \
     } while (0)
 
 // Real Parakeet 0.6B frontend config (v2 + v3 share these values).
@@ -64,39 +62,45 @@ transcribe::MelConfig parakeet_config() {
 
 void test_window() {
     transcribe::MelFrontend mf(parakeet_config());
-    const auto & w = mf.window();
+    const auto &            w = mf.window();
 
     CHECK(w.size() == 512);
 
     // First and last 56 entries are the zero pad: (n_fft - win_length) / 2
     // on each side. The 57th entry from each end is the first non-zero
     // sample of the symmetric Hann.
-    for (int i = 0; i < 56; ++i) CHECK(w[i] == 0.0);
-    for (int i = 0; i < 56; ++i) CHECK(w[511 - i] == 0.0);
+    for (int i = 0; i < 56; ++i) {
+        CHECK(w[i] == 0.0);
+    }
+    for (int i = 0; i < 56; ++i) {
+        CHECK(w[511 - i] == 0.0);
+    }
 
     // Symmetric Hann formula 0.5 - 0.5*cos(2*pi*k/(N-1)) with N=400.
     // The boundary samples at the edge of the Hann are tiny but non-zero.
     // Reference values captured from numpy and librosa, machine-precision.
-    CHECK_NEAR(w[56], 0.0,                                  1e-15);
-    CHECK_NEAR(w[57], 6.199333200590518e-05,                1e-15);
-    CHECK_NEAR(w[58], 0.0002479579553307798,                1e-15);
-    CHECK_NEAR(w[59], 0.0005578477557081074,                1e-15);
-    CHECK_NEAR(w[60], 0.0009915858887327156,                1e-15);
+    CHECK_NEAR(w[56], 0.0, 1e-15);
+    CHECK_NEAR(w[57], 6.199333200590518e-05, 1e-15);
+    CHECK_NEAR(w[58], 0.0002479579553307798, 1e-15);
+    CHECK_NEAR(w[59], 0.0005578477557081074, 1e-15);
+    CHECK_NEAR(w[60], 0.0009915858887327156, 1e-15);
 
     // Peak region. For a symmetric N=400 Hann the peak straddles indices
     // 199 and 200 (in window space) = 255 and 256 in the padded buffer,
     // both equal to ~0.99998 (NOT 1.0 - that would be the periodic form).
-    CHECK_NEAR(w[254], 0.9998605186060137,                  1e-15);
-    CHECK_NEAR(w[255], 0.9999845014267927,                  1e-15);
-    CHECK_NEAR(w[256], 0.9999845014267927,                  1e-15);
-    CHECK_NEAR(w[257], 0.9998605186060137,                  1e-15);
-    CHECK_NEAR(w[258], 0.9996125837088883,                  1e-15);
+    CHECK_NEAR(w[254], 0.9998605186060137, 1e-15);
+    CHECK_NEAR(w[255], 0.9999845014267927, 1e-15);
+    CHECK_NEAR(w[256], 0.9999845014267927, 1e-15);
+    CHECK_NEAR(w[257], 0.9998605186060137, 1e-15);
+    CHECK_NEAR(w[258], 0.9996125837088883, 1e-15);
 
     // Sum of a symmetric Hann window of length 400 is exactly
     // (N - 1) / 2 = 199.5. Off by anything > a few ULPs means the
     // formula is wrong.
     double sum = 0.0;
-    for (double v : w) sum += v;
+    for (double v : w) {
+        sum += v;
+    }
     CHECK_NEAR(sum, 199.5, 1e-12);
 
     // Sum of squares: closed form for a symmetric Hann length N is
@@ -104,15 +108,17 @@ void test_window() {
     // librosa-style symmetric form (k / (N-1)) gives a slightly
     // different value; reference captured from numpy directly:
     double sumsq = 0.0;
-    for (double v : w) sumsq += v * v;
+    for (double v : w) {
+        sumsq += v * v;
+    }
     CHECK_NEAR(sumsq, 149.625, 1e-12);
 }
 
 void test_mel_filterbank() {
     transcribe::MelFrontend mf(parakeet_config());
-    const auto & fb = mf.filterbank();
-    const int n_freq = mf.n_freq();
-    const int n_mels = mf.num_mels();
+    const auto &            fb     = mf.filterbank();
+    const int               n_freq = mf.n_freq();
+    const int               n_mels = mf.num_mels();
 
     CHECK(static_cast<int>(fb.size()) == n_mels * n_freq);
     CHECK(n_freq == 257);
@@ -126,7 +132,9 @@ void test_mel_filterbank() {
     // exact (sr=16000, n_fft=512, n_mels=128, fmin=0, fmax=8000,
     // norm='slaney') call.
     double total = 0.0;
-    for (float v : fb) total += static_cast<double>(v);
+    for (float v : fb) {
+        total += static_cast<double>(v);
+    }
     CHECK_NEAR(total, 4.090487480163574, 5e-6);
 
     // Per-row spot checks. Slaney filters are sparse at low mel
@@ -143,8 +151,8 @@ void test_mel_filterbank() {
     }
 
     // Mel bin 5: triangular filter spanning fft bins 4 and 5.
-    CHECK_NEAR(get(5, 4),  0.014789481647312641, 5e-7);
-    CHECK_NEAR(get(5, 5),  0.013588061556220055, 5e-7);
+    CHECK_NEAR(get(5, 4), 0.014789481647312641, 5e-7);
+    CHECK_NEAR(get(5, 5), 0.013588061556220055, 5e-7);
     CHECK(get(5, 3) == 0.0f);
     CHECK(get(5, 6) == 0.0f);
 
@@ -160,16 +168,16 @@ void test_mel_filterbank() {
     // Per-row sums (Slaney area-normalized triangles, so each row's
     // sum is 2/(width) * triangle area = roughly constant per
     // octave; reference values from librosa).
-    double row_0_sum = 0.0;
-    double row_64_sum = 0.0;
+    double row_0_sum   = 0.0;
+    double row_64_sum  = 0.0;
     double row_127_sum = 0.0;
     for (int k = 0; k < n_freq; ++k) {
-        row_0_sum   += get(0, k);
-        row_64_sum  += get(64, k);
+        row_0_sum += get(0, k);
+        row_64_sum += get(64, k);
         row_127_sum += get(127, k);
     }
-    CHECK_NEAR(row_0_sum,   0.028377542272210, 5e-7);
-    CHECK_NEAR(row_64_sum,  0.030684133991599, 5e-6);
+    CHECK_NEAR(row_0_sum, 0.028377542272210, 5e-7);
+    CHECK_NEAR(row_64_sum, 0.030684133991599, 5e-6);
     CHECK_NEAR(row_127_sum, 0.031943686306477, 5e-6);
 
     // Total nonzero count: librosa Slaney with these params gives
@@ -177,7 +185,11 @@ void test_mel_filterbank() {
     // would either widen the filters (more nonzeros) or break the
     // mel scale (different distribution).
     int nonzero = 0;
-    for (float v : fb) if (v != 0.0f) ++nonzero;
+    for (float v : fb) {
+        if (v != 0.0f) {
+            ++nonzero;
+        }
+    }
     CHECK(nonzero == 504);
 }
 
@@ -192,7 +204,7 @@ void test_n_frames_for() {
     CHECK(mf.n_frames_for(0) == 1);
 }
 
-} // namespace
+}  // namespace
 
 int main() {
     test_window();
diff --git a/tests/moonshine_streaming_batch_truncation.cpp b/tests/moonshine_streaming_batch_truncation.cpp
index d5eed232..a2ff6078 100644
--- a/tests/moonshine_streaming_batch_truncation.cpp
+++ b/tests/moonshine_streaming_batch_truncation.cpp
@@ -18,7 +18,6 @@
 //     GGUF. If unset/missing (or a sample is missing), exits 77 ("skipped").
 
 #include "transcribe.h"
-
 #include "wav.h"
 
 #include <sys/stat.h>
@@ -32,29 +31,26 @@ namespace {
 
 int g_failures = 0;
 
-#define CHECK(cond)                                                         \
-    do {                                                                    \
-        if (!(cond)) {                                                      \
-            std::fprintf(stderr, "FAIL %s:%d: %s\n",                        \
-                         __FILE__, __LINE__, #cond);                        \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK(cond)                                                              \
+    do {                                                                         \
+        if (!(cond)) {                                                           \
+            std::fprintf(stderr, "FAIL %s:%d: %s\n", __FILE__, __LINE__, #cond); \
+            ++g_failures;                                                        \
+        }                                                                        \
     } while (0)
 
-#define CHECK_EQ_INT(actual, expected)                                      \
-    do {                                                                    \
-        const long long _a = static_cast<long long>(actual);                \
-        const long long _e = static_cast<long long>(expected);              \
-        if (_a != _e) {                                                     \
-            std::fprintf(stderr,                                            \
-                         "FAIL %s:%d: %s = %lld, expected %lld\n",          \
-                         __FILE__, __LINE__, #actual, _a, _e);              \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK_EQ_INT(actual, expected)                                                                           \
+    do {                                                                                                         \
+        const long long _a = static_cast<long long>(actual);                                                     \
+        const long long _e = static_cast<long long>(expected);                                                   \
+        if (_a != _e) {                                                                                          \
+            std::fprintf(stderr, "FAIL %s:%d: %s = %lld, expected %lld\n", __FILE__, __LINE__, #actual, _a, _e); \
+            ++g_failures;                                                                                        \
+        }                                                                                                        \
     } while (0)
 
 bool file_exists(const std::string & path) {
-    struct stat st {};
+    struct stat st{};
     return ::stat(path.c_str(), &st) == 0;
 }
 
@@ -72,7 +68,7 @@ bool load_sample(const std::string & name, std::vector<float> & pcm) {
     return true;
 }
 
-} // namespace
+}  // namespace
 
 int main() {
     const char * model_path = std::getenv("TRANSCRIBE_MOONSHINE_STREAMING_TINY_GGUF");
@@ -84,17 +80,23 @@ int main() {
     }
 
     std::vector<float> pcm_short, pcm_long;
-    if (!load_sample("jfk.wav", pcm_short)) return 77;
-    if (!load_sample("love-loss.wav", pcm_long)) return 77;
+    if (!load_sample("jfk.wav", pcm_short)) {
+        return 77;
+    }
+    if (!load_sample("love-loss.wav", pcm_long)) {
+        return 77;
+    }
 
-    transcribe_model_load_params mp; transcribe_model_load_params_init(&mp);
+    transcribe_model_load_params mp;
+    transcribe_model_load_params_init(&mp);
     struct transcribe_model * model = nullptr;
     if (transcribe_model_load_file(model_path, &mp, &model) != TRANSCRIBE_OK) {
         std::fprintf(stderr, "model load failed: %s\n", model_path);
         return 1;
     }
 
-    transcribe_session_params sp; transcribe_session_params_init(&sp);
+    transcribe_session_params sp;
+    transcribe_session_params_init(&sp);
     struct transcribe_session * s = nullptr;
     if (transcribe_session_init(model, &sp, &s) != TRANSCRIBE_OK) {
         std::fprintf(stderr, "session init failed\n");
@@ -126,8 +128,7 @@ int main() {
     transcribe_model_free(model);
 
     if (g_failures > 0) {
-        std::fprintf(stderr, "moonshine_streaming_batch_truncation: %d failures\n",
-                     g_failures);
+        std::fprintf(stderr, "moonshine_streaming_batch_truncation: %d failures\n", g_failures);
         return EXIT_FAILURE;
     }
     std::fprintf(stdout, "moonshine_streaming_batch_truncation: ok\n");
diff --git a/tests/moonshine_streaming_stream_parity.cpp b/tests/moonshine_streaming_stream_parity.cpp
index d793542f..b381e771 100644
--- a/tests/moonshine_streaming_stream_parity.cpp
+++ b/tests/moonshine_streaming_stream_parity.cpp
@@ -26,7 +26,6 @@
 
 #include "transcribe.h"
 #include "transcribe/moonshine_streaming.h"
-
 #include "wav.h"
 
 #include <sys/stat.h>
@@ -42,86 +41,77 @@ namespace {
 
 int g_failures = 0;
 
-#define CHECK(cond)                                                         \
-    do {                                                                    \
-        if (!(cond)) {                                                      \
-            std::fprintf(stderr, "FAIL %s:%d: %s\n",                        \
-                         __FILE__, __LINE__, #cond);                        \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK(cond)                                                              \
+    do {                                                                         \
+        if (!(cond)) {                                                           \
+            std::fprintf(stderr, "FAIL %s:%d: %s\n", __FILE__, __LINE__, #cond); \
+            ++g_failures;                                                        \
+        }                                                                        \
     } while (0)
 
 bool file_exists(const std::string & path) {
-    struct stat st {};
+    struct stat st{};
     return ::stat(path.c_str(), &st) == 0;
 }
 
-int run_one_shot(transcribe_session *      ctx,
-                 const std::vector<float> & pcm,
-                 std::string &              out_text)
-{
-    transcribe_run_params rp; transcribe_run_params_init(&rp);
-    const transcribe_status st = transcribe_run(
-        ctx, pcm.data(), static_cast<int>(pcm.size()), &rp);
+int run_one_shot(transcribe_session * ctx, const std::vector<float> & pcm, std::string & out_text) {
+    transcribe_run_params rp;
+    transcribe_run_params_init(&rp);
+    const transcribe_status st = transcribe_run(ctx, pcm.data(), static_cast<int>(pcm.size()), &rp);
     if (st != TRANSCRIBE_OK) {
-        std::fprintf(stderr,
-                     "one-shot transcribe_run failed: status=%d (%s)\n",
-                     static_cast<int>(st), transcribe_status_string(st));
+        std::fprintf(stderr, "one-shot transcribe_run failed: status=%d (%s)\n", static_cast<int>(st),
+                     transcribe_status_string(st));
         return 1;
     }
     const char * t = transcribe_full_text(ctx);
-    out_text = (t == nullptr) ? "" : t;
+    out_text       = (t == nullptr) ? "" : t;
     return 0;
 }
 
-int run_streaming(transcribe_session *      ctx,
+int run_streaming(transcribe_session *       ctx,
                   const std::vector<float> & pcm,
                   int                        chunk_samples,
                   int                        min_decode_interval_ms,
                   int *                      out_n_partial_updates,
-                  std::string &              out_text)
-{
-    transcribe_run_params rp; transcribe_run_params_init(&rp);
-    transcribe_stream_params sp; transcribe_stream_params_init(&sp);
+                  std::string &              out_text) {
+    transcribe_run_params rp;
+    transcribe_run_params_init(&rp);
+    transcribe_stream_params sp;
+    transcribe_stream_params_init(&sp);
     transcribe_moonshine_streaming_stream_ext ms;
     transcribe_moonshine_streaming_stream_ext_init(&ms);
     ms.min_decode_interval_ms = min_decode_interval_ms;
-    sp.family = &ms.ext;
-    transcribe_status st = transcribe_stream_begin(ctx, &rp, &sp);
+    sp.family                 = &ms.ext;
+    transcribe_status st      = transcribe_stream_begin(ctx, &rp, &sp);
     if (st != TRANSCRIBE_OK) {
-        std::fprintf(stderr,
-                     "stream_begin failed: status=%d (%s)\n",
-                     static_cast<int>(st), transcribe_status_string(st));
+        std::fprintf(stderr, "stream_begin failed: status=%d (%s)\n", static_cast<int>(st),
+                     transcribe_status_string(st));
         return 1;
     }
 
-    int feed_count           = 0;
-    int n_partial_updates    = 0;
-    size_t pos               = 0;
-    int    last_revision     = 0;
-    int    last_committed    = 0;
+    int         feed_count        = 0;
+    int         n_partial_updates = 0;
+    size_t      pos               = 0;
+    int         last_revision     = 0;
+    int         last_committed    = 0;
     std::string last_full;
     std::string last_committed_text;
     std::string last_tentative;
     while (pos < pcm.size()) {
-        const size_t take = std::min<size_t>(
-            static_cast<size_t>(chunk_samples), pcm.size() - pos);
-        transcribe_stream_update upd; transcribe_stream_update_init(&upd);
-        st = transcribe_stream_feed(ctx, pcm.data() + pos,
-                                    static_cast<int>(take), &upd);
+        const size_t             take = std::min<size_t>(static_cast<size_t>(chunk_samples), pcm.size() - pos);
+        transcribe_stream_update upd;
+        transcribe_stream_update_init(&upd);
+        st = transcribe_stream_feed(ctx, pcm.data() + pos, static_cast<int>(take), &upd);
         if (st != TRANSCRIBE_OK) {
-            std::fprintf(stderr,
-                         "stream_feed[%d] failed: status=%d (%s)\n",
-                         feed_count, static_cast<int>(st),
+            std::fprintf(stderr, "stream_feed[%d] failed: status=%d (%s)\n", feed_count, static_cast<int>(st),
                          transcribe_status_string(st));
             return 1;
         }
 
         // Revision is monotonic non-decreasing.
         if (upd.revision < last_revision) {
-            std::fprintf(stderr,
-                         "FAIL feed[%d] revision regressed (%d -> %d)\n",
-                         feed_count, last_revision, upd.revision);
+            std::fprintf(stderr, "FAIL feed[%d] revision regressed (%d -> %d)\n", feed_count, last_revision,
+                         upd.revision);
             ++g_failures;
         }
         // n_committed_tokens is monotonic non-decreasing.
@@ -129,8 +119,8 @@ int run_streaming(transcribe_session *      ctx,
         if (committed_now < last_committed) {
             std::fprintf(stderr,
                          "FAIL feed[%d] n_committed_tokens regressed "
-                         "(%d -> %d)\n", feed_count,
-                         last_committed, committed_now);
+                         "(%d -> %d)\n",
+                         feed_count, last_committed, committed_now);
             ++g_failures;
         }
         // When the family signals result_changed, at least one observable
@@ -139,29 +129,24 @@ int run_streaming(transcribe_session *      ctx,
         // tentative_text even when full_text is byte-identical, so check
         // the whole surface rather than full_text alone.
         if (upd.result_changed) {
-            transcribe_stream_text txt; transcribe_stream_text_init(&txt);
+            transcribe_stream_text txt;
+            transcribe_stream_text_init(&txt);
             if (transcribe_stream_get_text(ctx, &txt) != TRANSCRIBE_OK) {
                 std::fprintf(stderr,
                              "FAIL feed[%d] get_text failed after "
-                             "result_changed\n", feed_count);
+                             "result_changed\n",
+                             feed_count);
                 ++g_failures;
             } else {
-                const std::string full =
-                    (txt.full_text == nullptr) ? "" : txt.full_text;
-                const std::string committed =
-                    (txt.committed_text == nullptr) ? "" : txt.committed_text;
-                const std::string tentative =
-                    (txt.tentative_text == nullptr) ? "" : txt.tentative_text;
-                if (full == last_full &&
-                    committed == last_committed_text &&
-                    tentative == last_tentative)
-                {
+                const std::string full      = (txt.full_text == nullptr) ? "" : txt.full_text;
+                const std::string committed = (txt.committed_text == nullptr) ? "" : txt.committed_text;
+                const std::string tentative = (txt.tentative_text == nullptr) ? "" : txt.tentative_text;
+                if (full == last_full && committed == last_committed_text && tentative == last_tentative) {
                     std::fprintf(stderr,
                                  "FAIL feed[%d] result_changed=true but "
                                  "full/committed/tentative all unchanged "
                                  "(full='%s' committed='%s' tentative='%s')\n",
-                                 feed_count, full.c_str(),
-                                 committed.c_str(), tentative.c_str());
+                                 feed_count, full.c_str(), committed.c_str(), tentative.c_str());
                     ++g_failures;
                 }
                 last_full           = full;
@@ -177,29 +162,24 @@ int run_streaming(transcribe_session *      ctx,
         ++feed_count;
     }
 
-    transcribe_stream_update fin_upd; transcribe_stream_update_init(&fin_upd);
+    transcribe_stream_update fin_upd;
+    transcribe_stream_update_init(&fin_upd);
     st = transcribe_stream_finalize(ctx, &fin_upd);
     if (st != TRANSCRIBE_OK) {
-        std::fprintf(stderr,
-                     "stream_finalize failed: status=%d (%s)\n",
-                     static_cast<int>(st), transcribe_status_string(st));
+        std::fprintf(stderr, "stream_finalize failed: status=%d (%s)\n", static_cast<int>(st),
+                     transcribe_status_string(st));
         return 1;
     }
     CHECK(fin_upd.is_final);
     if (fin_upd.revision < last_revision) {
-        std::fprintf(stderr,
-                     "FAIL finalize revision regressed (%d -> %d)\n",
-                     last_revision, fin_upd.revision);
+        std::fprintf(stderr, "FAIL finalize revision regressed (%d -> %d)\n", last_revision, fin_upd.revision);
         ++g_failures;
     }
 
     // At finalize, the whole transcript is committed.
     const int n_tokens_final           = transcribe_n_tokens(ctx);
-    const int n_committed_tokens_final =
-        transcribe_stream_n_committed_tokens(ctx);
-    if (n_tokens_final > 0 &&
-        n_committed_tokens_final != n_tokens_final)
-    {
+    const int n_committed_tokens_final = transcribe_stream_n_committed_tokens(ctx);
+    if (n_tokens_final > 0 && n_committed_tokens_final != n_tokens_final) {
         std::fprintf(stderr,
                      "FAIL finalize: n_committed_tokens=%d != "
                      "n_tokens=%d\n",
@@ -208,14 +188,14 @@ int run_streaming(transcribe_session *      ctx,
     }
 
     const char * t = transcribe_full_text(ctx);
-    out_text = (t == nullptr) ? "" : t;
+    out_text       = (t == nullptr) ? "" : t;
     if (out_n_partial_updates != nullptr) {
         *out_n_partial_updates = n_partial_updates;
     }
     return 0;
 }
 
-} // namespace
+}  // namespace
 
 int main(int /*argc*/, char ** /*argv*/) {
     const char * model_path = std::getenv("TRANSCRIBE_MOONSHINE_STREAMING_TINY_GGUF");
@@ -226,8 +206,7 @@ int main(int /*argc*/, char ** /*argv*/) {
         return 77;
     }
 
-    const std::string sample_path =
-        std::string(TRANSCRIBE_TEST_SAMPLES_DIR) + "/jfk.wav";
+    const std::string sample_path = std::string(TRANSCRIBE_TEST_SAMPLES_DIR) + "/jfk.wav";
     if (!file_exists(sample_path)) {
         std::fprintf(stderr, "skipping: %s missing\n", sample_path.c_str());
         return 77;
@@ -236,17 +215,16 @@ int main(int /*argc*/, char ** /*argv*/) {
     std::vector<float> pcm;
     {
         std::string err;
-        if (!transcribe_cli::load_wav_mono_16k(sample_path, pcm, err) ||
-            pcm.empty())
-        {
-            std::fprintf(stderr, "failed to load %s: %s\n",
-                         sample_path.c_str(), err.c_str());
+        if (!transcribe_cli::load_wav_mono_16k(sample_path, pcm, err) || pcm.empty()) {
+            std::fprintf(stderr, "failed to load %s: %s\n", sample_path.c_str(), err.c_str());
             return 1;
         }
     }
 
-    transcribe_model_load_params mp; transcribe_model_load_params_init(&mp);
-    transcribe_session_params cp; transcribe_session_params_init(&cp);
+    transcribe_model_load_params mp;
+    transcribe_model_load_params_init(&mp);
+    transcribe_session_params cp;
+    transcribe_session_params_init(&cp);
 
     transcribe_model *   model = nullptr;
     transcribe_session * ctx   = nullptr;
@@ -263,7 +241,8 @@ int main(int /*argc*/, char ** /*argv*/) {
 
     // Capabilities sanity: streaming must be advertised via the gate.
     {
-        transcribe_capabilities caps; transcribe_capabilities_init(&caps);
+        transcribe_capabilities caps;
+        transcribe_capabilities_init(&caps);
         CHECK(transcribe_model_get_capabilities(model, &caps) == TRANSCRIBE_OK);
         CHECK(caps.supports_streaming);
     }
@@ -284,13 +263,11 @@ int main(int /*argc*/, char ** /*argv*/) {
     // = 0 means decode on every advance.
     const int chunk_ms_choices[] = { 1, 20, 40, 80, 160, 500, 1000 };
     for (int chunk_ms : chunk_ms_choices) {
-        const int chunk_samples = std::max(1, chunk_ms * 16000 / 1000);
+        const int   chunk_samples = std::max(1, chunk_ms * 16000 / 1000);
         std::string stream_text;
-        int        n_partial_updates = 0;
+        int         n_partial_updates = 0;
         if (run_streaming(ctx, pcm, chunk_samples,
-                          /*min_decode_interval_ms=*/0,
-                          &n_partial_updates, stream_text) != 0)
-        {
+                          /*min_decode_interval_ms=*/0, &n_partial_updates, stream_text) != 0) {
             ++g_failures;
             continue;
         }
@@ -302,8 +279,7 @@ int main(int /*argc*/, char ** /*argv*/) {
                          chunk_ms, ref_text.c_str(), stream_text.c_str());
             ++g_failures;
         } else {
-            std::fprintf(stdout, "ok  chunk_ms=%-5d  %s\n",
-                         chunk_ms, stream_text.c_str());
+            std::fprintf(stdout, "ok  chunk_ms=%-5d  %s\n", chunk_ms, stream_text.c_str());
         }
 
         // After finalize, transcribe_run on the same context should
@@ -336,31 +312,26 @@ int main(int /*argc*/, char ** /*argv*/) {
         const int chunk_samples = std::max(1, 20 * 16000 / 1000);
 
         std::string s_no_throttle;
-        int n_updates_no_throttle = 0;
+        int         n_updates_no_throttle = 0;
         if (run_streaming(ctx, pcm, chunk_samples,
-                          /*min_decode_interval_ms=*/0,
-                          &n_updates_no_throttle, s_no_throttle) != 0)
-        {
+                          /*min_decode_interval_ms=*/0, &n_updates_no_throttle, s_no_throttle) != 0) {
             ++g_failures;
         }
         CHECK(s_no_throttle == ref_text);
 
         std::string s_default_throttle;
-        int n_updates_default = 0;
+        int         n_updates_default = 0;
         if (run_streaming(ctx, pcm, chunk_samples,
-                          /*min_decode_interval_ms=*/-1, // family default 240
-                          &n_updates_default, s_default_throttle) != 0)
-        {
+                          /*min_decode_interval_ms=*/-1,  // family default 240
+                          &n_updates_default, s_default_throttle) != 0) {
             ++g_failures;
         }
         CHECK(s_default_throttle == ref_text);
 
         std::string s_long_throttle;
-        int n_updates_long = 0;
+        int         n_updates_long = 0;
         if (run_streaming(ctx, pcm, chunk_samples,
-                          /*min_decode_interval_ms=*/500,
-                          &n_updates_long, s_long_throttle) != 0)
-        {
+                          /*min_decode_interval_ms=*/500, &n_updates_long, s_long_throttle) != 0) {
             ++g_failures;
         }
         CHECK(s_long_throttle == ref_text);
@@ -391,7 +362,8 @@ int main(int /*argc*/, char ** /*argv*/) {
         if (n_updates_default < 20 || n_updates_default > 80) {
             std::fprintf(stderr,
                          "FAIL default-throttle update count out of expected "
-                         "20..80 range: %d\n", n_updates_default);
+                         "20..80 range: %d\n",
+                         n_updates_default);
             ++g_failures;
         }
     }
diff --git a/tests/parakeet_chunked_limited_with_rc_mask_unit.cpp b/tests/parakeet_chunked_limited_with_rc_mask_unit.cpp
index 36e30fb9..baccff89 100644
--- a/tests/parakeet_chunked_limited_with_rc_mask_unit.cpp
+++ b/tests/parakeet_chunked_limited_with_rc_mask_unit.cpp
@@ -26,13 +26,12 @@ namespace {
 
 int g_failures = 0;
 
-#define CHECK(cond)                                                         \
-    do {                                                                    \
-        if (!(cond)) {                                                      \
-            std::fprintf(stderr, "FAIL %s:%d: %s\n",                        \
-                         __FILE__, __LINE__, #cond);                        \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK(cond)                                                              \
+    do {                                                                         \
+        if (!(cond)) {                                                           \
+            std::fprintf(stderr, "FAIL %s:%d: %s\n", __FILE__, __LINE__, #cond); \
+            ++g_failures;                                                        \
+        }                                                                        \
     } while (0)
 
 // Reference implementation mirroring NeMo's _create_masks branch for
@@ -40,18 +39,17 @@ int g_failures = 0;
 // where true = "allowed to attend".
 std::vector<bool> reference_mask(int T, int L, int C, int R, int P) {
     std::vector<bool> mask(static_cast<size_t>(T) * static_cast<size_t>(T), false);
-    const int pad = P > T ? T : P;
+    const int         pad = P > T ? T : P;
     for (int q = 0; q < T; ++q) {
-        const int c_q          = q / C;
-        const int ws_unclamped = c_q * C - L;
-        const int we_unclamped = c_q * C + C - 1 + R;
-        const int ws = ws_unclamped > 0 ? ws_unclamped : 0;
-        const int we = we_unclamped < (T - 1) ? we_unclamped : (T - 1);
-        const bool q_padded = q >= pad;
+        const int  c_q          = q / C;
+        const int  ws_unclamped = c_q * C - L;
+        const int  we_unclamped = c_q * C + C - 1 + R;
+        const int  ws           = ws_unclamped > 0 ? ws_unclamped : 0;
+        const int  we           = we_unclamped < (T - 1) ? we_unclamped : (T - 1);
+        const bool q_padded     = q >= pad;
         for (int k = 0; k < T; ++k) {
-            const bool k_padded = k >= pad;
-            mask[static_cast<size_t>(q) * T + k] =
-                (k >= ws && k <= we) && !q_padded && !k_padded;
+            const bool k_padded                  = k >= pad;
+            mask[static_cast<size_t>(q) * T + k] = (k >= ws && k <= we) && !q_padded && !k_padded;
         }
     }
     return mask;
@@ -59,26 +57,23 @@ std::vector<bool> reference_mask(int T, int L, int C, int R, int P) {
 
 void run_case(const char * name, int T, int L, int C, int R, int P = INT_MAX) {
     std::vector<float> got(static_cast<size_t>(T) * static_cast<size_t>(T));
-    transcribe::parakeet::compute_chunked_limited_with_rc_mask(
-        got.data(), T, L, C, R, P);
+    transcribe::parakeet::compute_chunked_limited_with_rc_mask(got.data(), T, L, C, R, P);
 
     const std::vector<bool> ref = reference_mask(T, L, C, R, P);
 
     int mismatches = 0;
     for (size_t i = 0; i < got.size(); ++i) {
-        const bool   allowed_ref = ref[i];
-        const float  cell        = got[i];
-        const bool   allowed_got = (cell == 0.0f);
-        const bool   masked_got  = std::isinf(cell) && cell < 0.0f;
-        const bool   well_formed = allowed_got || masked_got;
+        const bool  allowed_ref = ref[i];
+        const float cell        = got[i];
+        const bool  allowed_got = (cell == 0.0f);
+        const bool  masked_got  = std::isinf(cell) && cell < 0.0f;
+        const bool  well_formed = allowed_got || masked_got;
         if (!well_formed) {
             ++mismatches;
             if (mismatches <= 4) {
                 const int q = static_cast<int>(i / T);
                 const int k = static_cast<int>(i % T);
-                std::fprintf(stderr,
-                             "  [%s] mask[%d, %d] = %f (expected 0.0 or -INF)\n",
-                             name, q, k, cell);
+                std::fprintf(stderr, "  [%s] mask[%d, %d] = %f (expected 0.0 or -INF)\n", name, q, k, cell);
             }
             continue;
         }
@@ -87,25 +82,20 @@ void run_case(const char * name, int T, int L, int C, int R, int P = INT_MAX) {
             if (mismatches <= 4) {
                 const int q = static_cast<int>(i / T);
                 const int k = static_cast<int>(i % T);
-                std::fprintf(stderr,
-                             "  [%s] mask[%d, %d] = %s but ref says %s\n",
-                             name, q, k,
-                             allowed_got ? "0.0 (allowed)" : "-INF (masked)",
-                             allowed_ref ? "allowed" : "masked");
+                std::fprintf(stderr, "  [%s] mask[%d, %d] = %s but ref says %s\n", name, q, k,
+                             allowed_got ? "0.0 (allowed)" : "-INF (masked)", allowed_ref ? "allowed" : "masked");
             }
         }
     }
     if (mismatches == 0) {
         std::fprintf(stderr, "  [%s] OK T=%d L=%d C=%d R=%d\n", name, T, L, C, R);
     } else {
-        std::fprintf(stderr,
-                     "  [%s] FAIL T=%d L=%d C=%d R=%d — %d mismatching cells\n",
-                     name, T, L, C, R, mismatches);
+        std::fprintf(stderr, "  [%s] FAIL T=%d L=%d C=%d R=%d — %d mismatching cells\n", name, T, L, C, R, mismatches);
         ++g_failures;
     }
 }
 
-} // namespace
+}  // namespace
 
 int main() {
     // Parakeet-unified-en-0.6b's full training menu (frames at 80ms).
@@ -114,23 +104,23 @@ int main() {
     // (70, 13, 13), the fastest (70, 1, 0), and a mid-tier
     // (70, 7, 7). T values cover both "smaller than a chunk" and
     // "many chunks" regimes.
-    run_case("default-1.04s",        256, /*L=*/70, /*C=*/13, /*R=*/13);
-    run_case("default-1.04s-small",   10, /*L=*/70, /*C=*/13, /*R=*/13); // T < C: single chunk, hits clamps
-    run_case("fastest-80ms",    256, 70,  1,  0);
+    run_case("default-1.04s", 256, /*L=*/70, /*C=*/13, /*R=*/13);
+    run_case("default-1.04s-small", 10, /*L=*/70, /*C=*/13, /*R=*/13);  // T < C: single chunk, hits clamps
+    run_case("fastest-80ms", 256, 70, 1, 0);
     // R=1 specifically: the WER sweep showed (70,1,1) is a divergence
     // outlier vs the rest of the menu, so cover it explicitly.
-    run_case("low-lat-160ms",   256, 70,  1,  1);
-    run_case("low-lat-320ms",   256, 70,  2,  2);
-    run_case("midtier-560ms",   256, 70,  7,  7);
+    run_case("low-lat-160ms", 256, 70, 1, 1);
+    run_case("low-lat-320ms", 256, 70, 2, 2);
+    run_case("midtier-560ms", 256, 70, 7, 7);
 
     // L=0, R=0, C=1 — strictly diagonal (each frame sees only itself).
-    run_case("strictly-diag",    16,  0,  1,  0);
+    run_case("strictly-diag", 16, 0, 1, 0);
 
     // L=T-1, R=T-1 — full attention (every (q, k) allowed).
-    run_case("full-attention",   32, 31,  4, 31);
+    run_case("full-attention", 32, 31, 4, 31);
 
     // Edge: chunk straddles the end of T. Make sure clamping works.
-    run_case("ragged-tail",      11, 70,  4,  4);
+    run_case("ragged-tail", 11, 70, 4, 4);
 
     // Pad-mask: conv-overhang case. T_enc = 35 frames produced, but
     // effective_T = 34 (one trailing frame is conv padding overhang).
@@ -138,9 +128,9 @@ int main() {
     // row -INF) and as a key (whole column -INF). Mirrors NeMo's
     // pad_mask AND chunked_mask. Critical at low-C/low-R configs
     // where the leak tips greedy decisions.
-    run_case("pad-overhang-low-lat",  35, 70,  1,  1, /*P=*/34);
-    run_case("pad-overhang-default",  72, 70, 13, 13, /*P=*/72);  // no pad
-    run_case("pad-zero",               5, 70,  1,  0, /*P=*/0);   // all masked
+    run_case("pad-overhang-low-lat", 35, 70, 1, 1, /*P=*/34);
+    run_case("pad-overhang-default", 72, 70, 13, 13, /*P=*/72);  // no pad
+    run_case("pad-zero", 5, 70, 1, 0, /*P=*/0);                  // all masked
 
     if (g_failures > 0) {
         std::fprintf(stderr, "FAILED: %d cases\n", g_failures);
diff --git a/tests/parakeet_real_smoke.cpp b/tests/parakeet_real_smoke.cpp
index d2a351a8..141b8b1c 100644
--- a/tests/parakeet_real_smoke.cpp
+++ b/tests/parakeet_real_smoke.cpp
@@ -51,13 +51,11 @@
 // real value of THIS test is #7-#9, which only exist for the real
 // 0.6B dimensions.
 
-#include "transcribe.h"
-
 #include "arch/parakeet/parakeet.h"
 #include "arch/parakeet/weights.h"
-#include "transcribe-model.h"
-
 #include "ggml.h"
+#include "transcribe-model.h"
+#include "transcribe.h"
 
 #include <sys/stat.h>
 
@@ -70,51 +68,44 @@ namespace {
 
 int g_failures = 0;
 
-#define CHECK(cond)                                                         \
-    do {                                                                    \
-        if (!(cond)) {                                                      \
-            std::fprintf(stderr, "FAIL %s:%d: %s\n",                        \
-                         __FILE__, __LINE__, #cond);                        \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK(cond)                                                              \
+    do {                                                                         \
+        if (!(cond)) {                                                           \
+            std::fprintf(stderr, "FAIL %s:%d: %s\n", __FILE__, __LINE__, #cond); \
+            ++g_failures;                                                        \
+        }                                                                        \
     } while (0)
 
-#define CHECK_EQ_INT(actual, expected)                                      \
-    do {                                                                    \
-        const long long _a = static_cast<long long>(actual);                \
-        const long long _e = static_cast<long long>(expected);              \
-        if (_a != _e) {                                                     \
-            std::fprintf(stderr,                                            \
-                         "FAIL %s:%d: %s = %lld, expected %lld\n",          \
-                         __FILE__, __LINE__, #actual, _a, _e);              \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK_EQ_INT(actual, expected)                                                                           \
+    do {                                                                                                         \
+        const long long _a = static_cast<long long>(actual);                                                     \
+        const long long _e = static_cast<long long>(expected);                                                   \
+        if (_a != _e) {                                                                                          \
+            std::fprintf(stderr, "FAIL %s:%d: %s = %lld, expected %lld\n", __FILE__, __LINE__, #actual, _a, _e); \
+            ++g_failures;                                                                                        \
+        }                                                                                                        \
     } while (0)
 
-#define CHECK_STR_EQ(a, b)                                                  \
-    do {                                                                    \
-        const std::string _av = (a);                                        \
-        const std::string _bv = (b);                                        \
-        if (_av != _bv) {                                                   \
-            std::fprintf(stderr,                                            \
-                         "FAIL %s:%d: \"%s\" != \"%s\"\n",                  \
-                         __FILE__, __LINE__,                                \
-                         _av.c_str(), _bv.c_str());                         \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK_STR_EQ(a, b)                                                                                        \
+    do {                                                                                                          \
+        const std::string _av = (a);                                                                              \
+        const std::string _bv = (b);                                                                              \
+        if (_av != _bv) {                                                                                         \
+            std::fprintf(stderr, "FAIL %s:%d: \"%s\" != \"%s\"\n", __FILE__, __LINE__, _av.c_str(), _bv.c_str()); \
+            ++g_failures;                                                                                         \
+        }                                                                                                         \
     } while (0)
 
 bool file_exists(const std::string & path) {
-    struct stat st {};
+    struct stat st{};
     return ::stat(path.c_str(), &st) == 0;
 }
 
-const transcribe::parakeet::ParakeetModel *
-parakeet_view(const struct transcribe_model * m) {
+const transcribe::parakeet::ParakeetModel * parakeet_view(const struct transcribe_model * m) {
     return static_cast<const transcribe::parakeet::ParakeetModel *>(m);
 }
 
-} // namespace
+}  // namespace
 
 int main() {
     const char * env = std::getenv("TRANSCRIBE_PARAKEET_GGUF");
@@ -130,21 +121,17 @@ int main() {
     const std::string fixture = env;
 
     if (!file_exists(fixture)) {
-        std::fprintf(stderr,
-                     "parakeet_real_smoke: file not found: %s\n",
-                     fixture.c_str());
+        std::fprintf(stderr, "parakeet_real_smoke: file not found: %s\n", fixture.c_str());
         return 77;
     }
 
-    transcribe_model_load_params mp; transcribe_model_load_params_init(&mp);
+    transcribe_model_load_params mp;
+    transcribe_model_load_params_init(&mp);
     struct transcribe_model * model = nullptr;
 
-    const transcribe_status st =
-        transcribe_model_load_file(fixture.c_str(), &mp, &model);
+    const transcribe_status st = transcribe_model_load_file(fixture.c_str(), &mp, &model);
     if (st != TRANSCRIBE_OK) {
-        std::fprintf(stderr,
-                     "FAIL load: expected OK, got %s\n",
-                     transcribe_status_string(st));
+        std::fprintf(stderr, "FAIL load: expected OK, got %s\n", transcribe_status_string(st));
         return EXIT_FAILURE;
     }
     if (model == nullptr) {
@@ -160,8 +147,7 @@ int main() {
     {
         const std::string backend = transcribe_model_backend(model);
         if (backend.empty()) {
-            std::fprintf(stderr,
-                         "FAIL: backend = \"\" after step 1, expected non-empty\n");
+            std::fprintf(stderr, "FAIL: backend = \"\" after step 1, expected non-empty\n");
             ++g_failures;
         }
     }
@@ -169,19 +155,18 @@ int main() {
     // Variant must be one of the two the converter produces. Capture
     // which one for the variant-dependent assertions below.
     const std::string variant = transcribe_model_variant_string(model);
-    const bool is_v2 = (variant == "tdt-0.6b-v2");
-    const bool is_v3 = (variant == "tdt-0.6b-v3");
+    const bool        is_v2   = (variant == "tdt-0.6b-v2");
+    const bool        is_v3   = (variant == "tdt-0.6b-v3");
     if (!is_v2 && !is_v3) {
-        std::fprintf(stderr,
-                     "FAIL: unexpected variant \"%s\"\n", variant.c_str());
+        std::fprintf(stderr, "FAIL: unexpected variant \"%s\"\n", variant.c_str());
         ++g_failures;
     }
 
     // Family invariants.
-    transcribe_capabilities caps_buf; transcribe_capabilities_init(&caps_buf);
-    const bool caps_ok =
-        transcribe_model_get_capabilities(model, &caps_buf) == TRANSCRIBE_OK;
-    const transcribe_capabilities * caps = caps_ok ? &caps_buf : nullptr;
+    transcribe_capabilities caps_buf;
+    transcribe_capabilities_init(&caps_buf);
+    const bool                      caps_ok = transcribe_model_get_capabilities(model, &caps_buf) == TRANSCRIBE_OK;
+    const transcribe_capabilities * caps    = caps_ok ? &caps_buf : nullptr;
     CHECK(caps != nullptr);
     if (caps != nullptr) {
         CHECK(caps->native_sample_rate == 16000);
@@ -218,28 +203,28 @@ int main() {
     // (v2 and v3) shares these encoder / predictor / joint dims —
     // only the vocab size differs.
     const auto & hp = pm->hparams;
-    CHECK_EQ_INT(hp.enc_n_layers,             24);
-    CHECK_EQ_INT(hp.enc_d_model,              1024);
-    CHECK_EQ_INT(hp.enc_n_heads,              8);
-    CHECK_EQ_INT(hp.enc_d_ff,                 4096);
-    CHECK_EQ_INT(hp.enc_conv_kernel,          9);
-    CHECK_EQ_INT(hp.enc_subsampling_factor,   8);
+    CHECK_EQ_INT(hp.enc_n_layers, 24);
+    CHECK_EQ_INT(hp.enc_d_model, 1024);
+    CHECK_EQ_INT(hp.enc_n_heads, 8);
+    CHECK_EQ_INT(hp.enc_d_ff, 4096);
+    CHECK_EQ_INT(hp.enc_conv_kernel, 9);
+    CHECK_EQ_INT(hp.enc_subsampling_factor, 8);
     CHECK_EQ_INT(hp.enc_subsampling_channels, 256);
-    CHECK_EQ_INT(hp.enc_use_bias,             0);
-    CHECK_EQ_INT(hp.enc_head_dim(),           128); // 1024 / 8
-    CHECK_EQ_INT(hp.pred_hidden,              640);
-    CHECK_EQ_INT(hp.pred_n_layers,            2);
+    CHECK_EQ_INT(hp.enc_use_bias, 0);
+    CHECK_EQ_INT(hp.enc_head_dim(), 128);  // 1024 / 8
+    CHECK_EQ_INT(hp.pred_hidden, 640);
+    CHECK_EQ_INT(hp.pred_n_layers, 2);
     if (is_v2) {
-        CHECK_EQ_INT(hp.pred_vocab,           1025); // 1024 + 1 start row
-        CHECK_EQ_INT(hp.joint_n_classes(),    1030); // 1024 + 5 + 1
+        CHECK_EQ_INT(hp.pred_vocab, 1025);         // 1024 + 1 start row
+        CHECK_EQ_INT(hp.joint_n_classes(), 1030);  // 1024 + 5 + 1
     }
     if (is_v3) {
-        CHECK_EQ_INT(hp.pred_vocab,           8193); // 8192 + 1 start row
-        CHECK_EQ_INT(hp.joint_n_classes(),    8198); // 8192 + 5 + 1
+        CHECK_EQ_INT(hp.pred_vocab, 8193);         // 8192 + 1 start row
+        CHECK_EQ_INT(hp.joint_n_classes(), 8198);  // 8192 + 5 + 1
     }
-    CHECK_EQ_INT(hp.joint_hidden,             640);
-    CHECK_EQ_INT(hp.joint_num_extra_outputs,  5);
-    CHECK_STR_EQ(hp.joint_activation,         "relu");
+    CHECK_EQ_INT(hp.joint_hidden, 640);
+    CHECK_EQ_INT(hp.joint_num_extra_outputs, 5);
+    CHECK_STR_EQ(hp.joint_activation, "relu");
     // TDT durations: every published Parakeet 0.6B variant ships
     // [0, 1, 2, 3, 4]; loader cross-validates that the array length
     // matches num_extra_outputs.
@@ -249,19 +234,19 @@ int main() {
     CHECK_EQ_INT(hp.tdt_durations[2], 2);
     CHECK_EQ_INT(hp.tdt_durations[3], 3);
     CHECK_EQ_INT(hp.tdt_durations[4], 4);
-    CHECK_EQ_INT(hp.tdt_max_symbols,          10);
-    CHECK_EQ_INT(hp.fe_num_mels,              128);
-    CHECK_EQ_INT(hp.fe_sample_rate,           16000);
-    CHECK_STR_EQ(hp.fe_type,                  "mel");
-    CHECK_EQ_INT(hp.fe_n_fft,                 512);
-    CHECK_EQ_INT(hp.fe_win_length,            400);  // 0.025 s * 16000
-    CHECK_EQ_INT(hp.fe_hop_length,            160);  // 0.010 s * 16000
-    CHECK_STR_EQ(hp.fe_window,                "hann");
-    CHECK_STR_EQ(hp.fe_normalize,             "per_feature");
-    CHECK(hp.fe_dither       == 1e-5f);
+    CHECK_EQ_INT(hp.tdt_max_symbols, 10);
+    CHECK_EQ_INT(hp.fe_num_mels, 128);
+    CHECK_EQ_INT(hp.fe_sample_rate, 16000);
+    CHECK_STR_EQ(hp.fe_type, "mel");
+    CHECK_EQ_INT(hp.fe_n_fft, 512);
+    CHECK_EQ_INT(hp.fe_win_length, 400);  // 0.025 s * 16000
+    CHECK_EQ_INT(hp.fe_hop_length, 160);  // 0.010 s * 16000
+    CHECK_STR_EQ(hp.fe_window, "hann");
+    CHECK_STR_EQ(hp.fe_normalize, "per_feature");
+    CHECK(hp.fe_dither == 1e-5f);
     CHECK(hp.fe_pre_emphasis == 0.97f);
-    CHECK(hp.fe_f_min        == 0.0f);
-    CHECK(hp.fe_f_max        == 8000.0f);
+    CHECK(hp.fe_f_min == 0.0f);
+    CHECK(hp.fe_f_max == 8000.0f);
 
     // Block count matches the loader's read of enc_n_layers.
     CHECK_EQ_INT(pm->weights.blocks.size(), 24);
@@ -270,7 +255,7 @@ int main() {
     // (predictor: embed + 2*(Wx, Wh, bias)) + 6 (joint) = 697.
     {
         const int total = 12 + 24 * 28 + 7 + 6;
-        CHECK_EQ_INT(total, 697); // sanity on the formula itself
+        CHECK_EQ_INT(total, 697);  // sanity on the formula itself
     }
 
     // Spot-check a handful of tensor shapes against the per-block
@@ -300,16 +285,16 @@ int main() {
         const auto * t = pm->weights.predictor.embed_w;
         CHECK(t != nullptr);
         if (t != nullptr) {
-            CHECK_EQ_INT(t->ne[0], 640);                  // pred_hidden
-            CHECK_EQ_INT(t->ne[1], hp.pred_vocab);        // 1025 or 8193
+            CHECK_EQ_INT(t->ne[0], 640);            // pred_hidden
+            CHECK_EQ_INT(t->ne[1], hp.pred_vocab);  // 1025 or 8193
         }
     }
     {
         const auto * t = pm->weights.joint.out_w;
         CHECK(t != nullptr);
         if (t != nullptr) {
-            CHECK_EQ_INT(t->ne[0], 640);                  // joint_hidden
-            CHECK_EQ_INT(t->ne[1], hp.joint_n_classes()); // 1030 or 8198
+            CHECK_EQ_INT(t->ne[0], 640);                   // joint_hidden
+            CHECK_EQ_INT(t->ne[1], hp.joint_n_classes());  // 1030 or 8198
         }
     }
 
@@ -323,7 +308,6 @@ int main() {
         std::fprintf(stderr, "parakeet_real_smoke: %d failures\n", g_failures);
         return EXIT_FAILURE;
     }
-    std::fprintf(stdout,
-                 "parakeet_real_smoke: ok (%s)\n", variant.c_str());
+    std::fprintf(stdout, "parakeet_real_smoke: ok (%s)\n", variant.c_str());
     return EXIT_SUCCESS;
 }
diff --git a/tests/parakeet_smoke.cpp b/tests/parakeet_smoke.cpp
index 2dc922c0..9c924f87 100644
--- a/tests/parakeet_smoke.cpp
+++ b/tests/parakeet_smoke.cpp
@@ -28,14 +28,12 @@
 // C ABI does not (and should not) expose ggml_tensor pointers
 // directly.
 
-#include "transcribe.h"
-
 #include "arch/parakeet/parakeet.h"
 #include "arch/parakeet/weights.h"
-#include "transcribe-model.h"
-
-#include "ggml.h"
 #include "ggml-backend.h"
+#include "ggml.h"
+#include "transcribe-model.h"
+#include "transcribe.h"
 
 #include <sys/stat.h>
 
@@ -45,7 +43,7 @@
 #include <string>
 
 #ifndef TRANSCRIBE_TEST_FIXTURES_DIR
-#  error "TRANSCRIBE_TEST_FIXTURES_DIR must be defined by the build system"
+#    error "TRANSCRIBE_TEST_FIXTURES_DIR must be defined by the build system"
 #endif
 
 namespace {
@@ -54,42 +52,36 @@ const std::string g_fixtures_dir = TRANSCRIBE_TEST_FIXTURES_DIR;
 
 int g_failures = 0;
 
-#define CHECK(cond)                                                         \
-    do {                                                                    \
-        if (!(cond)) {                                                      \
-            std::fprintf(stderr, "FAIL %s:%d: %s\n",                        \
-                         __FILE__, __LINE__, #cond);                        \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK(cond)                                                              \
+    do {                                                                         \
+        if (!(cond)) {                                                           \
+            std::fprintf(stderr, "FAIL %s:%d: %s\n", __FILE__, __LINE__, #cond); \
+            ++g_failures;                                                        \
+        }                                                                        \
     } while (0)
 
-#define CHECK_EQ_INT(actual, expected)                                      \
-    do {                                                                    \
-        const long long _a = static_cast<long long>(actual);                \
-        const long long _e = static_cast<long long>(expected);              \
-        if (_a != _e) {                                                     \
-            std::fprintf(stderr,                                            \
-                         "FAIL %s:%d: %s = %lld, expected %lld\n",          \
-                         __FILE__, __LINE__, #actual, _a, _e);              \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK_EQ_INT(actual, expected)                                                                           \
+    do {                                                                                                         \
+        const long long _a = static_cast<long long>(actual);                                                     \
+        const long long _e = static_cast<long long>(expected);                                                   \
+        if (_a != _e) {                                                                                          \
+            std::fprintf(stderr, "FAIL %s:%d: %s = %lld, expected %lld\n", __FILE__, __LINE__, #actual, _a, _e); \
+            ++g_failures;                                                                                        \
+        }                                                                                                        \
     } while (0)
 
-#define CHECK_STR_EQ(a, b)                                                  \
-    do {                                                                    \
-        const std::string _av = (a);                                        \
-        const std::string _bv = (b);                                        \
-        if (_av != _bv) {                                                   \
-            std::fprintf(stderr,                                            \
-                         "FAIL %s:%d: \"%s\" != \"%s\"\n",                  \
-                         __FILE__, __LINE__,                                \
-                         _av.c_str(), _bv.c_str());                         \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK_STR_EQ(a, b)                                                                                        \
+    do {                                                                                                          \
+        const std::string _av = (a);                                                                              \
+        const std::string _bv = (b);                                                                              \
+        if (_av != _bv) {                                                                                         \
+            std::fprintf(stderr, "FAIL %s:%d: \"%s\" != \"%s\"\n", __FILE__, __LINE__, _av.c_str(), _bv.c_str()); \
+            ++g_failures;                                                                                         \
+        }                                                                                                         \
     } while (0)
 
 bool file_exists(const std::string & path) {
-    struct stat st {};
+    struct stat st{};
     return ::stat(path.c_str(), &st) == 0;
 }
 
@@ -98,12 +90,11 @@ bool file_exists(const std::string & path) {
 // from the parakeet handler because we just loaded a parakeet GGUF.
 // In real code the family handler keeps the downcast inside its own
 // init_context / run.
-const transcribe::parakeet::ParakeetModel *
-parakeet_view(const struct transcribe_model * m) {
+const transcribe::parakeet::ParakeetModel * parakeet_view(const struct transcribe_model * m) {
     return static_cast<const transcribe::parakeet::ParakeetModel *>(m);
 }
 
-} // namespace
+}  // namespace
 
 int main() {
     const std::string fixture = g_fixtures_dir + "/tokenizer_minimal.gguf";
@@ -114,18 +105,16 @@ int main() {
                      "regenerate with:\n"
                      "  cmake --build build --target fixtures\n",
                      fixture.c_str());
-        return 77; // CTest "skipped"
+        return 77;  // CTest "skipped"
     }
 
-    transcribe_model_load_params mp; transcribe_model_load_params_init(&mp);
+    transcribe_model_load_params mp;
+    transcribe_model_load_params_init(&mp);
     struct transcribe_model * model = nullptr;
 
-    const transcribe_status st =
-        transcribe_model_load_file(fixture.c_str(), &mp, &model);
+    const transcribe_status st = transcribe_model_load_file(fixture.c_str(), &mp, &model);
     if (st != TRANSCRIBE_OK) {
-        std::fprintf(stderr,
-                     "FAIL load: expected OK, got %s\n",
-                     transcribe_status_string(st));
+        std::fprintf(stderr, "FAIL load: expected OK, got %s\n", transcribe_status_string(st));
         return EXIT_FAILURE;
     }
     if (model == nullptr) {
@@ -144,8 +133,7 @@ int main() {
     {
         const char * backend = transcribe_model_backend(model);
         if (backend == nullptr || backend[0] == '\0') {
-            std::fprintf(stderr,
-                         "FAIL: backend = \"\" after step 1, expected non-empty\n");
+            std::fprintf(stderr, "FAIL: backend = \"\" after step 1, expected non-empty\n");
             ++g_failures;
         }
     }
@@ -160,49 +148,49 @@ int main() {
     // These match the values baked into make_gguf_fixtures.py
     // PARAKEET_HP. If either side drifts the test fails loudly.
     const auto & hp = pm->hparams;
-    CHECK_EQ_INT(hp.enc_n_layers,             2);
-    CHECK_EQ_INT(hp.enc_d_model,              8);
-    CHECK_EQ_INT(hp.enc_n_heads,              2);
-    CHECK_EQ_INT(hp.enc_d_ff,                 16);
-    CHECK_EQ_INT(hp.enc_conv_kernel,          3);
-    CHECK_EQ_INT(hp.enc_subsampling_factor,   2);
+    CHECK_EQ_INT(hp.enc_n_layers, 2);
+    CHECK_EQ_INT(hp.enc_d_model, 8);
+    CHECK_EQ_INT(hp.enc_n_heads, 2);
+    CHECK_EQ_INT(hp.enc_d_ff, 16);
+    CHECK_EQ_INT(hp.enc_conv_kernel, 3);
+    CHECK_EQ_INT(hp.enc_subsampling_factor, 2);
     CHECK_EQ_INT(hp.enc_subsampling_channels, 4);
-    CHECK_EQ_INT(hp.enc_pos_emb_max_len,      32);
-    CHECK_EQ_INT(hp.enc_use_bias,             0); // default false
-    CHECK_EQ_INT(hp.enc_head_dim(),           4); // 8 / 2
-    CHECK_EQ_INT(hp.pred_hidden,              4);
-    CHECK_EQ_INT(hp.pred_n_layers,            1);
-    CHECK_EQ_INT(hp.pred_vocab,               17);
-    CHECK_EQ_INT(hp.joint_hidden,             4);
-    CHECK_EQ_INT(hp.joint_num_extra_outputs,  2);
-    CHECK_EQ_INT(hp.joint_n_classes(),        19); // (17-1) + 2 + 1
-    CHECK_STR_EQ(hp.joint_activation,         "relu");
+    CHECK_EQ_INT(hp.enc_pos_emb_max_len, 32);
+    CHECK_EQ_INT(hp.enc_use_bias, 0);    // default false
+    CHECK_EQ_INT(hp.enc_head_dim(), 4);  // 8 / 2
+    CHECK_EQ_INT(hp.pred_hidden, 4);
+    CHECK_EQ_INT(hp.pred_n_layers, 1);
+    CHECK_EQ_INT(hp.pred_vocab, 17);
+    CHECK_EQ_INT(hp.joint_hidden, 4);
+    CHECK_EQ_INT(hp.joint_num_extra_outputs, 2);
+    CHECK_EQ_INT(hp.joint_n_classes(), 19);  // (17-1) + 2 + 1
+    CHECK_STR_EQ(hp.joint_activation, "relu");
     // TDT durations: 2 entries to match joint_num_extra_outputs.
     CHECK_EQ_INT(static_cast<int>(hp.tdt_durations.size()), 2);
     CHECK_EQ_INT(hp.tdt_durations[0], 0);
     CHECK_EQ_INT(hp.tdt_durations[1], 1);
-    CHECK_EQ_INT(hp.tdt_max_symbols,          10);
+    CHECK_EQ_INT(hp.tdt_max_symbols, 10);
     // Frontend hparams: full stt.frontend.* block. The synthetic
     // fixture's PARAKEET_HP and the loader's read_parakeet_hparams
     // both have to know about every field, and this assertion is the
     // gate that catches a future contributor who adds a key on one
     // side but forgets the other.
-    CHECK_STR_EQ(hp.fe_type,                  "mel");
-    CHECK_EQ_INT(hp.fe_num_mels,              4);
-    CHECK_EQ_INT(hp.fe_sample_rate,           16000);
-    CHECK_EQ_INT(hp.fe_n_fft,                 16);
-    CHECK_EQ_INT(hp.fe_win_length,            8);
-    CHECK_EQ_INT(hp.fe_hop_length,            4);
-    CHECK_STR_EQ(hp.fe_window,                "hann");
-    CHECK_STR_EQ(hp.fe_normalize,             "per_feature");
+    CHECK_STR_EQ(hp.fe_type, "mel");
+    CHECK_EQ_INT(hp.fe_num_mels, 4);
+    CHECK_EQ_INT(hp.fe_sample_rate, 16000);
+    CHECK_EQ_INT(hp.fe_n_fft, 16);
+    CHECK_EQ_INT(hp.fe_win_length, 8);
+    CHECK_EQ_INT(hp.fe_hop_length, 4);
+    CHECK_STR_EQ(hp.fe_window, "hann");
+    CHECK_STR_EQ(hp.fe_normalize, "per_feature");
     // f32 fields are checked exactly because the fixture writes
     // exact values and the round-trip is bit-perfect for these
     // sizes. If a future fixture starts using less round-friendly
     // values, switch to a fabs(diff) < epsilon check.
-    CHECK(hp.fe_dither       == 1e-5f);
+    CHECK(hp.fe_dither == 1e-5f);
     CHECK(hp.fe_pre_emphasis == 0.97f);
-    CHECK(hp.fe_f_min        == 0.0f);
-    CHECK(hp.fe_f_max        == 8000.0f);
+    CHECK(hp.fe_f_min == 0.0f);
+    CHECK(hp.fe_f_max == 8000.0f);
 
     // ----- Pre-encode slots populated -----
     const auto & pe = pm->weights.pre_encode;
@@ -216,8 +204,8 @@ int main() {
     CHECK(pe.conv5_b != nullptr);
     CHECK(pe.conv6_w != nullptr);
     CHECK(pe.conv6_b != nullptr);
-    CHECK(pe.out_w   != nullptr);
-    CHECK(pe.out_b   != nullptr);
+    CHECK(pe.out_w != nullptr);
+    CHECK(pe.out_b != nullptr);
 
     // ----- Encoder block slots populated for every layer -----
     CHECK_EQ_INT(pm->weights.blocks.size(), 2);
@@ -227,22 +215,22 @@ int main() {
         // every category got populated. Not exhaustive — the goal is
         // "the build_parakeet_weights walk visited every code path",
         // not "I am about to forget the names of all 28 tensors".
-        CHECK(b.norm_ff1_w  != nullptr);
-        CHECK(b.ff1_lin1_w  != nullptr);
+        CHECK(b.norm_ff1_w != nullptr);
+        CHECK(b.ff1_lin1_w != nullptr);
         CHECK(b.norm_attn_w != nullptr);
-        CHECK(b.attn_q_w    != nullptr);
-        CHECK(b.attn_pos_u  != nullptr);
-        CHECK(b.attn_pos_v  != nullptr);
+        CHECK(b.attn_q_w != nullptr);
+        CHECK(b.attn_pos_u != nullptr);
+        CHECK(b.attn_pos_v != nullptr);
         CHECK(b.norm_conv_w != nullptr);
-        CHECK(b.conv_pw1_w  != nullptr);
-        CHECK(b.conv_dw_w   != nullptr);
-        CHECK(b.conv_pw2_w  != nullptr);
-        CHECK(b.conv_bn_w   != nullptr);
-        CHECK(b.conv_bn_rm  != nullptr);
-        CHECK(b.conv_bn_rv  != nullptr);
-        CHECK(b.norm_ff2_w  != nullptr);
-        CHECK(b.ff2_lin1_w  != nullptr);
-        CHECK(b.norm_out_w  != nullptr);
+        CHECK(b.conv_pw1_w != nullptr);
+        CHECK(b.conv_dw_w != nullptr);
+        CHECK(b.conv_pw2_w != nullptr);
+        CHECK(b.conv_bn_w != nullptr);
+        CHECK(b.conv_bn_rm != nullptr);
+        CHECK(b.conv_bn_rv != nullptr);
+        CHECK(b.norm_ff2_w != nullptr);
+        CHECK(b.ff2_lin1_w != nullptr);
+        CHECK(b.norm_out_w != nullptr);
     }
 
     // ----- Predictor slots populated -----
@@ -252,16 +240,16 @@ int main() {
         const auto & l = pm->weights.predictor.lstm[0];
         CHECK(l.Wx != nullptr);
         CHECK(l.Wh != nullptr);
-        CHECK(l.b  != nullptr);
+        CHECK(l.b != nullptr);
     }
 
     // ----- Joint slots populated -----
-    CHECK(pm->weights.joint.enc_w  != nullptr);
-    CHECK(pm->weights.joint.enc_b  != nullptr);
+    CHECK(pm->weights.joint.enc_w != nullptr);
+    CHECK(pm->weights.joint.enc_b != nullptr);
     CHECK(pm->weights.joint.pred_w != nullptr);
     CHECK(pm->weights.joint.pred_b != nullptr);
-    CHECK(pm->weights.joint.out_w  != nullptr);
-    CHECK(pm->weights.joint.out_b  != nullptr);
+    CHECK(pm->weights.joint.out_w != nullptr);
+    CHECK(pm->weights.joint.out_b != nullptr);
 
     // ----- Spot-check tensor shapes against the catalog -----
     // The first pre_encode conv: ne should be [3, 3, 1, channels].
@@ -272,9 +260,7 @@ int main() {
         CHECK_EQ_INT(pe.conv0_w->ne[3], 4);
     }
     // The block-0 q projection should be square [d_model, d_model].
-    if (!pm->weights.blocks.empty() &&
-        pm->weights.blocks[0].attn_q_w != nullptr)
-    {
+    if (!pm->weights.blocks.empty() && pm->weights.blocks[0].attn_q_w != nullptr) {
         const auto * t = pm->weights.blocks[0].attn_q_w;
         CHECK_EQ_INT(t->ne[0], 8);
         CHECK_EQ_INT(t->ne[1], 8);
@@ -308,8 +294,7 @@ int main() {
         float v = 0.0f;
         ggml_backend_tensor_get(pe.conv0_w, &v, 0, sizeof(float));
         if (v != 0.0f) {
-            std::fprintf(stderr,
-                         "FAIL pre_encode.conv0_w[0]: got %f, expected 0.0\n", v);
+            std::fprintf(stderr, "FAIL pre_encode.conv0_w[0]: got %f, expected 0.0\n", v);
             ++g_failures;
         }
     } else {
@@ -320,8 +305,7 @@ int main() {
         float v = 0.0f;
         ggml_backend_tensor_get(pe.out_w, &v, 0, sizeof(float));
         if (v != 10.0f) {
-            std::fprintf(stderr,
-                         "FAIL pre_encode.out_w[0]: got %f, expected 10.0\n", v);
+            std::fprintf(stderr, "FAIL pre_encode.out_w[0]: got %f, expected 10.0\n", v);
             ++g_failures;
         }
     } else {
diff --git a/tests/parakeet_stream_ext_reject_unit.cpp b/tests/parakeet_stream_ext_reject_unit.cpp
index fbfd4075..3aa8a5a8 100644
--- a/tests/parakeet_stream_ext_reject_unit.cpp
+++ b/tests/parakeet_stream_ext_reject_unit.cpp
@@ -36,7 +36,7 @@
 #include <string>
 
 #ifndef TRANSCRIBE_TEST_FIXTURES_DIR
-#  error "TRANSCRIBE_TEST_FIXTURES_DIR must be defined by the build system"
+#    error "TRANSCRIBE_TEST_FIXTURES_DIR must be defined by the build system"
 #endif
 
 namespace {
@@ -45,24 +45,22 @@ const std::string g_fixtures_dir = TRANSCRIBE_TEST_FIXTURES_DIR;
 
 int g_failures = 0;
 
-#define CHECK(cond)                                                         \
-    do {                                                                    \
-        if (!(cond)) {                                                      \
-            std::fprintf(stderr, "FAIL %s:%d: %s\n",                        \
-                         __FILE__, __LINE__, #cond);                        \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK(cond)                                                              \
+    do {                                                                         \
+        if (!(cond)) {                                                           \
+            std::fprintf(stderr, "FAIL %s:%d: %s\n", __FILE__, __LINE__, #cond); \
+            ++g_failures;                                                        \
+        }                                                                        \
     } while (0)
 
 bool file_exists(const std::string & path) {
-    struct stat st {};
+    struct stat st{};
     return ::stat(path.c_str(), &st) == 0;
 }
 
-bool load_and_init(const char *                  fixture_name,
-                   struct transcribe_model **    out_model,
-                   struct transcribe_session **  out_ctx)
-{
+bool load_and_init(const char *                 fixture_name,
+                   struct transcribe_model **   out_model,
+                   struct transcribe_session ** out_ctx) {
     *out_model = nullptr;
     *out_ctx   = nullptr;
 
@@ -76,20 +74,16 @@ bool load_and_init(const char *                  fixture_name,
         return false;
     }
 
-    const transcribe_status load_st =
-        transcribe_model_load_file(p.c_str(), nullptr, out_model);
+    const transcribe_status load_st = transcribe_model_load_file(p.c_str(), nullptr, out_model);
     if (load_st != TRANSCRIBE_OK || *out_model == nullptr) {
-        std::fprintf(stderr, "FAIL load %s: %s\n",
-                     fixture_name, transcribe_status_string(load_st));
+        std::fprintf(stderr, "FAIL load %s: %s\n", fixture_name, transcribe_status_string(load_st));
         ++g_failures;
         return false;
     }
 
-    const transcribe_status init_st =
-        transcribe_session_init(*out_model, nullptr, out_ctx);
+    const transcribe_status init_st = transcribe_session_init(*out_model, nullptr, out_ctx);
     if (init_st != TRANSCRIBE_OK || *out_ctx == nullptr) {
-        std::fprintf(stderr, "FAIL session_init %s: %s\n",
-                     fixture_name, transcribe_status_string(init_st));
+        std::fprintf(stderr, "FAIL session_init %s: %s\n", fixture_name, transcribe_status_string(init_st));
         transcribe_model_free(*out_model);
         *out_model = nullptr;
         ++g_failures;
@@ -106,19 +100,19 @@ bool load_and_init(const char *                  fixture_name,
 void test_cache_aware_rejects_sub_sentinel() {
     struct transcribe_model *   model = nullptr;
     struct transcribe_session * ctx   = nullptr;
-    if (!load_and_init("tokenizer_minimal_streaming_cache_aware.gguf",
-                       &model, &ctx))
-    {
+    if (!load_and_init("tokenizer_minimal_streaming_cache_aware.gguf", &model, &ctx)) {
         return;
     }
 
-    transcribe_run_params rp; transcribe_run_params_init(&rp);
+    transcribe_run_params rp;
+    transcribe_run_params_init(&rp);
 
     transcribe_parakeet_stream_ext ext;
     transcribe_parakeet_stream_ext_init(&ext);
     ext.att_context_right = -2;
 
-    transcribe_stream_params sp; transcribe_stream_params_init(&sp);
+    transcribe_stream_params sp;
+    transcribe_stream_params_init(&sp);
     sp.family = &ext.ext;
 
     const transcribe_status st = transcribe_stream_begin(ctx, &rp, &sp);
@@ -126,12 +120,12 @@ void test_cache_aware_rejects_sub_sentinel() {
     // Pre-flight rejection: dispatcher returns the error before clear
     // or any state transition, so the session stays IDLE with
     // last_status untouched.
-    CHECK(transcribe_stream_get_state(ctx)   == TRANSCRIBE_STREAM_IDLE);
+    CHECK(transcribe_stream_get_state(ctx) == TRANSCRIBE_STREAM_IDLE);
     CHECK(transcribe_stream_last_status(ctx) == TRANSCRIBE_OK);
 
     // Also try a strongly negative value to confirm the boundary.
-    ext.att_context_right = -42;
-    sp.family = &ext.ext;
+    ext.att_context_right       = -42;
+    sp.family                   = &ext.ext;
     const transcribe_status st2 = transcribe_stream_begin(ctx, &rp, &sp);
     CHECK(st2 == TRANSCRIBE_ERR_INVALID_ARG);
 
@@ -145,13 +139,12 @@ void test_cache_aware_rejects_sub_sentinel() {
 void test_buffered_rejects_sub_sentinel() {
     struct transcribe_model *   model = nullptr;
     struct transcribe_session * ctx   = nullptr;
-    if (!load_and_init("tokenizer_minimal_streaming_buffered.gguf",
-                       &model, &ctx))
-    {
+    if (!load_and_init("tokenizer_minimal_streaming_buffered.gguf", &model, &ctx)) {
         return;
     }
 
-    transcribe_run_params rp; transcribe_run_params_init(&rp);
+    transcribe_run_params rp;
+    transcribe_run_params_init(&rp);
 
     auto try_reject = [&](int32_t L, int32_t C, int32_t R) {
         transcribe_parakeet_buffered_stream_ext ext;
@@ -159,12 +152,13 @@ void test_buffered_rejects_sub_sentinel() {
         ext.left_ms  = L;
         ext.chunk_ms = C;
         ext.right_ms = R;
-        transcribe_stream_params sp; transcribe_stream_params_init(&sp);
-        sp.family = &ext.ext;
+        transcribe_stream_params sp;
+        transcribe_stream_params_init(&sp);
+        sp.family                  = &ext.ext;
         const transcribe_status st = transcribe_stream_begin(ctx, &rp, &sp);
         CHECK(st == TRANSCRIBE_ERR_INVALID_ARG);
         // Pre-flight rejection leaves lifecycle / last_status untouched.
-        CHECK(transcribe_stream_get_state(ctx)   == TRANSCRIBE_STREAM_IDLE);
+        CHECK(transcribe_stream_get_state(ctx) == TRANSCRIBE_STREAM_IDLE);
         CHECK(transcribe_stream_last_status(ctx) == TRANSCRIBE_OK);
     };
 
@@ -195,13 +189,12 @@ void test_buffered_rejects_sub_sentinel() {
 void test_buffered_zero_is_real_value() {
     struct transcribe_model *   model = nullptr;
     struct transcribe_session * ctx   = nullptr;
-    if (!load_and_init("tokenizer_minimal_streaming_buffered.gguf",
-                       &model, &ctx))
-    {
+    if (!load_and_init("tokenizer_minimal_streaming_buffered.gguf", &model, &ctx)) {
         return;
     }
 
-    transcribe_run_params rp; transcribe_run_params_init(&rp);
+    transcribe_run_params rp;
+    transcribe_run_params_init(&rp);
 
     transcribe_parakeet_buffered_stream_ext ext;
     transcribe_parakeet_buffered_stream_ext_init(&ext);
@@ -210,7 +203,8 @@ void test_buffered_zero_is_real_value() {
     ext.left_ms  = 70;
     ext.chunk_ms = 1;
     ext.right_ms = 0;
-    transcribe_stream_params sp; transcribe_stream_params_init(&sp);
+    transcribe_stream_params sp;
+    transcribe_stream_params_init(&sp);
     sp.family = &ext.ext;
 
     const transcribe_status st = transcribe_stream_begin(ctx, &rp, &sp);
@@ -227,7 +221,7 @@ void test_buffered_zero_is_real_value() {
     transcribe_model_free(model);
 }
 
-} // namespace
+}  // namespace
 
 int main() {
     test_cache_aware_rejects_sub_sentinel();
@@ -235,8 +229,7 @@ int main() {
     test_buffered_zero_is_real_value();
 
     if (g_failures > 0) {
-        std::fprintf(stderr, "parakeet_stream_ext_reject_unit: %d failures\n",
-                     g_failures);
+        std::fprintf(stderr, "parakeet_stream_ext_reject_unit: %d failures\n", g_failures);
         return EXIT_FAILURE;
     }
     std::fprintf(stdout, "parakeet_stream_ext_reject_unit: ok\n");
diff --git a/tests/qwen3_asr_batch_truncation.cpp b/tests/qwen3_asr_batch_truncation.cpp
index 7b06310e..ae3fb2e0 100644
--- a/tests/qwen3_asr_batch_truncation.cpp
+++ b/tests/qwen3_asr_batch_truncation.cpp
@@ -30,7 +30,6 @@
 //     unset/missing (or a sample is missing), exits 77 ("skipped").
 
 #include "transcribe.h"
-
 #include "wav.h"
 
 #include <sys/stat.h>
@@ -44,29 +43,26 @@ namespace {
 
 int g_failures = 0;
 
-#define CHECK(cond)                                                         \
-    do {                                                                    \
-        if (!(cond)) {                                                      \
-            std::fprintf(stderr, "FAIL %s:%d: %s\n",                        \
-                         __FILE__, __LINE__, #cond);                        \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK(cond)                                                              \
+    do {                                                                         \
+        if (!(cond)) {                                                           \
+            std::fprintf(stderr, "FAIL %s:%d: %s\n", __FILE__, __LINE__, #cond); \
+            ++g_failures;                                                        \
+        }                                                                        \
     } while (0)
 
-#define CHECK_EQ_INT(actual, expected)                                      \
-    do {                                                                    \
-        const long long _a = static_cast<long long>(actual);                \
-        const long long _e = static_cast<long long>(expected);              \
-        if (_a != _e) {                                                     \
-            std::fprintf(stderr,                                            \
-                         "FAIL %s:%d: %s = %lld, expected %lld\n",          \
-                         __FILE__, __LINE__, #actual, _a, _e);              \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK_EQ_INT(actual, expected)                                                                           \
+    do {                                                                                                         \
+        const long long _a = static_cast<long long>(actual);                                                     \
+        const long long _e = static_cast<long long>(expected);                                                   \
+        if (_a != _e) {                                                                                          \
+            std::fprintf(stderr, "FAIL %s:%d: %s = %lld, expected %lld\n", __FILE__, __LINE__, #actual, _a, _e); \
+            ++g_failures;                                                                                        \
+        }                                                                                                        \
     } while (0)
 
 bool file_exists(const std::string & path) {
-    struct stat st {};
+    struct stat st{};
     return ::stat(path.c_str(), &st) == 0;
 }
 
@@ -84,28 +80,33 @@ bool load_sample(const std::string & name, std::vector<float> & pcm) {
     return true;
 }
 
-} // namespace
+}  // namespace
 
 int main() {
     const char * model_path = std::getenv("TRANSCRIBE_QWEN3_ASR_0_6B_GGUF");
     if (model_path == nullptr || *model_path == '\0' || !file_exists(model_path)) {
-        std::fprintf(stderr,
-                     "skipping: TRANSCRIBE_QWEN3_ASR_0_6B_GGUF unset or missing\n");
+        std::fprintf(stderr, "skipping: TRANSCRIBE_QWEN3_ASR_0_6B_GGUF unset or missing\n");
         return 77;
     }
 
     std::vector<float> pcm_short, pcm_long;
-    if (!load_sample("jfk.wav", pcm_short)) return 77;
-    if (!load_sample("love-loss.wav", pcm_long)) return 77;
+    if (!load_sample("jfk.wav", pcm_short)) {
+        return 77;
+    }
+    if (!load_sample("love-loss.wav", pcm_long)) {
+        return 77;
+    }
 
-    transcribe_model_load_params mp; transcribe_model_load_params_init(&mp);
+    transcribe_model_load_params mp;
+    transcribe_model_load_params_init(&mp);
     struct transcribe_model * model = nullptr;
     if (transcribe_model_load_file(model_path, &mp, &model) != TRANSCRIBE_OK) {
         std::fprintf(stderr, "model load failed: %s\n", model_path);
         return 1;
     }
 
-    transcribe_session_params sp; transcribe_session_params_init(&sp);
+    transcribe_session_params sp;
+    transcribe_session_params_init(&sp);
     struct transcribe_session * s = nullptr;
     if (transcribe_session_init(model, &sp, &s) != TRANSCRIBE_OK) {
         std::fprintf(stderr, "session init failed\n");
@@ -117,16 +118,14 @@ int main() {
     // Both pass the input-length gate at the default (full) context; the long
     // clip simply runs the decoder into the 256-token generation budget.
     {
-        const transcribe_status rl = transcribe_run(
-            s, pcm_long.data(), (int) pcm_long.size(), nullptr);
+        const transcribe_status rl = transcribe_run(s, pcm_long.data(), (int) pcm_long.size(), nullptr);
         CHECK(rl == TRANSCRIBE_ERR_OUTPUT_TRUNCATED);
         CHECK(transcribe_was_truncated(s) == true);
         const char * t = transcribe_full_text(s);
-        CHECK(t != nullptr && t[0] != '\0');   // partial transcript retained
+        CHECK(t != nullptr && t[0] != '\0');  // partial transcript retained
     }
     {
-        const transcribe_status rs = transcribe_run(
-            s, pcm_short.data(), (int) pcm_short.size(), nullptr);
+        const transcribe_status rs = transcribe_run(s, pcm_short.data(), (int) pcm_short.size(), nullptr);
         CHECK(rs == TRANSCRIBE_OK);
         CHECK(transcribe_was_truncated(s) == false);  // reset + completed
     }
@@ -158,8 +157,7 @@ int main() {
     transcribe_model_free(model);
 
     if (g_failures > 0) {
-        std::fprintf(stderr, "qwen3_asr_batch_truncation: %d failures\n",
-                     g_failures);
+        std::fprintf(stderr, "qwen3_asr_batch_truncation: %d failures\n", g_failures);
         return EXIT_FAILURE;
     }
     std::fprintf(stdout, "qwen3_asr_batch_truncation: ok\n");
diff --git a/tests/qwen3_asr_bpe_parity.cpp b/tests/qwen3_asr_bpe_parity.cpp
index 9c63c2b2..8d6f09f1 100644
--- a/tests/qwen3_asr_bpe_parity.cpp
+++ b/tests/qwen3_asr_bpe_parity.cpp
@@ -22,12 +22,10 @@
 // Gated on the TRANSCRIBE_QWEN3_ASR_0_6B_GGUF env var (same var the
 // structural real-smoke test uses). Unset -> exit 77 (skip).
 
-#include "transcribe.h"
-
+#include "arch/qwen3_asr/qwen3_asr.h"
 #include "transcribe-model.h"
 #include "transcribe-tokenizer.h"
-
-#include "arch/qwen3_asr/qwen3_asr.h"
+#include "transcribe.h"
 
 #include <sys/stat.h>
 
@@ -48,34 +46,29 @@ int g_failures = 0;
 
 // Fixture schema used by the generated .inc file.
 struct Fixture {
-    const char *   text;
-    const int32_t  ids[32];
-    size_t         n_ids;
+    const char *  text;
+    const int32_t ids[32];
+    size_t        n_ids;
 };
 
 #include "fixtures/qwen3_asr_bpe_parity.inc"
 
 bool file_exists(const std::string & path) {
-    struct stat st {};
+    struct stat st{};
     return ::stat(path.c_str(), &st) == 0;
 }
 
-void check_ids_equal(const char *                  label,
-                     const char *                  text,
-                     const int32_t *               expected,
-                     size_t                         expected_n,
-                     const std::vector<int32_t> &  actual)
-{
-    if (actual.size() == expected_n &&
-        std::memcmp(actual.data(), expected,
-                    expected_n * sizeof(int32_t)) == 0)
-    {
+void check_ids_equal(const char *                 label,
+                     const char *                 text,
+                     const int32_t *              expected,
+                     size_t                       expected_n,
+                     const std::vector<int32_t> & actual) {
+    if (actual.size() == expected_n && std::memcmp(actual.data(), expected, expected_n * sizeof(int32_t)) == 0) {
         return;
     }
 
     ++g_failures;
-    std::fprintf(stderr, "FAIL[%s] input=\"%s\"\n  expected (%zu):",
-                 label, text, expected_n);
+    std::fprintf(stderr, "FAIL[%s] input=\"%s\"\n  expected (%zu):", label, text, expected_n);
     for (size_t i = 0; i < expected_n; ++i) {
         std::fprintf(stderr, " %d", static_cast<int>(expected[i]));
     }
@@ -86,7 +79,7 @@ void check_ids_equal(const char *                  label,
     std::fprintf(stderr, "\n");
 }
 
-} // namespace
+}  // namespace
 
 int main() {
     const char * env = std::getenv("TRANSCRIBE_QWEN3_ASR_0_6B_GGUF");
@@ -98,26 +91,22 @@ int main() {
     }
     const std::string model_path = env;
     if (!file_exists(model_path)) {
-        std::fprintf(stderr,
-                     "qwen3_asr_bpe_parity: model not found: %s\n",
-                     model_path.c_str());
+        std::fprintf(stderr, "qwen3_asr_bpe_parity: model not found: %s\n", model_path.c_str());
         return 77;
     }
 
-    transcribe_model_load_params mp; transcribe_model_load_params_init(&mp);
-    mp.backend = TRANSCRIBE_BACKEND_CPU;
+    transcribe_model_load_params mp;
+    transcribe_model_load_params_init(&mp);
+    mp.backend                      = TRANSCRIBE_BACKEND_CPU;
     struct transcribe_model * model = nullptr;
-    if (transcribe_model_load_file(model_path.c_str(), &mp, &model) !=
-            TRANSCRIBE_OK ||
-        model == nullptr)
-    {
+    if (transcribe_model_load_file(model_path.c_str(), &mp, &model) != TRANSCRIBE_OK || model == nullptr) {
         std::fprintf(stderr, "qwen3_asr_bpe_parity: failed to load model\n");
         return EXIT_FAILURE;
     }
 
-    const auto * base = reinterpret_cast<const transcribe_model *>(model);
-    const auto * qm   = static_cast<const transcribe::qwen3_asr::QwenAsrModel *>(base);
-    const transcribe::Tokenizer & tok = qm->tok;
+    const auto *                  base = reinterpret_cast<const transcribe_model *>(model);
+    const auto *                  qm   = static_cast<const transcribe::qwen3_asr::QwenAsrModel *>(base);
+    const transcribe::Tokenizer & tok  = qm->tok;
 
     if (!tok.has_encoder()) {
         std::fprintf(stderr,
@@ -129,17 +118,14 @@ int main() {
     }
 
     // Section 1: plain-text BPE parity.
-    std::fprintf(stderr,
-                 "qwen3_asr_bpe_parity: %zu plain BPE fixtures\n",
-                 k_bpe_fixtures_n);
+    std::fprintf(stderr, "qwen3_asr_bpe_parity: %zu plain BPE fixtures\n", k_bpe_fixtures_n);
     for (size_t i = 0; i < k_bpe_fixtures_n; ++i) {
-        const auto & f = k_bpe_fixtures[i];
-        std::vector<int32_t> got;
+        const auto &            f = k_bpe_fixtures[i];
+        std::vector<int32_t>    got;
         const transcribe_status st = tok.encode(f.text, got);
         if (st != TRANSCRIBE_OK) {
-            std::fprintf(stderr,
-                         "FAIL[bpe] encode returned %s for input \"%s\"\n",
-                         transcribe_status_string(st), f.text);
+            std::fprintf(stderr, "FAIL[bpe] encode returned %s for input \"%s\"\n", transcribe_status_string(st),
+                         f.text);
             ++g_failures;
             continue;
         }
@@ -147,14 +133,11 @@ int main() {
     }
 
     // Section 2: language-prefix parity (encode_language_prefix).
-    std::fprintf(stderr,
-                 "qwen3_asr_bpe_parity: %zu language-prefix fixtures\n",
-                 k_lang_prefix_fixtures_n);
+    std::fprintf(stderr, "qwen3_asr_bpe_parity: %zu language-prefix fixtures\n", k_lang_prefix_fixtures_n);
     for (size_t i = 0; i < k_lang_prefix_fixtures_n; ++i) {
-        const auto & f = k_lang_prefix_fixtures[i];
-        std::vector<int32_t> got;
-        const transcribe_status st =
-            transcribe::qwen3_asr::encode_language_prefix(tok, f.bcp47, got);
+        const auto &            f = k_lang_prefix_fixtures[i];
+        std::vector<int32_t>    got;
+        const transcribe_status st = transcribe::qwen3_asr::encode_language_prefix(tok, f.bcp47, got);
         if (st != TRANSCRIBE_OK) {
             std::fprintf(stderr,
                          "FAIL[lang] encode_language_prefix returned "
@@ -171,8 +154,7 @@ int main() {
     transcribe_model_free(model);
 
     if (g_failures > 0) {
-        std::fprintf(stderr,
-                     "qwen3_asr_bpe_parity: %d failures\n", g_failures);
+        std::fprintf(stderr, "qwen3_asr_bpe_parity: %d failures\n", g_failures);
         return EXIT_FAILURE;
     }
     std::fprintf(stdout, "qwen3_asr_bpe_parity: ok\n");
diff --git a/tests/qwen3_asr_e2e_smoke.cpp b/tests/qwen3_asr_e2e_smoke.cpp
index 13dcaf02..f88f5fe0 100644
--- a/tests/qwen3_asr_e2e_smoke.cpp
+++ b/tests/qwen3_asr_e2e_smoke.cpp
@@ -30,7 +30,6 @@
 //     second case when the samples/dots.wav file is present.
 
 #include "transcribe.h"
-
 #include "wav.h"
 
 #include <sys/stat.h>
@@ -43,56 +42,55 @@
 #include <vector>
 
 #ifndef TRANSCRIBE_TEST_SAMPLES_DIR
-#  define TRANSCRIBE_TEST_SAMPLES_DIR "samples"
+#    define TRANSCRIBE_TEST_SAMPLES_DIR "samples"
 #endif
 
 namespace {
 
 int g_failures = 0;
 
-#define CHECK(cond)                                                         \
-    do {                                                                    \
-        if (!(cond)) {                                                      \
-            std::fprintf(stderr, "FAIL %s:%d: %s\n",                        \
-                         __FILE__, __LINE__, #cond);                        \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK(cond)                                                              \
+    do {                                                                         \
+        if (!(cond)) {                                                           \
+            std::fprintf(stderr, "FAIL %s:%d: %s\n", __FILE__, __LINE__, #cond); \
+            ++g_failures;                                                        \
+        }                                                                        \
     } while (0)
 
-#define CHECK_STR_EQ(a, b)                                                  \
-    do {                                                                    \
-        const std::string _av = (a);                                        \
-        const std::string _bv = (b);                                        \
-        if (_av != _bv) {                                                   \
-            std::fprintf(stderr,                                            \
-                         "FAIL %s:%d: \"%s\" != \"%s\"\n",                  \
-                         __FILE__, __LINE__,                                \
-                         _av.c_str(), _bv.c_str());                         \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK_STR_EQ(a, b)                                                                                        \
+    do {                                                                                                          \
+        const std::string _av = (a);                                                                              \
+        const std::string _bv = (b);                                                                              \
+        if (_av != _bv) {                                                                                         \
+            std::fprintf(stderr, "FAIL %s:%d: \"%s\" != \"%s\"\n", __FILE__, __LINE__, _av.c_str(), _bv.c_str()); \
+            ++g_failures;                                                                                         \
+        }                                                                                                         \
     } while (0)
 
 bool file_exists(const std::string & path) {
-    struct stat st {};
+    struct stat st{};
     return ::stat(path.c_str(), &st) == 0;
 }
 
 int edit_distance(const std::string & a, const std::string & b) {
-    const int n = static_cast<int>(a.size());
-    const int m = static_cast<int>(b.size());
+    const int        n = static_cast<int>(a.size());
+    const int        m = static_cast<int>(b.size());
     std::vector<int> prev(static_cast<size_t>(m + 1));
     std::vector<int> curr(static_cast<size_t>(m + 1));
-    for (int j = 0; j <= m; ++j) prev[static_cast<size_t>(j)] = j;
+    for (int j = 0; j <= m; ++j) {
+        prev[static_cast<size_t>(j)] = j;
+    }
     for (int i = 1; i <= n; ++i) {
         curr[0] = i;
         for (int j = 1; j <= m; ++j) {
-            const int cost = (a[static_cast<size_t>(i - 1)] ==
-                              b[static_cast<size_t>(j - 1)]) ? 0 : 1;
-            const int del = prev[static_cast<size_t>(j)]     + 1;
-            const int ins = curr[static_cast<size_t>(j - 1)] + 1;
-            const int sub = prev[static_cast<size_t>(j - 1)] + cost;
-            int best = del < ins ? del : ins;
-            if (sub < best) best = sub;
+            const int cost = (a[static_cast<size_t>(i - 1)] == b[static_cast<size_t>(j - 1)]) ? 0 : 1;
+            const int del  = prev[static_cast<size_t>(j)] + 1;
+            const int ins  = curr[static_cast<size_t>(j - 1)] + 1;
+            const int sub  = prev[static_cast<size_t>(j - 1)] + cost;
+            int       best = del < ins ? del : ins;
+            if (sub < best) {
+                best = sub;
+            }
             curr[static_cast<size_t>(j)] = best;
         }
         prev.swap(curr);
@@ -137,63 +135,52 @@ void run_case(transcribe_model *  model,
               const char *        case_name,
               const std::string & wav_path,
               const char *        reference,
-              int                 max_edit_distance)
-{
+              int                 max_edit_distance) {
     if (!file_exists(wav_path)) {
-        std::fprintf(stderr,
-                     "qwen3_asr_e2e_smoke[%s]: wav not found: %s\n",
-                     case_name, wav_path.c_str());
+        std::fprintf(stderr, "qwen3_asr_e2e_smoke[%s]: wav not found: %s\n", case_name, wav_path.c_str());
         ++g_failures;
         return;
     }
 
     std::vector<float> pcm;
-    std::string load_err;
+    std::string        load_err;
     if (!transcribe_cli::load_wav_mono_16k(wav_path, pcm, load_err)) {
-        std::fprintf(stderr,
-                     "qwen3_asr_e2e_smoke[%s]: wav load: %s\n",
-                     case_name, load_err.c_str());
+        std::fprintf(stderr, "qwen3_asr_e2e_smoke[%s]: wav load: %s\n", case_name, load_err.c_str());
         ++g_failures;
         return;
     }
 
-    transcribe_session_params cp; transcribe_session_params_init(&cp);
+    transcribe_session_params cp;
+    transcribe_session_params_init(&cp);
+
     struct transcribe_session * ctx = nullptr;
     {
-        const transcribe_status st =
-            transcribe_session_init(model, &cp, &ctx);
+        const transcribe_status st = transcribe_session_init(model, &cp, &ctx);
         if (st != TRANSCRIBE_OK || ctx == nullptr) {
-            std::fprintf(stderr,
-                         "qwen3_asr_e2e_smoke[%s]: FAIL ctx_init: %s\n",
-                         case_name, transcribe_status_string(st));
+            std::fprintf(stderr, "qwen3_asr_e2e_smoke[%s]: FAIL ctx_init: %s\n", case_name,
+                         transcribe_status_string(st));
             ++g_failures;
             return;
         }
     }
 
-    transcribe_run_params rp; transcribe_run_params_init(&rp);
+    transcribe_run_params rp;
+    transcribe_run_params_init(&rp);
     {
-        const transcribe_status st =
-            transcribe_run(ctx, pcm.data(),
-                           static_cast<int>(pcm.size()), &rp);
+        const transcribe_status st = transcribe_run(ctx, pcm.data(), static_cast<int>(pcm.size()), &rp);
         if (st != TRANSCRIBE_OK) {
-            std::fprintf(stderr,
-                         "qwen3_asr_e2e_smoke[%s]: FAIL run: %s\n",
-                         case_name, transcribe_status_string(st));
+            std::fprintf(stderr, "qwen3_asr_e2e_smoke[%s]: FAIL run: %s\n", case_name, transcribe_status_string(st));
             ++g_failures;
             transcribe_session_free(ctx);
             return;
         }
     }
 
-    const char * full = transcribe_full_text(ctx);
+    const char *      full   = transcribe_full_text(ctx);
     const std::string actual = full ? full : "";
-    std::fprintf(stderr,
-                 "qwen3_asr_e2e_smoke[%s]: text=\"%s\"\n",
-                 case_name, actual.c_str());
+    std::fprintf(stderr, "qwen3_asr_e2e_smoke[%s]: text=\"%s\"\n", case_name, actual.c_str());
     if (actual.empty()) {
-        std::fprintf(stderr,
-                     "FAIL[%s]: transcript is empty\n", case_name);
+        std::fprintf(stderr, "FAIL[%s]: transcript is empty\n", case_name);
         ++g_failures;
         transcribe_session_free(ctx);
         return;
@@ -205,9 +192,7 @@ void run_case(transcribe_model *  model,
                  "(tolerance=%d)\n",
                  case_name, dist, max_edit_distance);
     if (dist > max_edit_distance) {
-        std::fprintf(stderr,
-                     "FAIL[%s]: text edit distance %d exceeds %d\n",
-                     case_name, dist, max_edit_distance);
+        std::fprintf(stderr, "FAIL[%s]: text edit distance %d exceeds %d\n", case_name, dist, max_edit_distance);
         std::fprintf(stderr, "  reference: %s\n", reference);
         std::fprintf(stderr, "  actual:    %s\n", actual.c_str());
         ++g_failures;
@@ -216,7 +201,7 @@ void run_case(transcribe_model *  model,
     transcribe_session_free(ctx);
 }
 
-} // namespace
+}  // namespace
 
 int main() {
     const char * env = std::getenv("TRANSCRIBE_QWEN3_ASR_GGUF");
@@ -228,9 +213,7 @@ int main() {
     }
     const std::string model_path = env;
     if (!file_exists(model_path)) {
-        std::fprintf(stderr,
-                     "qwen3_asr_e2e_smoke: model not found: %s\n",
-                     model_path.c_str());
+        std::fprintf(stderr, "qwen3_asr_e2e_smoke: model not found: %s\n", model_path.c_str());
         return 77;
     }
 
@@ -240,20 +223,19 @@ int main() {
     } else {
         jfk_wav = std::string(TRANSCRIBE_TEST_SAMPLES_DIR) + "/jfk.wav";
     }
-    const std::string dots_wav =
-        std::string(TRANSCRIBE_TEST_SAMPLES_DIR) + "/dots.wav";
+    const std::string dots_wav = std::string(TRANSCRIBE_TEST_SAMPLES_DIR) + "/dots.wav";
 
     const auto t_start = std::chrono::steady_clock::now();
 
-    transcribe_model_load_params mp; transcribe_model_load_params_init(&mp);
+    transcribe_model_load_params mp;
+    transcribe_model_load_params_init(&mp);
     mp.backend = TRANSCRIBE_BACKEND_CPU;
+
     struct transcribe_model * model = nullptr;
     {
-        const transcribe_status st =
-            transcribe_model_load_file(model_path.c_str(), &mp, &model);
+        const transcribe_status st = transcribe_model_load_file(model_path.c_str(), &mp, &model);
         if (st != TRANSCRIBE_OK || model == nullptr) {
-            std::fprintf(stderr, "FAIL load: %s\n",
-                         transcribe_status_string(st));
+            std::fprintf(stderr, "FAIL load: %s\n", transcribe_status_string(st));
             return EXIT_FAILURE;
         }
     }
@@ -275,10 +257,8 @@ int main() {
     // can't mask a later bug.
     {
         std::vector<float> pcm;
-        std::string load_err;
-        if (!file_exists(jfk_wav) ||
-            !transcribe_cli::load_wav_mono_16k(jfk_wav, pcm, load_err))
-        {
+        std::string        load_err;
+        if (!file_exists(jfk_wav) || !transcribe_cli::load_wav_mono_16k(jfk_wav, pcm, load_err)) {
             std::fprintf(stderr,
                          "qwen3_asr_e2e_smoke: jfk wav load for language "
                          "hint check: %s\n",
@@ -287,11 +267,10 @@ int main() {
             return EXIT_FAILURE;
         }
 
-        transcribe_session_params cp; transcribe_session_params_init(&cp);
+        transcribe_session_params cp;
+        transcribe_session_params_init(&cp);
         struct transcribe_session * ctx = nullptr;
-        if (transcribe_session_init(model, &cp, &ctx) != TRANSCRIBE_OK ||
-            ctx == nullptr)
-        {
+        if (transcribe_session_init(model, &cp, &ctx) != TRANSCRIBE_OK || ctx == nullptr) {
             std::fprintf(stderr,
                          "qwen3_asr_e2e_smoke: ctx_init for language "
                          "hint check failed\n");
@@ -302,28 +281,23 @@ int main() {
         // Accept path: force "en" on English audio and expect a
         // transcript within the same edit-distance tolerance as the
         // auto-detect jfk case.
-        transcribe_run_params rp_lang; transcribe_run_params_init(&rp_lang);
-        rp_lang.language = "en";
-        const transcribe_status st =
-            transcribe_run(ctx, pcm.data(), static_cast<int>(pcm.size()),
-                           &rp_lang);
+        transcribe_run_params rp_lang;
+        transcribe_run_params_init(&rp_lang);
+        rp_lang.language           = "en";
+        const transcribe_status st = transcribe_run(ctx, pcm.data(), static_cast<int>(pcm.size()), &rp_lang);
         if (st != TRANSCRIBE_OK) {
-            std::fprintf(stderr,
-                         "FAIL: language=\"en\" returned %s (expected OK)\n",
-                         transcribe_status_string(st));
+            std::fprintf(stderr, "FAIL: language=\"en\" returned %s (expected OK)\n", transcribe_status_string(st));
             ++g_failures;
         } else {
-            const char * forced = transcribe_full_text(ctx);
+            const char *      forced      = transcribe_full_text(ctx);
             const std::string forced_text = forced ? forced : "";
-            const int dist = edit_distance(forced_text, k_jfk_reference_text);
+            const int         dist        = edit_distance(forced_text, k_jfk_reference_text);
             std::fprintf(stderr,
                          "qwen3_asr_e2e_smoke[lang=en]: text=\"%s\" "
                          "edit_distance=%d\n",
                          forced_text.c_str(), dist);
             if (dist > k_jfk_max_edit_distance) {
-                std::fprintf(stderr,
-                             "FAIL: forced-en edit distance %d > %d\n",
-                             dist, k_jfk_max_edit_distance);
+                std::fprintf(stderr, "FAIL: forced-en edit distance %d > %d\n", dist, k_jfk_max_edit_distance);
                 ++g_failures;
             }
         }
@@ -331,10 +305,8 @@ int main() {
         // Reject path: a BCP-47 code that is NOT in caps.languages
         // must be rejected with UNSUPPORTED_LANGUAGE by the
         // dispatcher. Use an unambiguously bogus code.
-        rp_lang.language = "xx-fake";
-        const transcribe_status st_bad =
-            transcribe_run(ctx, pcm.data(), static_cast<int>(pcm.size()),
-                           &rp_lang);
+        rp_lang.language               = "xx-fake";
+        const transcribe_status st_bad = transcribe_run(ctx, pcm.data(), static_cast<int>(pcm.size()), &rp_lang);
         if (st_bad != TRANSCRIBE_ERR_UNSUPPORTED_LANGUAGE) {
             std::fprintf(stderr,
                          "FAIL: expected UNSUPPORTED_LANGUAGE for "
@@ -347,8 +319,7 @@ int main() {
     }
 
     // Case 1: jfk.wav (single-chunk).
-    run_case(model, "jfk", jfk_wav,
-             k_jfk_reference_text, k_jfk_max_edit_distance);
+    run_case(model, "jfk", jfk_wav, k_jfk_reference_text, k_jfk_max_edit_distance);
 
     // Case 2: dots.wav (multi-chunk ragged tail). This is the
     // automated gate for the ragged-tail trim path — golden tensor
@@ -357,27 +328,27 @@ int main() {
     // when the sample file is absent so ad-hoc runs that only care
     // about jfk still pass.
     if (file_exists(dots_wav)) {
-        run_case(model, "dots", dots_wav,
-                 k_dots_reference_text, k_dots_max_edit_distance);
+        run_case(model, "dots", dots_wav, k_dots_reference_text, k_dots_max_edit_distance);
     } else {
         std::fprintf(stderr,
                      "qwen3_asr_e2e_smoke[dots]: %s not present; "
-                     "skipping multi-chunk case.\n", dots_wav.c_str());
+                     "skipping multi-chunk case.\n",
+                     dots_wav.c_str());
     }
 
-    const auto t_end = std::chrono::steady_clock::now();
-    const double wall_ms =
-        std::chrono::duration<double, std::milli>(t_end - t_start).count();
+    const auto   t_end   = std::chrono::steady_clock::now();
+    const double wall_ms = std::chrono::duration<double, std::milli>(t_end - t_start).count();
     std::fprintf(stderr, "qwen3_asr_e2e_smoke: wall=%.2f ms\n", wall_ms);
     if (wall_ms > 180000.0) {
-        std::fprintf(stderr,
-                     "FAIL: wall time %.2f ms exceeds 180000 ms\n", wall_ms);
+        std::fprintf(stderr, "FAIL: wall time %.2f ms exceeds 180000 ms\n", wall_ms);
         ++g_failures;
     }
 
     transcribe_model_free(model);
 
-    if (g_failures > 0) return EXIT_FAILURE;
+    if (g_failures > 0) {
+        return EXIT_FAILURE;
+    }
     std::fprintf(stdout, "qwen3_asr_e2e_smoke: ok\n");
     return EXIT_SUCCESS;
 }
diff --git a/tests/qwen3_asr_real_smoke_0_6b.cpp b/tests/qwen3_asr_real_smoke_0_6b.cpp
index 619b15f1..bd71699e 100644
--- a/tests/qwen3_asr_real_smoke_0_6b.cpp
+++ b/tests/qwen3_asr_real_smoke_0_6b.cpp
@@ -31,13 +31,11 @@
 //      n_languages matches the 30-language roster the converter
 //      writes, supports_language_detect true, supports_translate false.
 
-#include "transcribe.h"
-
 #include "arch/qwen3_asr/qwen3_asr.h"
 #include "arch/qwen3_asr/weights.h"
-#include "transcribe-model.h"
-
 #include "ggml.h"
+#include "transcribe-model.h"
+#include "transcribe.h"
 
 #include <sys/stat.h>
 
@@ -51,51 +49,44 @@ namespace {
 
 int g_failures = 0;
 
-#define CHECK(cond)                                                         \
-    do {                                                                    \
-        if (!(cond)) {                                                      \
-            std::fprintf(stderr, "FAIL %s:%d: %s\n",                        \
-                         __FILE__, __LINE__, #cond);                        \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK(cond)                                                              \
+    do {                                                                         \
+        if (!(cond)) {                                                           \
+            std::fprintf(stderr, "FAIL %s:%d: %s\n", __FILE__, __LINE__, #cond); \
+            ++g_failures;                                                        \
+        }                                                                        \
     } while (0)
 
-#define CHECK_EQ_INT(actual, expected)                                      \
-    do {                                                                    \
-        const long long _a = static_cast<long long>(actual);                \
-        const long long _e = static_cast<long long>(expected);              \
-        if (_a != _e) {                                                     \
-            std::fprintf(stderr,                                            \
-                         "FAIL %s:%d: %s = %lld, expected %lld\n",          \
-                         __FILE__, __LINE__, #actual, _a, _e);              \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK_EQ_INT(actual, expected)                                                                           \
+    do {                                                                                                         \
+        const long long _a = static_cast<long long>(actual);                                                     \
+        const long long _e = static_cast<long long>(expected);                                                   \
+        if (_a != _e) {                                                                                          \
+            std::fprintf(stderr, "FAIL %s:%d: %s = %lld, expected %lld\n", __FILE__, __LINE__, #actual, _a, _e); \
+            ++g_failures;                                                                                        \
+        }                                                                                                        \
     } while (0)
 
-#define CHECK_STR_EQ(a, b)                                                  \
-    do {                                                                    \
-        const std::string _av = (a);                                        \
-        const std::string _bv = (b);                                        \
-        if (_av != _bv) {                                                   \
-            std::fprintf(stderr,                                            \
-                         "FAIL %s:%d: \"%s\" != \"%s\"\n",                  \
-                         __FILE__, __LINE__,                                \
-                         _av.c_str(), _bv.c_str());                         \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK_STR_EQ(a, b)                                                                                        \
+    do {                                                                                                          \
+        const std::string _av = (a);                                                                              \
+        const std::string _bv = (b);                                                                              \
+        if (_av != _bv) {                                                                                         \
+            std::fprintf(stderr, "FAIL %s:%d: \"%s\" != \"%s\"\n", __FILE__, __LINE__, _av.c_str(), _bv.c_str()); \
+            ++g_failures;                                                                                         \
+        }                                                                                                         \
     } while (0)
 
 bool file_exists(const std::string & path) {
-    struct stat st {};
+    struct stat st{};
     return ::stat(path.c_str(), &st) == 0;
 }
 
-const transcribe::qwen3_asr::QwenAsrModel *
-qwen_view(const struct transcribe_model * m) {
+const transcribe::qwen3_asr::QwenAsrModel * qwen_view(const struct transcribe_model * m) {
     return static_cast<const transcribe::qwen3_asr::QwenAsrModel *>(m);
 }
 
-} // namespace
+}  // namespace
 
 int main() {
     const char * env = std::getenv("TRANSCRIBE_QWEN3_ASR_0_6B_GGUF");
@@ -107,19 +98,16 @@ int main() {
     }
     const std::string fixture = env;
     if (!file_exists(fixture)) {
-        std::fprintf(stderr,
-                     "qwen3_asr_real_smoke_0_6b: file not found: %s\n",
-                     fixture.c_str());
+        std::fprintf(stderr, "qwen3_asr_real_smoke_0_6b: file not found: %s\n", fixture.c_str());
         return 77;
     }
 
-    transcribe_model_load_params mp; transcribe_model_load_params_init(&mp);
+    transcribe_model_load_params mp;
+    transcribe_model_load_params_init(&mp);
     struct transcribe_model * model = nullptr;
-    const transcribe_status st =
-        transcribe_model_load_file(fixture.c_str(), &mp, &model);
+    const transcribe_status   st    = transcribe_model_load_file(fixture.c_str(), &mp, &model);
     if (st != TRANSCRIBE_OK || model == nullptr) {
-        std::fprintf(stderr, "FAIL load: %s\n",
-                     transcribe_status_string(st));
+        std::fprintf(stderr, "FAIL load: %s\n", transcribe_status_string(st));
         return EXIT_FAILURE;
     }
 
@@ -129,15 +117,14 @@ int main() {
         const char * backend = transcribe_model_backend(model);
         CHECK(backend != nullptr && backend[0] != '\0');
         if (backend) {
-            std::fprintf(stderr,
-                         "qwen3_asr_real_smoke_0_6b: backend=%s\n", backend);
+            std::fprintf(stderr, "qwen3_asr_real_smoke_0_6b: backend=%s\n", backend);
         }
     }
 
-    transcribe_capabilities caps_buf; transcribe_capabilities_init(&caps_buf);
-    const bool caps_ok =
-        transcribe_model_get_capabilities(model, &caps_buf) == TRANSCRIBE_OK;
-    const transcribe_capabilities * caps = caps_ok ? &caps_buf : nullptr;
+    transcribe_capabilities caps_buf;
+    transcribe_capabilities_init(&caps_buf);
+    const bool                      caps_ok = transcribe_model_get_capabilities(model, &caps_buf) == TRANSCRIBE_OK;
+    const transcribe_capabilities * caps    = caps_ok ? &caps_buf : nullptr;
     CHECK(caps != nullptr);
     if (caps != nullptr) {
         CHECK_EQ_INT(caps->native_sample_rate, 16000);
@@ -156,51 +143,51 @@ int main() {
     const auto & hp = qm->hparams;
 
     // Encoder (Qwen3ASRAudioEncoder, 18 layers, d_model 896).
-    CHECK_EQ_INT(hp.enc_n_layers,          18);
-    CHECK_EQ_INT(hp.enc_d_model,           896);
-    CHECK_EQ_INT(hp.enc_n_heads,           14);
-    CHECK_EQ_INT(hp.enc_ffn_dim,           3584);
-    CHECK_EQ_INT(hp.enc_num_mel_bins,      128);
+    CHECK_EQ_INT(hp.enc_n_layers, 18);
+    CHECK_EQ_INT(hp.enc_d_model, 896);
+    CHECK_EQ_INT(hp.enc_n_heads, 14);
+    CHECK_EQ_INT(hp.enc_ffn_dim, 3584);
+    CHECK_EQ_INT(hp.enc_num_mel_bins, 128);
     CHECK_EQ_INT(hp.enc_downsample_hidden, 480);
-    CHECK_EQ_INT(hp.enc_output_dim,        1024);
+    CHECK_EQ_INT(hp.enc_output_dim, 1024);
     CHECK_EQ_INT(hp.enc_max_source_positions, 1500);
-    CHECK_EQ_INT(hp.enc_n_window,          50);
-    CHECK_EQ_INT(hp.enc_n_window_infer,    800);
-    CHECK_STR_EQ(hp.enc_activation,        "gelu");
+    CHECK_EQ_INT(hp.enc_n_window, 50);
+    CHECK_EQ_INT(hp.enc_n_window_infer, 800);
+    CHECK_STR_EQ(hp.enc_activation, "gelu");
 
     // LM (28-layer Qwen3 causal LM, GQA 16/8).
-    CHECK_EQ_INT(hp.dec_n_layers,     28);
-    CHECK_EQ_INT(hp.dec_hidden,       1024);
+    CHECK_EQ_INT(hp.dec_n_layers, 28);
+    CHECK_EQ_INT(hp.dec_hidden, 1024);
     CHECK_EQ_INT(hp.dec_intermediate, 3072);
-    CHECK_EQ_INT(hp.dec_n_heads,      16);
-    CHECK_EQ_INT(hp.dec_n_kv_heads,   8);
-    CHECK_EQ_INT(hp.dec_head_dim,     128);
-    CHECK_STR_EQ(hp.dec_hidden_act,   "silu");
+    CHECK_EQ_INT(hp.dec_n_heads, 16);
+    CHECK_EQ_INT(hp.dec_n_kv_heads, 8);
+    CHECK_EQ_INT(hp.dec_head_dim, 128);
+    CHECK_STR_EQ(hp.dec_hidden_act, "silu");
     CHECK(hp.dec_rms_norm_eps == 1e-6f);
-    CHECK(hp.dec_rope_theta   == 1000000.0f);
+    CHECK(hp.dec_rope_theta == 1000000.0f);
     CHECK_EQ_INT(hp.dec_rope_mrope_section_t, 24);
     CHECK_EQ_INT(hp.dec_rope_mrope_section_h, 20);
     CHECK_EQ_INT(hp.dec_rope_mrope_section_w, 20);
     CHECK(hp.dec_rope_mrope_interleaved);
     CHECK(hp.dec_tie_word_embeddings);
-    CHECK_EQ_INT(hp.dec_vocab_size,   151936);
+    CHECK_EQ_INT(hp.dec_vocab_size, 151936);
 
     // Audio-token injection ids.
     CHECK_EQ_INT(hp.audio_start_token_id, 151669);
-    CHECK_EQ_INT(hp.audio_end_token_id,   151670);
-    CHECK_EQ_INT(hp.audio_token_id,       151676);
+    CHECK_EQ_INT(hp.audio_end_token_id, 151670);
+    CHECK_EQ_INT(hp.audio_token_id, 151676);
 
     // Frontend (Whisper).
-    CHECK_STR_EQ(hp.fe_type,        "mel");
-    CHECK_EQ_INT(hp.fe_num_mels,     128);
-    CHECK_EQ_INT(hp.fe_sample_rate,  16000);
-    CHECK_EQ_INT(hp.fe_n_fft,        400);
-    CHECK_EQ_INT(hp.fe_win_length,   400);
-    CHECK_EQ_INT(hp.fe_hop_length,   160);
-    CHECK_STR_EQ(hp.fe_window,       "hann_periodic");
-    CHECK_STR_EQ(hp.fe_normalize,    "per_utterance");
-    CHECK_STR_EQ(hp.fe_pad_mode,     "reflect");
-    CHECK(hp.fe_dither       == 0.0f);
+    CHECK_STR_EQ(hp.fe_type, "mel");
+    CHECK_EQ_INT(hp.fe_num_mels, 128);
+    CHECK_EQ_INT(hp.fe_sample_rate, 16000);
+    CHECK_EQ_INT(hp.fe_n_fft, 400);
+    CHECK_EQ_INT(hp.fe_win_length, 400);
+    CHECK_EQ_INT(hp.fe_hop_length, 160);
+    CHECK_STR_EQ(hp.fe_window, "hann_periodic");
+    CHECK_STR_EQ(hp.fe_normalize, "per_utterance");
+    CHECK_STR_EQ(hp.fe_pad_mode, "reflect");
+    CHECK(hp.fe_dither == 0.0f);
     CHECK(hp.fe_pre_emphasis == 0.0f);
 
     CHECK_EQ_INT(qm->weights.enc_blocks.size(), 18);
@@ -258,8 +245,12 @@ int main() {
         const auto * q = qm->weights.dec_blocks[0].attn_q_norm;
         const auto * k = qm->weights.dec_blocks[0].attn_k_norm;
         CHECK(q != nullptr && k != nullptr);
-        if (q) CHECK_EQ_INT(q->ne[0], hp.dec_head_dim);
-        if (k) CHECK_EQ_INT(k->ne[0], hp.dec_head_dim);
+        if (q) {
+            CHECK_EQ_INT(q->ne[0], hp.dec_head_dim);
+        }
+        if (k) {
+            CHECK_EQ_INT(k->ne[0], hp.dec_head_dim);
+        }
     }
 
     // ---- Input-length contract (docs/input-limits.md) ----
@@ -268,12 +259,14 @@ int main() {
     // run is rejected with TRANSCRIBE_ERR_INPUT_TOO_LONG before decoding.
     CHECK(caps != nullptr && caps->max_audio_ms > 0);
     {
-        transcribe_session_params sp; transcribe_session_params_init(&sp);
+        transcribe_session_params sp;
+        transcribe_session_params_init(&sp);
         struct transcribe_session * s = nullptr;
 
         // Default session: effective limits come from the full model context.
         CHECK(transcribe_session_init(model, &sp, &s) == TRANSCRIBE_OK);
-        transcribe_session_limits lim; transcribe_session_limits_init(&lim);
+        transcribe_session_limits lim;
+        transcribe_session_limits_init(&lim);
         CHECK(transcribe_session_get_limits(s, &lim) == TRANSCRIBE_OK);
         CHECK_EQ_INT(lim.effective_n_ctx, hp.dec_max_position_embeddings);
         CHECK(lim.effective_max_audio_ms > 0);
@@ -284,7 +277,7 @@ int main() {
 
         // A lowered n_ctx lowers the effective audio bound and KV ceiling.
         sp.n_ctx = 4096;
-        s = nullptr;
+        s        = nullptr;
         CHECK(transcribe_session_init(model, &sp, &s) == TRANSCRIBE_OK);
         transcribe_session_limits_init(&lim);
         CHECK(transcribe_session_get_limits(s, &lim) == TRANSCRIBE_OK);
@@ -298,20 +291,19 @@ int main() {
         // up front with INPUT_TOO_LONG (synthetic silence — the gate keys on
         // sample count, not content). 1 s of 16 kHz mono silence.
         sp.n_ctx = 64;
-        s = nullptr;
+        s        = nullptr;
         CHECK(transcribe_session_init(model, &sp, &s) == TRANSCRIBE_OK);
-        std::vector<float> silence(16000, 0.0f);
-        const transcribe_status rst = transcribe_run(
-            s, silence.data(), (int) silence.size(), nullptr);
+        std::vector<float>      silence(16000, 0.0f);
+        const transcribe_status rst = transcribe_run(s, silence.data(), (int) silence.size(), nullptr);
         CHECK(rst == TRANSCRIBE_ERR_INPUT_TOO_LONG);
         CHECK(transcribe_was_truncated(s) == false);  // rejected, not truncated
 
         // Batch parity: run_batch enforces the same contract PER UTTERANCE —
         // the whole-batch call still returns OK, and each over-cap utterance
         // carries INPUT_TOO_LONG in its per-utterance status.
-        std::vector<float> sil2 = silence;
-        const float * pcms[2] = { silence.data(), sil2.data() };
-        const int     lens[2] = { (int) silence.size(), (int) sil2.size() };
+        std::vector<float> sil2    = silence;
+        const float *      pcms[2] = { silence.data(), sil2.data() };
+        const int          lens[2] = { (int) silence.size(), (int) sil2.size() };
         CHECK(transcribe_run_batch(s, pcms, lens, 2, nullptr) == TRANSCRIBE_OK);
         CHECK_EQ_INT(transcribe_batch_n_results(s), 2);
         CHECK(transcribe_batch_status(s, 0) == TRANSCRIBE_ERR_INPUT_TOO_LONG);
@@ -326,11 +318,13 @@ int main() {
         // f16 size for an f32 session (or vice-versa).
         {
             auto kv_bytes_for = [&](transcribe_kv_type t) -> long long {
-                transcribe_session_params spk; transcribe_session_params_init(&spk);
-                spk.kv_type = t;
+                transcribe_session_params spk;
+                transcribe_session_params_init(&spk);
+                spk.kv_type                    = t;
                 struct transcribe_session * sk = nullptr;
                 CHECK(transcribe_session_init(model, &spk, &sk) == TRANSCRIBE_OK);
-                transcribe_session_limits lk; transcribe_session_limits_init(&lk);
+                transcribe_session_limits lk;
+                transcribe_session_limits_init(&lk);
                 CHECK(transcribe_session_get_limits(sk, &lk) == TRANSCRIBE_OK);
                 const long long b = (long long) lk.max_kv_bytes;
                 transcribe_session_free(sk);
@@ -340,16 +334,15 @@ int main() {
             const long long kv_auto = kv_bytes_for(TRANSCRIBE_KV_TYPE_AUTO);
             const long long kv_f32  = kv_bytes_for(TRANSCRIBE_KV_TYPE_F32);
             CHECK(kv_f16 > 0);
-            CHECK_EQ_INT(kv_auto, kv_f16);       // AUTO == f16 for the KV cache
-            CHECK_EQ_INT(kv_f32, kv_f16 * 2);    // f32 is exactly 2x f16
+            CHECK_EQ_INT(kv_auto, kv_f16);     // AUTO == f16 for the KV cache
+            CHECK_EQ_INT(kv_f32, kv_f16 * 2);  // f32 is exactly 2x f16
         }
     }
 
     transcribe_model_free(model);
 
     if (g_failures > 0) {
-        std::fprintf(stderr,
-                     "qwen3_asr_real_smoke_0_6b: %d failures\n", g_failures);
+        std::fprintf(stderr, "qwen3_asr_real_smoke_0_6b: %d failures\n", g_failures);
         return EXIT_FAILURE;
     }
     std::fprintf(stdout, "qwen3_asr_real_smoke_0_6b: ok\n");
diff --git a/tests/qwen3_asr_real_smoke_1_7b.cpp b/tests/qwen3_asr_real_smoke_1_7b.cpp
index f9fd196e..44ee66c2 100644
--- a/tests/qwen3_asr_real_smoke_1_7b.cpp
+++ b/tests/qwen3_asr_real_smoke_1_7b.cpp
@@ -17,13 +17,11 @@
 // variant / backend sane, capabilities, hparams match the 1.7B
 // architecture, representative tensor shapes, block counts).
 
-#include "transcribe.h"
-
 #include "arch/qwen3_asr/qwen3_asr.h"
 #include "arch/qwen3_asr/weights.h"
-#include "transcribe-model.h"
-
 #include "ggml.h"
+#include "transcribe-model.h"
+#include "transcribe.h"
 
 #include <sys/stat.h>
 
@@ -36,51 +34,44 @@ namespace {
 
 int g_failures = 0;
 
-#define CHECK(cond)                                                         \
-    do {                                                                    \
-        if (!(cond)) {                                                      \
-            std::fprintf(stderr, "FAIL %s:%d: %s\n",                        \
-                         __FILE__, __LINE__, #cond);                        \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK(cond)                                                              \
+    do {                                                                         \
+        if (!(cond)) {                                                           \
+            std::fprintf(stderr, "FAIL %s:%d: %s\n", __FILE__, __LINE__, #cond); \
+            ++g_failures;                                                        \
+        }                                                                        \
     } while (0)
 
-#define CHECK_EQ_INT(actual, expected)                                      \
-    do {                                                                    \
-        const long long _a = static_cast<long long>(actual);                \
-        const long long _e = static_cast<long long>(expected);              \
-        if (_a != _e) {                                                     \
-            std::fprintf(stderr,                                            \
-                         "FAIL %s:%d: %s = %lld, expected %lld\n",          \
-                         __FILE__, __LINE__, #actual, _a, _e);              \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK_EQ_INT(actual, expected)                                                                           \
+    do {                                                                                                         \
+        const long long _a = static_cast<long long>(actual);                                                     \
+        const long long _e = static_cast<long long>(expected);                                                   \
+        if (_a != _e) {                                                                                          \
+            std::fprintf(stderr, "FAIL %s:%d: %s = %lld, expected %lld\n", __FILE__, __LINE__, #actual, _a, _e); \
+            ++g_failures;                                                                                        \
+        }                                                                                                        \
     } while (0)
 
-#define CHECK_STR_EQ(a, b)                                                  \
-    do {                                                                    \
-        const std::string _av = (a);                                        \
-        const std::string _bv = (b);                                        \
-        if (_av != _bv) {                                                   \
-            std::fprintf(stderr,                                            \
-                         "FAIL %s:%d: \"%s\" != \"%s\"\n",                  \
-                         __FILE__, __LINE__,                                \
-                         _av.c_str(), _bv.c_str());                         \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK_STR_EQ(a, b)                                                                                        \
+    do {                                                                                                          \
+        const std::string _av = (a);                                                                              \
+        const std::string _bv = (b);                                                                              \
+        if (_av != _bv) {                                                                                         \
+            std::fprintf(stderr, "FAIL %s:%d: \"%s\" != \"%s\"\n", __FILE__, __LINE__, _av.c_str(), _bv.c_str()); \
+            ++g_failures;                                                                                         \
+        }                                                                                                         \
     } while (0)
 
 bool file_exists(const std::string & path) {
-    struct stat st {};
+    struct stat st{};
     return ::stat(path.c_str(), &st) == 0;
 }
 
-const transcribe::qwen3_asr::QwenAsrModel *
-qwen_view(const struct transcribe_model * m) {
+const transcribe::qwen3_asr::QwenAsrModel * qwen_view(const struct transcribe_model * m) {
     return static_cast<const transcribe::qwen3_asr::QwenAsrModel *>(m);
 }
 
-} // namespace
+}  // namespace
 
 int main() {
     const char * env = std::getenv("TRANSCRIBE_QWEN3_ASR_1_7B_GGUF");
@@ -92,19 +83,16 @@ int main() {
     }
     const std::string fixture = env;
     if (!file_exists(fixture)) {
-        std::fprintf(stderr,
-                     "qwen3_asr_real_smoke_1_7b: file not found: %s\n",
-                     fixture.c_str());
+        std::fprintf(stderr, "qwen3_asr_real_smoke_1_7b: file not found: %s\n", fixture.c_str());
         return 77;
     }
 
-    transcribe_model_load_params mp; transcribe_model_load_params_init(&mp);
+    transcribe_model_load_params mp;
+    transcribe_model_load_params_init(&mp);
     struct transcribe_model * model = nullptr;
-    const transcribe_status st =
-        transcribe_model_load_file(fixture.c_str(), &mp, &model);
+    const transcribe_status   st    = transcribe_model_load_file(fixture.c_str(), &mp, &model);
     if (st != TRANSCRIBE_OK || model == nullptr) {
-        std::fprintf(stderr, "FAIL load: %s\n",
-                     transcribe_status_string(st));
+        std::fprintf(stderr, "FAIL load: %s\n", transcribe_status_string(st));
         return EXIT_FAILURE;
     }
 
@@ -114,15 +102,14 @@ int main() {
         const char * backend = transcribe_model_backend(model);
         CHECK(backend != nullptr && backend[0] != '\0');
         if (backend) {
-            std::fprintf(stderr,
-                         "qwen3_asr_real_smoke_1_7b: backend=%s\n", backend);
+            std::fprintf(stderr, "qwen3_asr_real_smoke_1_7b: backend=%s\n", backend);
         }
     }
 
-    transcribe_capabilities caps_buf; transcribe_capabilities_init(&caps_buf);
-    const bool caps_ok =
-        transcribe_model_get_capabilities(model, &caps_buf) == TRANSCRIBE_OK;
-    const transcribe_capabilities * caps = caps_ok ? &caps_buf : nullptr;
+    transcribe_capabilities caps_buf;
+    transcribe_capabilities_init(&caps_buf);
+    const bool                      caps_ok = transcribe_model_get_capabilities(model, &caps_buf) == TRANSCRIBE_OK;
+    const transcribe_capabilities * caps    = caps_ok ? &caps_buf : nullptr;
     CHECK(caps != nullptr);
     if (caps != nullptr) {
         CHECK_EQ_INT(caps->native_sample_rate, 16000);
@@ -138,51 +125,51 @@ int main() {
     const auto & hp = qm->hparams;
 
     // Encoder (Qwen3ASRAudioEncoder, 24 layers, d_model 1024).
-    CHECK_EQ_INT(hp.enc_n_layers,              24);
-    CHECK_EQ_INT(hp.enc_d_model,               1024);
-    CHECK_EQ_INT(hp.enc_n_heads,               16);
-    CHECK_EQ_INT(hp.enc_ffn_dim,               4096);
-    CHECK_EQ_INT(hp.enc_num_mel_bins,          128);
-    CHECK_EQ_INT(hp.enc_downsample_hidden,     480);
-    CHECK_EQ_INT(hp.enc_output_dim,            2048);
-    CHECK_EQ_INT(hp.enc_max_source_positions,  1500);
-    CHECK_EQ_INT(hp.enc_n_window,              50);
-    CHECK_EQ_INT(hp.enc_n_window_infer,        800);
-    CHECK_STR_EQ(hp.enc_activation,            "gelu");
+    CHECK_EQ_INT(hp.enc_n_layers, 24);
+    CHECK_EQ_INT(hp.enc_d_model, 1024);
+    CHECK_EQ_INT(hp.enc_n_heads, 16);
+    CHECK_EQ_INT(hp.enc_ffn_dim, 4096);
+    CHECK_EQ_INT(hp.enc_num_mel_bins, 128);
+    CHECK_EQ_INT(hp.enc_downsample_hidden, 480);
+    CHECK_EQ_INT(hp.enc_output_dim, 2048);
+    CHECK_EQ_INT(hp.enc_max_source_positions, 1500);
+    CHECK_EQ_INT(hp.enc_n_window, 50);
+    CHECK_EQ_INT(hp.enc_n_window_infer, 800);
+    CHECK_STR_EQ(hp.enc_activation, "gelu");
 
     // LM (28-layer Qwen3 causal LM, GQA 16/8, wider hidden).
-    CHECK_EQ_INT(hp.dec_n_layers,     28);
-    CHECK_EQ_INT(hp.dec_hidden,       2048);
+    CHECK_EQ_INT(hp.dec_n_layers, 28);
+    CHECK_EQ_INT(hp.dec_hidden, 2048);
     CHECK_EQ_INT(hp.dec_intermediate, 6144);
-    CHECK_EQ_INT(hp.dec_n_heads,      16);
-    CHECK_EQ_INT(hp.dec_n_kv_heads,   8);
-    CHECK_EQ_INT(hp.dec_head_dim,     128);
-    CHECK_STR_EQ(hp.dec_hidden_act,   "silu");
+    CHECK_EQ_INT(hp.dec_n_heads, 16);
+    CHECK_EQ_INT(hp.dec_n_kv_heads, 8);
+    CHECK_EQ_INT(hp.dec_head_dim, 128);
+    CHECK_STR_EQ(hp.dec_hidden_act, "silu");
     CHECK(hp.dec_rms_norm_eps == 1e-6f);
-    CHECK(hp.dec_rope_theta   == 1000000.0f);
+    CHECK(hp.dec_rope_theta == 1000000.0f);
     CHECK_EQ_INT(hp.dec_rope_mrope_section_t, 24);
     CHECK_EQ_INT(hp.dec_rope_mrope_section_h, 20);
     CHECK_EQ_INT(hp.dec_rope_mrope_section_w, 20);
     CHECK(hp.dec_rope_mrope_interleaved);
     CHECK(hp.dec_tie_word_embeddings);
-    CHECK_EQ_INT(hp.dec_vocab_size,   151936);
+    CHECK_EQ_INT(hp.dec_vocab_size, 151936);
 
     // Audio-token injection ids (same across variants).
     CHECK_EQ_INT(hp.audio_start_token_id, 151669);
-    CHECK_EQ_INT(hp.audio_end_token_id,   151670);
-    CHECK_EQ_INT(hp.audio_token_id,       151676);
+    CHECK_EQ_INT(hp.audio_end_token_id, 151670);
+    CHECK_EQ_INT(hp.audio_token_id, 151676);
 
     // Frontend (Whisper; same across variants).
-    CHECK_STR_EQ(hp.fe_type,        "mel");
-    CHECK_EQ_INT(hp.fe_num_mels,     128);
-    CHECK_EQ_INT(hp.fe_sample_rate,  16000);
-    CHECK_EQ_INT(hp.fe_n_fft,        400);
-    CHECK_EQ_INT(hp.fe_win_length,   400);
-    CHECK_EQ_INT(hp.fe_hop_length,   160);
-    CHECK_STR_EQ(hp.fe_window,       "hann_periodic");
-    CHECK_STR_EQ(hp.fe_normalize,    "per_utterance");
-    CHECK_STR_EQ(hp.fe_pad_mode,     "reflect");
-    CHECK(hp.fe_dither       == 0.0f);
+    CHECK_STR_EQ(hp.fe_type, "mel");
+    CHECK_EQ_INT(hp.fe_num_mels, 128);
+    CHECK_EQ_INT(hp.fe_sample_rate, 16000);
+    CHECK_EQ_INT(hp.fe_n_fft, 400);
+    CHECK_EQ_INT(hp.fe_win_length, 400);
+    CHECK_EQ_INT(hp.fe_hop_length, 160);
+    CHECK_STR_EQ(hp.fe_window, "hann_periodic");
+    CHECK_STR_EQ(hp.fe_normalize, "per_utterance");
+    CHECK_STR_EQ(hp.fe_pad_mode, "reflect");
+    CHECK(hp.fe_dither == 0.0f);
     CHECK(hp.fe_pre_emphasis == 0.0f);
 
     CHECK_EQ_INT(qm->weights.enc_blocks.size(), 24);
@@ -240,15 +227,18 @@ int main() {
         const auto * q = qm->weights.dec_blocks[0].attn_q_norm;
         const auto * k = qm->weights.dec_blocks[0].attn_k_norm;
         CHECK(q != nullptr && k != nullptr);
-        if (q) CHECK_EQ_INT(q->ne[0], hp.dec_head_dim);
-        if (k) CHECK_EQ_INT(k->ne[0], hp.dec_head_dim);
+        if (q) {
+            CHECK_EQ_INT(q->ne[0], hp.dec_head_dim);
+        }
+        if (k) {
+            CHECK_EQ_INT(k->ne[0], hp.dec_head_dim);
+        }
     }
 
     transcribe_model_free(model);
 
     if (g_failures > 0) {
-        std::fprintf(stderr,
-                     "qwen3_asr_real_smoke_1_7b: %d failures\n", g_failures);
+        std::fprintf(stderr, "qwen3_asr_real_smoke_1_7b: %d failures\n", g_failures);
         return EXIT_FAILURE;
     }
     std::fprintf(stdout, "qwen3_asr_real_smoke_1_7b: ok\n");
diff --git a/tests/qwen3_asr_smoke.cpp b/tests/qwen3_asr_smoke.cpp
index 0b150492..98ac5ba2 100644
--- a/tests/qwen3_asr_smoke.cpp
+++ b/tests/qwen3_asr_smoke.cpp
@@ -43,14 +43,12 @@
 //   - qwen3_asr_e2e_smoke.cpp:              env-gated public-ABI
 //                                           transcription round-trip.
 
-#include "transcribe.h"
-
 #include "arch/qwen3_asr/qwen3_asr.h"
 #include "arch/qwen3_asr/weights.h"
-#include "transcribe-model.h"
-
-#include "ggml.h"
 #include "ggml-backend.h"
+#include "ggml.h"
+#include "transcribe-model.h"
+#include "transcribe.h"
 
 #include <sys/stat.h>
 
@@ -60,7 +58,7 @@
 #include <string>
 
 #ifndef TRANSCRIBE_TEST_FIXTURES_DIR
-#  error "TRANSCRIBE_TEST_FIXTURES_DIR must be defined by the build system"
+#    error "TRANSCRIBE_TEST_FIXTURES_DIR must be defined by the build system"
 #endif
 
 namespace {
@@ -69,51 +67,44 @@ const std::string g_fixtures_dir = TRANSCRIBE_TEST_FIXTURES_DIR;
 
 int g_failures = 0;
 
-#define CHECK(cond)                                                         \
-    do {                                                                    \
-        if (!(cond)) {                                                      \
-            std::fprintf(stderr, "FAIL %s:%d: %s\n",                        \
-                         __FILE__, __LINE__, #cond);                        \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK(cond)                                                              \
+    do {                                                                         \
+        if (!(cond)) {                                                           \
+            std::fprintf(stderr, "FAIL %s:%d: %s\n", __FILE__, __LINE__, #cond); \
+            ++g_failures;                                                        \
+        }                                                                        \
     } while (0)
 
-#define CHECK_EQ_INT(actual, expected)                                      \
-    do {                                                                    \
-        const long long _a = static_cast<long long>(actual);                \
-        const long long _e = static_cast<long long>(expected);              \
-        if (_a != _e) {                                                     \
-            std::fprintf(stderr,                                            \
-                         "FAIL %s:%d: %s = %lld, expected %lld\n",          \
-                         __FILE__, __LINE__, #actual, _a, _e);              \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK_EQ_INT(actual, expected)                                                                           \
+    do {                                                                                                         \
+        const long long _a = static_cast<long long>(actual);                                                     \
+        const long long _e = static_cast<long long>(expected);                                                   \
+        if (_a != _e) {                                                                                          \
+            std::fprintf(stderr, "FAIL %s:%d: %s = %lld, expected %lld\n", __FILE__, __LINE__, #actual, _a, _e); \
+            ++g_failures;                                                                                        \
+        }                                                                                                        \
     } while (0)
 
-#define CHECK_STR_EQ(a, b)                                                  \
-    do {                                                                    \
-        const std::string _av = (a);                                        \
-        const std::string _bv = (b);                                        \
-        if (_av != _bv) {                                                   \
-            std::fprintf(stderr,                                            \
-                         "FAIL %s:%d: \"%s\" != \"%s\"\n",                  \
-                         __FILE__, __LINE__,                                \
-                         _av.c_str(), _bv.c_str());                         \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK_STR_EQ(a, b)                                                                                        \
+    do {                                                                                                          \
+        const std::string _av = (a);                                                                              \
+        const std::string _bv = (b);                                                                              \
+        if (_av != _bv) {                                                                                         \
+            std::fprintf(stderr, "FAIL %s:%d: \"%s\" != \"%s\"\n", __FILE__, __LINE__, _av.c_str(), _bv.c_str()); \
+            ++g_failures;                                                                                         \
+        }                                                                                                         \
     } while (0)
 
 bool file_exists(const std::string & path) {
-    struct stat st {};
+    struct stat st{};
     return ::stat(path.c_str(), &st) == 0;
 }
 
-const transcribe::qwen3_asr::QwenAsrModel *
-qwen_view(const struct transcribe_model * m) {
+const transcribe::qwen3_asr::QwenAsrModel * qwen_view(const struct transcribe_model * m) {
     return static_cast<const transcribe::qwen3_asr::QwenAsrModel *>(m);
 }
 
-} // namespace
+}  // namespace
 
 int main() {
     const std::string fixture = g_fixtures_dir + "/arch_qwen3_asr_minimal.gguf";
@@ -124,23 +115,21 @@ int main() {
                      "regenerate with:\n"
                      "  cmake --build build --target fixtures\n",
                      fixture.c_str());
-        return 77; // CTest "skipped"
+        return 77;  // CTest "skipped"
     }
 
     // Force CPU backend: ffn_gate_up packing at load does a CPU
     // round-trip (ggml_backend_tensor_get + _set). Keeping the test on
     // CPU keeps the dependency narrow — no Metal/Vulkan runtime
     // required for default ctest.
-    transcribe_model_load_params mp; transcribe_model_load_params_init(&mp);
-    mp.backend = TRANSCRIBE_BACKEND_CPU;
+    transcribe_model_load_params mp;
+    transcribe_model_load_params_init(&mp);
+    mp.backend                      = TRANSCRIBE_BACKEND_CPU;
     struct transcribe_model * model = nullptr;
 
-    const transcribe_status st =
-        transcribe_model_load_file(fixture.c_str(), &mp, &model);
+    const transcribe_status st = transcribe_model_load_file(fixture.c_str(), &mp, &model);
     if (st != TRANSCRIBE_OK) {
-        std::fprintf(stderr,
-                     "FAIL load: expected OK, got %s\n",
-                     transcribe_status_string(st));
+        std::fprintf(stderr, "FAIL load: expected OK, got %s\n", transcribe_status_string(st));
         return EXIT_FAILURE;
     }
     if (model == nullptr) {
@@ -153,17 +142,14 @@ int main() {
         std::fprintf(stderr, "FAIL: arch_string != qwen3_asr\n");
         ++g_failures;
     }
-    if (std::strcmp(transcribe_model_variant_string(model),
-                    "qwen3-asr-toy") != 0)
-    {
+    if (std::strcmp(transcribe_model_variant_string(model), "qwen3-asr-toy") != 0) {
         std::fprintf(stderr, "FAIL: variant_string != qwen3-asr-toy\n");
         ++g_failures;
     }
     {
         const char * backend = transcribe_model_backend(model);
         if (backend == nullptr || backend[0] == '\0') {
-            std::fprintf(stderr,
-                         "FAIL: backend = \"\" after load, expected non-empty\n");
+            std::fprintf(stderr, "FAIL: backend = \"\" after load, expected non-empty\n");
             ++g_failures;
         }
     }
@@ -172,10 +158,10 @@ int main() {
     // trip; translate stays false (family invariant); max_timestamp
     // stays NONE (alignment is not exposed for this family).
     {
-        transcribe_capabilities caps_buf; transcribe_capabilities_init(&caps_buf);
-        const bool caps_ok =
-            transcribe_model_get_capabilities(model, &caps_buf) == TRANSCRIBE_OK;
-        const auto * caps = caps_ok ? &caps_buf : nullptr;
+        transcribe_capabilities caps_buf;
+        transcribe_capabilities_init(&caps_buf);
+        const bool   caps_ok = transcribe_model_get_capabilities(model, &caps_buf) == TRANSCRIBE_OK;
+        const auto * caps    = caps_ok ? &caps_buf : nullptr;
         CHECK(caps != nullptr);
         CHECK_EQ_INT(caps->native_sample_rate, 16000);
         CHECK(caps->supports_translate == false);
@@ -193,45 +179,45 @@ int main() {
 
     // ----- Hparams match the fixture -----
     const auto & hp = qm->hparams;
-    CHECK_EQ_INT(hp.enc_n_layers,              2);
-    CHECK_EQ_INT(hp.enc_d_model,               16);
-    CHECK_EQ_INT(hp.enc_n_heads,               2);
-    CHECK_EQ_INT(hp.enc_ffn_dim,               32);
-    CHECK_EQ_INT(hp.enc_num_mel_bins,          8);
-    CHECK_EQ_INT(hp.enc_downsample_hidden,     16);
-    CHECK_EQ_INT(hp.enc_output_dim,            16);
-    CHECK_EQ_INT(hp.enc_max_source_positions,  64);
-    CHECK_EQ_INT(hp.enc_n_window,              2);
-    CHECK_EQ_INT(hp.enc_n_window_infer,        4);
-    CHECK_EQ_INT(hp.enc_conv_chunksize,        8);
-    CHECK_STR_EQ(hp.enc_activation,            "gelu");
-
-    CHECK_EQ_INT(hp.dec_n_layers,                2);
-    CHECK_EQ_INT(hp.dec_hidden,                  16);
-    CHECK_EQ_INT(hp.dec_intermediate,            32);
-    CHECK_EQ_INT(hp.dec_n_heads,                 2);
-    CHECK_EQ_INT(hp.dec_n_kv_heads,              1);
-    CHECK_EQ_INT(hp.dec_head_dim,                8);
-    CHECK_STR_EQ(hp.dec_hidden_act,              "silu");
-    CHECK_EQ_INT(hp.dec_rope_mrope_section_t,    2);
-    CHECK_EQ_INT(hp.dec_rope_mrope_section_h,    1);
-    CHECK_EQ_INT(hp.dec_rope_mrope_section_w,    1);
+    CHECK_EQ_INT(hp.enc_n_layers, 2);
+    CHECK_EQ_INT(hp.enc_d_model, 16);
+    CHECK_EQ_INT(hp.enc_n_heads, 2);
+    CHECK_EQ_INT(hp.enc_ffn_dim, 32);
+    CHECK_EQ_INT(hp.enc_num_mel_bins, 8);
+    CHECK_EQ_INT(hp.enc_downsample_hidden, 16);
+    CHECK_EQ_INT(hp.enc_output_dim, 16);
+    CHECK_EQ_INT(hp.enc_max_source_positions, 64);
+    CHECK_EQ_INT(hp.enc_n_window, 2);
+    CHECK_EQ_INT(hp.enc_n_window_infer, 4);
+    CHECK_EQ_INT(hp.enc_conv_chunksize, 8);
+    CHECK_STR_EQ(hp.enc_activation, "gelu");
+
+    CHECK_EQ_INT(hp.dec_n_layers, 2);
+    CHECK_EQ_INT(hp.dec_hidden, 16);
+    CHECK_EQ_INT(hp.dec_intermediate, 32);
+    CHECK_EQ_INT(hp.dec_n_heads, 2);
+    CHECK_EQ_INT(hp.dec_n_kv_heads, 1);
+    CHECK_EQ_INT(hp.dec_head_dim, 8);
+    CHECK_STR_EQ(hp.dec_hidden_act, "silu");
+    CHECK_EQ_INT(hp.dec_rope_mrope_section_t, 2);
+    CHECK_EQ_INT(hp.dec_rope_mrope_section_h, 1);
+    CHECK_EQ_INT(hp.dec_rope_mrope_section_w, 1);
     CHECK(hp.dec_rope_mrope_interleaved == true);
     CHECK_EQ_INT(hp.dec_max_position_embeddings, 128);
     CHECK(hp.dec_tie_word_embeddings == true);
-    CHECK_EQ_INT(hp.dec_vocab_size,              32);
+    CHECK_EQ_INT(hp.dec_vocab_size, 32);
 
     CHECK_EQ_INT(hp.audio_start_token_id, 16);
-    CHECK_EQ_INT(hp.audio_end_token_id,   17);
-    CHECK_EQ_INT(hp.audio_token_id,       18);
+    CHECK_EQ_INT(hp.audio_end_token_id, 17);
+    CHECK_EQ_INT(hp.audio_token_id, 18);
 
     // Frontend: a subset of the full block; the full read is exercised
     // by the MelConfig passthrough inside load(). Just confirm the
     // hparams reached this struct.
-    CHECK_STR_EQ(hp.fe_type,      "mel");
-    CHECK_EQ_INT(hp.fe_num_mels,  8);
+    CHECK_STR_EQ(hp.fe_type, "mel");
+    CHECK_EQ_INT(hp.fe_num_mels, 8);
     CHECK_EQ_INT(hp.fe_sample_rate, 16000);
-    CHECK_STR_EQ(hp.fe_window,    "hann_periodic");
+    CHECK_STR_EQ(hp.fe_window, "hann_periodic");
     CHECK_STR_EQ(hp.fe_normalize, "per_utterance");
 
     // Tokenizer vocab size drives hp.vocab_size + the dec_vocab_size
@@ -245,22 +231,22 @@ int main() {
     // ----- Chat-template token ids resolved at load -----
     {
         const auto & ct = qm->chat_tokens;
-        CHECK_EQ_INT(ct.im_start,        2);
-        CHECK_EQ_INT(ct.im_end,          3);
-        CHECK_EQ_INT(ct.newline,         4);
-        CHECK_EQ_INT(ct.role_system,     5);
-        CHECK_EQ_INT(ct.role_user,       6);
-        CHECK_EQ_INT(ct.role_assistant,  7);
+        CHECK_EQ_INT(ct.im_start, 2);
+        CHECK_EQ_INT(ct.im_end, 3);
+        CHECK_EQ_INT(ct.newline, 4);
+        CHECK_EQ_INT(ct.role_system, 5);
+        CHECK_EQ_INT(ct.role_user, 6);
+        CHECK_EQ_INT(ct.role_assistant, 7);
     }
 
     // ----- Encoder subsample slots populated -----
     const auto & es = qm->weights.enc_subsample;
-    CHECK(es.conv0_w  != nullptr);
-    CHECK(es.conv0_b  != nullptr);
-    CHECK(es.conv1_w  != nullptr);
-    CHECK(es.conv1_b  != nullptr);
-    CHECK(es.conv2_w  != nullptr);
-    CHECK(es.conv2_b  != nullptr);
+    CHECK(es.conv0_w != nullptr);
+    CHECK(es.conv0_b != nullptr);
+    CHECK(es.conv1_w != nullptr);
+    CHECK(es.conv1_b != nullptr);
+    CHECK(es.conv2_w != nullptr);
+    CHECK(es.conv2_b != nullptr);
     CHECK(es.conv_out != nullptr);
 
     // ----- Encoder block slots populated for every layer -----
@@ -269,50 +255,50 @@ int main() {
         const auto & b = qm->weights.enc_blocks[i];
         CHECK(b.norm_attn_w != nullptr);
         CHECK(b.norm_attn_b != nullptr);
-        CHECK(b.attn_q_w    != nullptr);
-        CHECK(b.attn_q_b    != nullptr);
-        CHECK(b.attn_k_w    != nullptr);
-        CHECK(b.attn_k_b    != nullptr);
-        CHECK(b.attn_v_w    != nullptr);
-        CHECK(b.attn_v_b    != nullptr);
-        CHECK(b.attn_out_w  != nullptr);
-        CHECK(b.attn_out_b  != nullptr);
-        CHECK(b.norm_ffn_w  != nullptr);
-        CHECK(b.norm_ffn_b  != nullptr);
-        CHECK(b.fc1_w       != nullptr);
-        CHECK(b.fc1_b       != nullptr);
-        CHECK(b.fc2_w       != nullptr);
-        CHECK(b.fc2_b       != nullptr);
+        CHECK(b.attn_q_w != nullptr);
+        CHECK(b.attn_q_b != nullptr);
+        CHECK(b.attn_k_w != nullptr);
+        CHECK(b.attn_k_b != nullptr);
+        CHECK(b.attn_v_w != nullptr);
+        CHECK(b.attn_v_b != nullptr);
+        CHECK(b.attn_out_w != nullptr);
+        CHECK(b.attn_out_b != nullptr);
+        CHECK(b.norm_ffn_w != nullptr);
+        CHECK(b.norm_ffn_b != nullptr);
+        CHECK(b.fc1_w != nullptr);
+        CHECK(b.fc1_b != nullptr);
+        CHECK(b.fc2_w != nullptr);
+        CHECK(b.fc2_b != nullptr);
     }
 
     // ----- Encoder head slots populated -----
     const auto & eh = qm->weights.enc_head;
     CHECK(eh.ln_post_w != nullptr);
     CHECK(eh.ln_post_b != nullptr);
-    CHECK(eh.proj1_w   != nullptr);
-    CHECK(eh.proj1_b   != nullptr);
-    CHECK(eh.proj2_w   != nullptr);
-    CHECK(eh.proj2_b   != nullptr);
+    CHECK(eh.proj1_w != nullptr);
+    CHECK(eh.proj1_b != nullptr);
+    CHECK(eh.proj2_w != nullptr);
+    CHECK(eh.proj2_b != nullptr);
 
     // ----- Decoder embed (tied to lm_head) + final norm -----
     CHECK(qm->weights.dec_embed.token_w != nullptr);
-    CHECK(qm->weights.dec_final.norm_w  != nullptr);
+    CHECK(qm->weights.dec_final.norm_w != nullptr);
 
     // ----- Decoder block slots populated for every layer -----
     CHECK_EQ_INT(qm->weights.dec_blocks.size(), 2);
     for (size_t i = 0; i < qm->weights.dec_blocks.size(); ++i) {
         const auto & b = qm->weights.dec_blocks[i];
         CHECK(b.norm_attn_w != nullptr);
-        CHECK(b.norm_ffn_w  != nullptr);
-        CHECK(b.attn_q_w    != nullptr);
-        CHECK(b.attn_k_w    != nullptr);
-        CHECK(b.attn_v_w    != nullptr);
-        CHECK(b.attn_o_w    != nullptr);
+        CHECK(b.norm_ffn_w != nullptr);
+        CHECK(b.attn_q_w != nullptr);
+        CHECK(b.attn_k_w != nullptr);
+        CHECK(b.attn_v_w != nullptr);
+        CHECK(b.attn_o_w != nullptr);
         CHECK(b.attn_q_norm != nullptr);
         CHECK(b.attn_k_norm != nullptr);
-        CHECK(b.ffn_gate_w  != nullptr);
-        CHECK(b.ffn_up_w    != nullptr);
-        CHECK(b.ffn_down_w  != nullptr);
+        CHECK(b.ffn_gate_w != nullptr);
+        CHECK(b.ffn_up_w != nullptr);
+        CHECK(b.ffn_down_w != nullptr);
         // Packed gate+up: filled by the post-load packing step in
         // model.cpp. Must be non-null if the step ran.
         CHECK(b.ffn_gate_up_w != nullptr);
@@ -363,8 +349,7 @@ int main() {
         float v = 0.0f;
         ggml_backend_tensor_get(es.conv0_w, &v, 0, sizeof(float));
         if (v != 0.0f) {
-            std::fprintf(stderr,
-                         "FAIL es.conv0_w[0]: got %f, expected 0.0\n", v);
+            std::fprintf(stderr, "FAIL es.conv0_w[0]: got %f, expected 0.0\n", v);
             ++g_failures;
         }
     }
@@ -372,8 +357,7 @@ int main() {
         float v = 0.0f;
         ggml_backend_tensor_get(es.conv0_b, &v, 0, sizeof(float));
         if (v != 1.0f) {
-            std::fprintf(stderr,
-                         "FAIL es.conv0_b[0]: got %f, expected 1.0\n", v);
+            std::fprintf(stderr, "FAIL es.conv0_b[0]: got %f, expected 1.0\n", v);
             ++g_failures;
         }
     }
diff --git a/tests/run_dispatch_unit.cpp b/tests/run_dispatch_unit.cpp
index b2c369d0..c78913a4 100644
--- a/tests/run_dispatch_unit.cpp
+++ b/tests/run_dispatch_unit.cpp
@@ -1,8 +1,8 @@
 // run_dispatch_unit.cpp - dispatcher-level transcribe_run behavior tests.
 
-#include "transcribe-session.h"
 #include "transcribe-arch.h"
 #include "transcribe-model.h"
+#include "transcribe-session.h"
 #include "transcribe.h"
 
 #include <cstdio>
@@ -13,34 +13,35 @@ namespace {
 
 int g_failures = 0;
 
-#define CHECK(cond)                                                         \
-    do {                                                                    \
-        if (!(cond)) {                                                      \
-            std::fprintf(stderr, "FAIL %s:%d: %s\n",                        \
-                         __FILE__, __LINE__, #cond);                        \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK(cond)                                                              \
+    do {                                                                         \
+        if (!(cond)) {                                                           \
+            std::fprintf(stderr, "FAIL %s:%d: %s\n", __FILE__, __LINE__, #cond); \
+            ++g_failures;                                                        \
+        }                                                                        \
     } while (0)
 
 // Existing behavior: with no arch->run wired, transcribe_run clears the
 // previous snapshot and returns NOT_IMPLEMENTED.
 void test_no_run_hook_clears_and_not_implemented() {
     transcribe_session session;
-    session.full_text = "stale";
-    session.has_result = true;
-    session.t_mel_us = 1000;
+    session.full_text   = "stale";
+    session.has_result  = true;
+    session.t_mel_us    = 1000;
     session.t_encode_us = 2000;
     session.t_decode_us = 3000;
 
-    float pcm = 0.0f;
-    transcribe_run_params params; transcribe_run_params_init(&params);
+    float                 pcm = 0.0f;
+    transcribe_run_params params;
+    transcribe_run_params_init(&params);
     const transcribe_status st = transcribe_run(&session, &pcm, 1, &params);
 
     CHECK(st == TRANSCRIBE_ERR_NOT_IMPLEMENTED);
     CHECK(!session.has_result);
     CHECK(session.full_text.empty());
 
-    transcribe_timings t; transcribe_timings_init(&t);
+    transcribe_timings t;
+    transcribe_timings_init(&t);
     CHECK(transcribe_get_timings(&session, &t) == TRANSCRIBE_OK);
     CHECK(t.mel_ms == 0.0f);
     CHECK(t.encode_ms == 0.0f);
@@ -56,55 +57,46 @@ void test_no_run_hook_clears_and_not_implemented() {
 
 constexpr uint32_t kFakeRunKind = 0xF00D;
 
-bool g_run_called = false;
+bool              g_run_called          = false;
 transcribe_status g_run_validate_status = TRANSCRIBE_OK;
 
-transcribe_status fake_run(
-    transcribe_session *        session,
-    const float *               pcm,
-    int                         n_samples,
-    const transcribe_run_params * params)
-{
-    (void)pcm;
-    (void)n_samples;
-    (void)params;
-    g_run_called = true;
+transcribe_status fake_run(transcribe_session *          session,
+                           const float *                 pcm,
+                           int                           n_samples,
+                           const transcribe_run_params * params) {
+    (void) pcm;
+    (void) n_samples;
+    (void) params;
+    g_run_called        = true;
     // A successful run installs a fresh result.
-    session->full_text = "fresh result";
+    session->full_text  = "fresh result";
     session->has_result = true;
     return TRANSCRIBE_OK;
 }
 
-bool fake_accepts_run_kind(
-    const transcribe_model * model,
-    transcribe_ext_slot      slot,
-    uint32_t                 kind)
-{
-    (void)model;
+bool fake_accepts_run_kind(const transcribe_model * model, transcribe_ext_slot slot, uint32_t kind) {
+    (void) model;
     return slot == TRANSCRIBE_EXT_SLOT_RUN && kind == kFakeRunKind;
 }
 
-transcribe_status fake_run_validate(
-    const transcribe_session *   ctx,
-    const transcribe_run_params * params)
-{
-    (void)ctx;
-    (void)params;
+transcribe_status fake_run_validate(const transcribe_session * ctx, const transcribe_run_params * params) {
+    (void) ctx;
+    (void) params;
     return g_run_validate_status;
 }
 
 const transcribe::Arch & run_validate_arch() {
     static const transcribe::Arch arch = {
         "fake-run",
-        nullptr,                 // load
-        nullptr,                 // init_context
+        nullptr,  // load
+        nullptr,  // init_context
         fake_run,
-        nullptr,                 // run_batch
-        nullptr,                 // stream_validate
-        nullptr,                 // stream_begin
-        nullptr,                 // stream_feed
-        nullptr,                 // stream_finalize
-        nullptr,                 // stream_reset
+        nullptr,  // run_batch
+        nullptr,  // stream_validate
+        nullptr,  // stream_begin
+        nullptr,  // stream_feed
+        nullptr,  // stream_finalize
+        nullptr,  // stream_reset
         fake_accepts_run_kind,
         fake_run_validate,
     };
@@ -118,22 +110,23 @@ void test_run_validate_failure_preserves_snapshot() {
     model.arch = &run_validate_arch();
 
     transcribe_session session;
-    session.model = &model;
-    session.full_text = "previous result";
+    session.model      = &model;
+    session.full_text  = "previous result";
     session.has_result = true;
 
     transcribe_ext ext;
-    ext.size = sizeof(transcribe_ext);   // passes the generic header check
-    ext.kind = kFakeRunKind;             // accepted by the arch
+    ext.size = sizeof(transcribe_ext);  // passes the generic header check
+    ext.kind = kFakeRunKind;            // accepted by the arch
 
-    transcribe_run_params params; transcribe_run_params_init(&params);
+    transcribe_run_params params;
+    transcribe_run_params_init(&params);
     params.family = &ext;
 
-    g_run_called = false;
+    g_run_called          = false;
     g_run_validate_status = TRANSCRIBE_ERR_BAD_STRUCT_SIZE;
 
-    float pcm = 0.0f;
-    const transcribe_status st = transcribe_run(&session, &pcm, 1, &params);
+    float                   pcm = 0.0f;
+    const transcribe_status st  = transcribe_run(&session, &pcm, 1, &params);
 
     // Family preflight rejected the call BEFORE the snapshot was cleared
     // and BEFORE the run hook ran. The prior transcript survives intact.
@@ -151,22 +144,23 @@ void test_run_validate_success_clears_and_runs() {
     model.arch = &run_validate_arch();
 
     transcribe_session session;
-    session.model = &model;
-    session.full_text = "previous result";
+    session.model      = &model;
+    session.full_text  = "previous result";
     session.has_result = true;
 
     transcribe_ext ext;
     ext.size = sizeof(transcribe_ext);
     ext.kind = kFakeRunKind;
 
-    transcribe_run_params params; transcribe_run_params_init(&params);
+    transcribe_run_params params;
+    transcribe_run_params_init(&params);
     params.family = &ext;
 
-    g_run_called = false;
+    g_run_called          = false;
     g_run_validate_status = TRANSCRIBE_OK;
 
-    float pcm = 0.0f;
-    const transcribe_status st = transcribe_run(&session, &pcm, 1, &params);
+    float                   pcm = 0.0f;
+    const transcribe_status st  = transcribe_run(&session, &pcm, 1, &params);
 
     CHECK(st == TRANSCRIBE_OK);
     CHECK(g_run_called == true);
@@ -182,35 +176,35 @@ void test_run_validate_success_clears_and_runs() {
 // (run_batch == nullptr in run_validate_arch).
 // ---------------------------------------------------------------------------
 
-int g_abort_after = 0;   // number of poll_abort() calls allowed before firing
+int g_abort_after = 0;  // number of poll_abort() calls allowed before firing
 int g_abort_polls = 0;
 
 bool fake_abort_cb(void * u) {
-    (void)u;
+    (void) u;
     ++g_abort_polls;
     return g_abort_polls > g_abort_after;
 }
 
 void test_batch_abort_pads_missing_to_n() {
     transcribe_model model;
-    model.arch = &run_validate_arch();   // run_batch == nullptr -> serial fallback
+    model.arch = &run_validate_arch();  // run_batch == nullptr -> serial fallback
 
     transcribe_session session;
     session.model = &model;
 
-    transcribe_run_params params; transcribe_run_params_init(&params);
+    transcribe_run_params params;
+    transcribe_run_params_init(&params);
 
     g_run_validate_status = TRANSCRIBE_OK;
-    g_abort_polls = 0;
-    g_abort_after = 1;   // utterance 0 runs; abort fires before utterance 1
+    g_abort_polls         = 0;
+    g_abort_after         = 1;  // utterance 0 runs; abort fires before utterance 1
     transcribe_set_abort_callback(&session, fake_abort_cb, nullptr);
 
-    float s0 = 0.0f, s1 = 0.0f, s2 = 0.0f;
-    const float * pcm[3]      = { &s0, &s1, &s2 };
+    float         s0 = 0.0f, s1 = 0.0f, s2 = 0.0f;
+    const float * pcm[3]       = { &s0, &s1, &s2 };
     const int     n_samples[3] = { 1, 1, 1 };
 
-    const transcribe_status st =
-        transcribe_run_batch(&session, pcm, n_samples, 3, &params);
+    const transcribe_status st = transcribe_run_batch(&session, pcm, n_samples, 3, &params);
 
     // Whole-batch status is ABORTED, but every input still owns a slot.
     CHECK(st == TRANSCRIBE_ERR_ABORTED);
@@ -234,17 +228,15 @@ void test_batch_abort_pads_missing_to_n() {
 // != nullptr branch in transcribe_run_batch.
 // ---------------------------------------------------------------------------
 
-transcribe_status fake_run_batch_abort(
-    transcribe_session *          session,
-    const float * const *         pcm,
-    const int *                   n_samples,
-    int                           n,
-    const transcribe_run_params * params)
-{
-    (void)pcm;
-    (void)n_samples;
-    (void)n;
-    (void)params;
+transcribe_status fake_run_batch_abort(transcribe_session *          session,
+                                       const float * const *         pcm,
+                                       const int *                   n_samples,
+                                       int                           n,
+                                       const transcribe_run_params * params) {
+    (void) pcm;
+    (void) n_samples;
+    (void) n;
+    (void) params;
     // Complete utterance 0, then abort before producing the rest. The hook
     // retains only what it finished; the dispatcher pads missing slots.
     transcribe_session::ResultSet rs;
@@ -258,17 +250,17 @@ transcribe_status fake_run_batch_abort(
 const transcribe::Arch & run_batch_abort_arch() {
     static const transcribe::Arch arch = {
         "fake-run-batch",
-        nullptr,                 // load
-        nullptr,                 // init_context
-        fake_run,                // run (required; dispatcher gates on it)
-        fake_run_batch_abort,    // run_batch (fast path)
-        nullptr,                 // stream_validate
-        nullptr,                 // stream_begin
-        nullptr,                 // stream_feed
-        nullptr,                 // stream_finalize
-        nullptr,                 // stream_reset
-        nullptr,                 // accepts_run_kind
-        nullptr,                 // run_validate
+        nullptr,               // load
+        nullptr,               // init_context
+        fake_run,              // run (required; dispatcher gates on it)
+        fake_run_batch_abort,  // run_batch (fast path)
+        nullptr,               // stream_validate
+        nullptr,               // stream_begin
+        nullptr,               // stream_feed
+        nullptr,               // stream_finalize
+        nullptr,               // stream_reset
+        nullptr,               // accepts_run_kind
+        nullptr,               // run_validate
     };
     return arch;
 }
@@ -280,14 +272,14 @@ void test_batch_fastpath_abort_pads_missing_to_n() {
     transcribe_session session;
     session.model = &model;
 
-    transcribe_run_params params; transcribe_run_params_init(&params);
+    transcribe_run_params params;
+    transcribe_run_params_init(&params);
 
-    float s0 = 0.0f, s1 = 0.0f, s2 = 0.0f;
+    float         s0 = 0.0f, s1 = 0.0f, s2 = 0.0f;
     const float * pcm[3]       = { &s0, &s1, &s2 };
     const int     n_samples[3] = { 1, 1, 1 };
 
-    const transcribe_status st =
-        transcribe_run_batch(&session, pcm, n_samples, 3, &params);
+    const transcribe_status st = transcribe_run_batch(&session, pcm, n_samples, 3, &params);
 
     // Same invariant as the serial fallback, via the fast-path branch.
     CHECK(st == TRANSCRIBE_ERR_ABORTED);
@@ -302,7 +294,7 @@ void test_batch_fastpath_abort_pads_missing_to_n() {
     CHECK(std::strcmp(transcribe_batch_full_text(&session, 2), "") == 0);
 }
 
-} // namespace
+}  // namespace
 
 int main() {
     test_no_run_hook_clears_and_not_implemented();
diff --git a/tests/stream_capability_unit.cpp b/tests/stream_capability_unit.cpp
index c7657ae0..df074181 100644
--- a/tests/stream_capability_unit.cpp
+++ b/tests/stream_capability_unit.cpp
@@ -37,7 +37,7 @@
 #include <string>
 
 #ifndef TRANSCRIBE_TEST_FIXTURES_DIR
-#  error "TRANSCRIBE_TEST_FIXTURES_DIR must be defined by the build system"
+#    error "TRANSCRIBE_TEST_FIXTURES_DIR must be defined by the build system"
 #endif
 
 namespace {
@@ -46,27 +46,25 @@ const std::string g_fixtures_dir = TRANSCRIBE_TEST_FIXTURES_DIR;
 
 int g_failures = 0;
 
-#define CHECK(cond)                                                         \
-    do {                                                                    \
-        if (!(cond)) {                                                      \
-            std::fprintf(stderr, "FAIL %s:%d: %s\n",                        \
-                         __FILE__, __LINE__, #cond);                        \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK(cond)                                                              \
+    do {                                                                         \
+        if (!(cond)) {                                                           \
+            std::fprintf(stderr, "FAIL %s:%d: %s\n", __FILE__, __LINE__, #cond); \
+            ++g_failures;                                                        \
+        }                                                                        \
     } while (0)
 
 bool file_exists(const std::string & path) {
-    struct stat st {};
+    struct stat st{};
     return ::stat(path.c_str(), &st) == 0;
 }
 
 // Wraps the load + context-init dance so each test case stays tight.
 // On failure prints a diagnostic, increments g_failures, and returns
 // false; the caller then bails so it doesn't deref nullptrs.
-bool load_and_init(const char *                  fixture_name,
-                   struct transcribe_model **    out_model,
-                   struct transcribe_session **  out_ctx)
-{
+bool load_and_init(const char *                 fixture_name,
+                   struct transcribe_model **   out_model,
+                   struct transcribe_session ** out_ctx) {
     *out_model = nullptr;
     *out_ctx   = nullptr;
 
@@ -80,26 +78,22 @@ bool load_and_init(const char *                  fixture_name,
         return false;
     }
 
-    transcribe_model_load_params mp; transcribe_model_load_params_init(&mp);
-    const transcribe_status load_st =
-        transcribe_model_load_file(p.c_str(), &mp, out_model);
+    transcribe_model_load_params mp;
+    transcribe_model_load_params_init(&mp);
+    const transcribe_status load_st = transcribe_model_load_file(p.c_str(), &mp, out_model);
     if (load_st != TRANSCRIBE_OK || *out_model == nullptr) {
-        std::fprintf(stderr,
-                     "FAIL load %s: status=%s, model=%p\n",
-                     fixture_name, transcribe_status_string(load_st),
-                     (void *)*out_model);
+        std::fprintf(stderr, "FAIL load %s: status=%s, model=%p\n", fixture_name, transcribe_status_string(load_st),
+                     (void *) *out_model);
         ++g_failures;
         return false;
     }
 
-    transcribe_session_params cp; transcribe_session_params_init(&cp);
-    const transcribe_status init_st =
-        transcribe_session_init(*out_model, &cp, out_ctx);
+    transcribe_session_params cp;
+    transcribe_session_params_init(&cp);
+    const transcribe_status init_st = transcribe_session_init(*out_model, &cp, out_ctx);
     if (init_st != TRANSCRIBE_OK || *out_ctx == nullptr) {
-        std::fprintf(stderr,
-                     "FAIL context_init %s: status=%s, ctx=%p\n",
-                     fixture_name, transcribe_status_string(init_st),
-                     (void *)*out_ctx);
+        std::fprintf(stderr, "FAIL context_init %s: status=%s, ctx=%p\n", fixture_name,
+                     transcribe_status_string(init_st), (void *) *out_ctx);
         transcribe_model_free(*out_model);
         *out_model = nullptr;
         ++g_failures;
@@ -115,27 +109,31 @@ bool load_and_init(const char *                  fixture_name,
 void test_supports_streaming_false() {
     struct transcribe_model *   model = nullptr;
     struct transcribe_session * ctx   = nullptr;
-    if (!load_and_init("tokenizer_minimal.gguf", &model, &ctx)) return;
+    if (!load_and_init("tokenizer_minimal.gguf", &model, &ctx)) {
+        return;
+    }
 
-    transcribe_capabilities caps_buf; transcribe_capabilities_init(&caps_buf);
-    const bool caps_ok =
-        transcribe_model_get_capabilities(model, &caps_buf) == TRANSCRIBE_OK;
-    const transcribe_capabilities * caps = caps_ok ? &caps_buf : nullptr;
+    transcribe_capabilities caps_buf;
+    transcribe_capabilities_init(&caps_buf);
+    const bool                      caps_ok = transcribe_model_get_capabilities(model, &caps_buf) == TRANSCRIBE_OK;
+    const transcribe_capabilities * caps    = caps_ok ? &caps_buf : nullptr;
     CHECK(caps != nullptr);
     if (caps != nullptr) {
-        CHECK(caps->supports_streaming     == false);
+        CHECK(caps->supports_streaming == false);
     }
 
-    transcribe_stream_params sp; transcribe_stream_params_init(&sp);
-    transcribe_run_params rp; transcribe_run_params_init(&rp);
-    const transcribe_status   st = transcribe_stream_begin(ctx, &rp, &sp);
+    transcribe_stream_params sp;
+    transcribe_stream_params_init(&sp);
+    transcribe_run_params rp;
+    transcribe_run_params_init(&rp);
+    const transcribe_status st = transcribe_stream_begin(ctx, &rp, &sp);
 
     CHECK(st == TRANSCRIBE_ERR_NOT_IMPLEMENTED);
     // Pre-hook rejection: state unchanged from IDLE, last_status not
     // disturbed (capability gate fires before the lifecycle transition).
-    CHECK(transcribe_stream_get_state(ctx)    == TRANSCRIBE_STREAM_IDLE);
-    CHECK(transcribe_stream_last_status(ctx)  == TRANSCRIBE_OK);
-    CHECK(transcribe_stream_revision(ctx)     == 0);
+    CHECK(transcribe_stream_get_state(ctx) == TRANSCRIBE_STREAM_IDLE);
+    CHECK(transcribe_stream_last_status(ctx) == TRANSCRIBE_OK);
+    CHECK(transcribe_stream_revision(ctx) == 0);
 
     transcribe_session_free(ctx);
     transcribe_model_free(model);
@@ -153,22 +151,26 @@ void test_supports_streaming_false() {
 void test_supports_streaming_true_variant_offline() {
     struct transcribe_model *   model = nullptr;
     struct transcribe_session * ctx   = nullptr;
-    if (!load_and_init("tokenizer_minimal_streaming.gguf", &model, &ctx)) return;
+    if (!load_and_init("tokenizer_minimal_streaming.gguf", &model, &ctx)) {
+        return;
+    }
 
-    transcribe_capabilities caps_buf; transcribe_capabilities_init(&caps_buf);
-    const bool caps_ok =
-        transcribe_model_get_capabilities(model, &caps_buf) == TRANSCRIBE_OK;
-    const transcribe_capabilities * caps = caps_ok ? &caps_buf : nullptr;
+    transcribe_capabilities caps_buf;
+    transcribe_capabilities_init(&caps_buf);
+    const bool                      caps_ok = transcribe_model_get_capabilities(model, &caps_buf) == TRANSCRIBE_OK;
+    const transcribe_capabilities * caps    = caps_ok ? &caps_buf : nullptr;
     CHECK(caps != nullptr);
     if (caps != nullptr) {
         // KV path works: the loader read stt.capability.streaming=true
         // and flipped the family default.
-        CHECK(caps->supports_streaming     == true);
+        CHECK(caps->supports_streaming == true);
     }
 
-    transcribe_stream_params sp; transcribe_stream_params_init(&sp);
-    transcribe_run_params rp; transcribe_run_params_init(&rp);
-    const transcribe_status   st = transcribe_stream_begin(ctx, &rp, &sp);
+    transcribe_stream_params sp;
+    transcribe_stream_params_init(&sp);
+    transcribe_run_params rp;
+    transcribe_run_params_init(&rp);
+    const transcribe_status st = transcribe_stream_begin(ctx, &rp, &sp);
 
     // Family-level pre-flight rejection: caps says yes, the
     // dispatcher's gates pass, but parakeet's stream_validate hook
@@ -178,7 +180,7 @@ void test_supports_streaming_true_variant_offline() {
     // stays IDLE and last_status is untouched — semantically
     // equivalent to a caps.supports_streaming = false rejection.
     CHECK(st == TRANSCRIBE_ERR_NOT_IMPLEMENTED);
-    CHECK(transcribe_stream_get_state(ctx)   == TRANSCRIBE_STREAM_IDLE);
+    CHECK(transcribe_stream_get_state(ctx) == TRANSCRIBE_STREAM_IDLE);
     CHECK(transcribe_stream_last_status(ctx) == TRANSCRIBE_OK);
 
     transcribe_session_free(ctx);
@@ -201,20 +203,23 @@ void test_supports_streaming_true_variant_offline() {
 void test_run_after_failed_begin_does_not_get_stuck() {
     struct transcribe_model *   model = nullptr;
     struct transcribe_session * ctx   = nullptr;
-    if (!load_and_init("tokenizer_minimal.gguf", &model, &ctx)) return;
+    if (!load_and_init("tokenizer_minimal.gguf", &model, &ctx)) {
+        return;
+    }
 
-    transcribe_stream_params sp; transcribe_stream_params_init(&sp);
-    transcribe_run_params rp; transcribe_run_params_init(&rp);
-    CHECK(transcribe_stream_begin(ctx, &rp, &sp) ==
-          TRANSCRIBE_ERR_NOT_IMPLEMENTED);
+    transcribe_stream_params sp;
+    transcribe_stream_params_init(&sp);
+    transcribe_run_params rp;
+    transcribe_run_params_init(&rp);
+    CHECK(transcribe_stream_begin(ctx, &rp, &sp) == TRANSCRIBE_ERR_NOT_IMPLEMENTED);
     CHECK(transcribe_stream_get_state(ctx) == TRANSCRIBE_STREAM_IDLE);
 
     // transcribe_run from IDLE: must not return the ACTIVE-rejection
     // INVALID_ARG path. Whatever the family does next is fine — we
     // only care that the streaming bookkeeping didn't strand the
     // context.
-    const float pcm[16] = { 0.0f };
-    const transcribe_status run_st = transcribe_run(ctx, pcm, 16, &rp);
+    const float             pcm[16] = { 0.0f };
+    const transcribe_status run_st  = transcribe_run(ctx, pcm, 16, &rp);
     // INVALID_ARG specifically from the ACTIVE-stream rejection
     // would be a regression. The dispatcher's other INVALID_ARG paths
     // (NULL args, bad enum) are not reachable here since we pass
@@ -247,10 +252,10 @@ void test_supports_translate_kv_override() {
         return;
     }
 
-    transcribe_capabilities caps_buf; transcribe_capabilities_init(&caps_buf);
-    const bool caps_ok =
-        transcribe_model_get_capabilities(model, &caps_buf) == TRANSCRIBE_OK;
-    const transcribe_capabilities * caps = caps_ok ? &caps_buf : nullptr;
+    transcribe_capabilities caps_buf;
+    transcribe_capabilities_init(&caps_buf);
+    const bool                      caps_ok = transcribe_model_get_capabilities(model, &caps_buf) == TRANSCRIBE_OK;
+    const transcribe_capabilities * caps    = caps_ok ? &caps_buf : nullptr;
     CHECK(caps != nullptr);
     if (caps != nullptr) {
         // Canonical KV honored: family default false, KV says true.
@@ -259,8 +264,7 @@ void test_supports_translate_kv_override() {
         // exposed on the public caps struct (the target-side twin of
         // languages[]).
         CHECK(caps->n_translate_target_languages == 3);
-        if (caps->n_translate_target_languages == 3 &&
-            caps->translate_target_languages != nullptr) {
+        if (caps->n_translate_target_languages == 3 && caps->translate_target_languages != nullptr) {
             CHECK(std::strcmp(caps->translate_target_languages[0], "en") == 0);
             CHECK(std::strcmp(caps->translate_target_languages[1], "de") == 0);
             CHECK(std::strcmp(caps->translate_target_languages[2], "fr") == 0);
@@ -272,31 +276,31 @@ void test_supports_translate_kv_override() {
     // UNSUPPORTED_LANGUAGE ("zz" is not in {"en"}). This fires in the
     // shared validate_run_params_common before any family compute.
     {
-        transcribe_run_params rp; transcribe_run_params_init(&rp);
-        rp.task            = TRANSCRIBE_TASK_TRANSLATE;
-        rp.target_language = "zz";
+        transcribe_run_params rp;
+        transcribe_run_params_init(&rp);
+        rp.task             = TRANSCRIBE_TASK_TRANSLATE;
+        rp.target_language  = "zz";
         const float pcm[16] = { 0.0f };
-        CHECK(transcribe_run(ctx, pcm, 16, &rp) ==
-              TRANSCRIBE_ERR_UNSUPPORTED_LANGUAGE);
+        CHECK(transcribe_run(ctx, pcm, 16, &rp) == TRANSCRIBE_ERR_UNSUPPORTED_LANGUAGE);
     }
 
     // Translation-pair gate: "fr" is an advertised target, so the target
     // gate passes, but the exact pair set only allows en>de and de>en.
     {
-        transcribe_run_params rp; transcribe_run_params_init(&rp);
-        rp.task            = TRANSCRIBE_TASK_TRANSLATE;
-        rp.language        = "de";
-        rp.target_language = "fr";
+        transcribe_run_params rp;
+        transcribe_run_params_init(&rp);
+        rp.task             = TRANSCRIBE_TASK_TRANSLATE;
+        rp.language         = "de";
+        rp.target_language  = "fr";
         const float pcm[16] = { 0.0f };
-        CHECK(transcribe_run(ctx, pcm, 16, &rp) ==
-              TRANSCRIBE_ERR_UNSUPPORTED_LANGUAGE);
+        CHECK(transcribe_run(ctx, pcm, 16, &rp) == TRANSCRIBE_ERR_UNSUPPORTED_LANGUAGE);
     }
 
     transcribe_session_free(ctx);
     transcribe_model_free(model);
 }
 
-} // namespace
+}  // namespace
 
 int main() {
     test_supports_streaming_false();
@@ -305,8 +309,7 @@ int main() {
     test_supports_translate_kv_override();
 
     if (g_failures > 0) {
-        std::fprintf(stderr, "stream_capability_unit: %d failures\n",
-                     g_failures);
+        std::fprintf(stderr, "stream_capability_unit: %d failures\n", g_failures);
         return EXIT_FAILURE;
     }
     std::fprintf(stdout, "stream_capability_unit: ok\n");
diff --git a/tests/stream_committed_pointer_stability.cpp b/tests/stream_committed_pointer_stability.cpp
index f19fa89e..d36448fc 100644
--- a/tests/stream_committed_pointer_stability.cpp
+++ b/tests/stream_committed_pointer_stability.cpp
@@ -16,7 +16,6 @@
 // is missing.
 
 #include "transcribe.h"
-
 #include "wav.h"
 
 #include <sys/stat.h>
@@ -30,35 +29,30 @@ namespace {
 
 int g_failures = 0;
 
-#define CHECK(cond)                                                         \
-    do {                                                                    \
-        if (!(cond)) {                                                      \
-            std::fprintf(stderr, "FAIL %s:%d: %s\n",                        \
-                         __FILE__, __LINE__, #cond);                        \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK(cond)                                                              \
+    do {                                                                         \
+        if (!(cond)) {                                                           \
+            std::fprintf(stderr, "FAIL %s:%d: %s\n", __FILE__, __LINE__, #cond); \
+            ++g_failures;                                                        \
+        }                                                                        \
     } while (0)
 
 bool file_exists(const std::string & path) {
-    struct stat st {};
+    struct stat st{};
     return ::stat(path.c_str(), &st) == 0;
 }
 
 std::string read_committed_text(transcribe_session * ctx,
                                 std::string &        tentative,
                                 std::string &        full,
-                                const char *         where)
-{
+                                const char *         where) {
     transcribe_stream_text text;
     transcribe_stream_text_init(&text);
     CHECK(transcribe_stream_get_text(ctx, &text) == TRANSCRIBE_OK);
     CHECK(text.committed_text != nullptr);
     CHECK(text.tentative_text != nullptr);
     CHECK(text.full_text != nullptr);
-    if (text.committed_text == nullptr ||
-        text.tentative_text == nullptr ||
-        text.full_text == nullptr)
-    {
+    if (text.committed_text == nullptr || text.tentative_text == nullptr || text.full_text == nullptr) {
         std::fprintf(stderr, "FAIL %s: null stream text pointer\n", where);
         return "";
     }
@@ -67,22 +61,18 @@ std::string read_committed_text(transcribe_session * ctx,
     return text.committed_text;
 }
 
-} // namespace
+}  // namespace
 
 int main(int /*argc*/, char ** /*argv*/) {
-    const char * model_path =
-        std::getenv("TRANSCRIBE_MOONSHINE_STREAMING_TINY_GGUF");
-    if (model_path == nullptr || *model_path == '\0' ||
-        !file_exists(model_path))
-    {
+    const char * model_path = std::getenv("TRANSCRIBE_MOONSHINE_STREAMING_TINY_GGUF");
+    if (model_path == nullptr || *model_path == '\0' || !file_exists(model_path)) {
         std::fprintf(stderr,
                      "skipping: TRANSCRIBE_MOONSHINE_STREAMING_TINY_GGUF unset "
                      "or missing\n");
         return 77;
     }
 
-    const std::string sample_path =
-        std::string(TRANSCRIBE_TEST_SAMPLES_DIR) + "/jfk.wav";
+    const std::string sample_path = std::string(TRANSCRIBE_TEST_SAMPLES_DIR) + "/jfk.wav";
     if (!file_exists(sample_path)) {
         std::fprintf(stderr, "skipping: %s missing\n", sample_path.c_str());
         return 77;
@@ -91,19 +81,14 @@ int main(int /*argc*/, char ** /*argv*/) {
     std::vector<float> pcm;
     {
         std::string err;
-        if (!transcribe_cli::load_wav_mono_16k(sample_path, pcm, err) ||
-            pcm.empty())
-        {
-            std::fprintf(stderr, "failed to load %s: %s\n",
-                         sample_path.c_str(), err.c_str());
+        if (!transcribe_cli::load_wav_mono_16k(sample_path, pcm, err) || pcm.empty()) {
+            std::fprintf(stderr, "failed to load %s: %s\n", sample_path.c_str(), err.c_str());
             return 1;
         }
     }
 
     struct transcribe_session * ctx = nullptr;
-    if (transcribe_open(model_path, nullptr, nullptr, &ctx) != TRANSCRIBE_OK ||
-        ctx == nullptr)
-    {
+    if (transcribe_open(model_path, nullptr, nullptr, &ctx) != TRANSCRIBE_OK || ctx == nullptr) {
         std::fprintf(stderr, "transcribe_open failed for %s\n", model_path);
         return 1;
     }
@@ -116,36 +101,34 @@ int main(int /*argc*/, char ** /*argv*/) {
 
     // Small chunks => many feeds => maximal opportunity for the committed
     // prefix to grow incrementally and for a stale pointer to surface.
-    const int chunk_samples = 250 * 16000 / 1000; // 250 ms
+    const int   chunk_samples = 250 * 16000 / 1000;  // 250 ms
     std::string prev_committed;
-    int pos = 0;
+    int         pos = 0;
     while (pos < static_cast<int>(pcm.size())) {
         int take = chunk_samples;
         if (pos + take > static_cast<int>(pcm.size())) {
             take = static_cast<int>(pcm.size()) - pos;
         }
-        const transcribe_status st =
-            transcribe_stream_feed(ctx, pcm.data() + pos, take, nullptr);
+        const transcribe_status st = transcribe_stream_feed(ctx, pcm.data() + pos, take, nullptr);
         CHECK(st == TRANSCRIBE_OK);
-        if (st != TRANSCRIBE_OK) break;
+        if (st != TRANSCRIBE_OK) {
+            break;
+        }
 
-        std::string tentative;
-        std::string full;
-        const std::string committed =
-            read_committed_text(ctx, tentative, full, "feed");
+        std::string       tentative;
+        std::string       full;
+        const std::string committed = read_committed_text(ctx, tentative, full, "feed");
         CHECK(committed.rfind(prev_committed, 0) == 0);
         prev_committed = committed;
         pos += take;
     }
 
-    const transcribe_status fin =
-        transcribe_stream_finalize(ctx, nullptr);
+    const transcribe_status fin = transcribe_stream_finalize(ctx, nullptr);
     CHECK(fin == TRANSCRIBE_OK);
 
-    std::string tentative;
-    std::string full;
-    const std::string committed =
-        read_committed_text(ctx, tentative, full, "finalize");
+    std::string       tentative;
+    std::string       full;
+    const std::string committed = read_committed_text(ctx, tentative, full, "finalize");
     CHECK(committed.rfind(prev_committed, 0) == 0);
     CHECK(tentative.empty());
     CHECK(!full.empty());
diff --git a/tests/stream_dispatch_unit.cpp b/tests/stream_dispatch_unit.cpp
index f3c9e604..2fcb2200 100644
--- a/tests/stream_dispatch_unit.cpp
+++ b/tests/stream_dispatch_unit.cpp
@@ -10,9 +10,9 @@
 // TRANSLATE rejection, language validation) require a real model and
 // are covered by stream_capability_unit.cpp.
 
-#include "transcribe-session.h"
 #include "transcribe-arch.h"
 #include "transcribe-model.h"
+#include "transcribe-session.h"
 #include "transcribe.h"
 
 #include <cstddef>
@@ -23,41 +23,40 @@
 
 namespace {
 
-int g_failures = 0;
-int g_begin_calls = 0;
-const char * g_feed_texts[8] = {};
-int g_n_feed_texts = 0;
-int g_feed_text_i = 0;
-const char * g_finalize_text = "";
-const char * g_token_texts[8] = {};
-int g_n_token_rows = 0;
-int g_forced_n_committed_tokens = -1;
-int g_forced_n_committed_words = -1;
-int g_forced_n_committed_segments = -1;
-int64_t g_feed_audio_committed_us = 0;
-
-#define CHECK(cond)                                                         \
-    do {                                                                    \
-        if (!(cond)) {                                                      \
-            std::fprintf(stderr, "FAIL %s:%d: %s\n",                        \
-                         __FILE__, __LINE__, #cond);                        \
-            ++g_failures;                                                   \
-        }                                                                   \
+int          g_failures                    = 0;
+int          g_begin_calls                 = 0;
+const char * g_feed_texts[8]               = {};
+int          g_n_feed_texts                = 0;
+int          g_feed_text_i                 = 0;
+const char * g_finalize_text               = "";
+const char * g_token_texts[8]              = {};
+int          g_n_token_rows                = 0;
+int          g_forced_n_committed_tokens   = -1;
+int          g_forced_n_committed_words    = -1;
+int          g_forced_n_committed_segments = -1;
+int64_t      g_feed_audio_committed_us     = 0;
+
+#define CHECK(cond)                                                              \
+    do {                                                                         \
+        if (!(cond)) {                                                           \
+            std::fprintf(stderr, "FAIL %s:%d: %s\n", __FILE__, __LINE__, #cond); \
+            ++g_failures;                                                        \
+        }                                                                        \
     } while (0)
 
 void reset_sequence_globals() {
     for (int i = 0; i < 8; ++i) {
-        g_feed_texts[i] = nullptr;
+        g_feed_texts[i]  = nullptr;
         g_token_texts[i] = nullptr;
     }
-    g_n_feed_texts = 0;
-    g_feed_text_i = 0;
-    g_finalize_text = "";
-    g_n_token_rows = 0;
-    g_forced_n_committed_tokens = -1;
-    g_forced_n_committed_words = -1;
+    g_n_feed_texts                = 0;
+    g_feed_text_i                 = 0;
+    g_finalize_text               = "";
+    g_n_token_rows                = 0;
+    g_forced_n_committed_tokens   = -1;
+    g_forced_n_committed_words    = -1;
     g_forced_n_committed_segments = -1;
-    g_feed_audio_committed_us = 0;
+    g_feed_audio_committed_us     = 0;
 }
 
 void test_accessors_on_null_ctx() {
@@ -80,17 +79,19 @@ void test_accessors_on_idle_ctx() {
 }
 
 void test_default_params() {
-    transcribe_stream_params p; transcribe_stream_params_init(&p);
+    transcribe_stream_params p;
+    transcribe_stream_params_init(&p);
     CHECK(p.family == nullptr);
     CHECK(p.struct_size == sizeof(transcribe_stream_params));
 }
 
 void test_begin_null_args() {
     // session == NULL is still rejected.
-    transcribe_run_params rp; transcribe_run_params_init(&rp);
-    transcribe_stream_params sp; transcribe_stream_params_init(&sp);
-    CHECK(transcribe_stream_begin(nullptr, &rp, &sp) ==
-          TRANSCRIBE_ERR_INVALID_ARG);
+    transcribe_run_params rp;
+    transcribe_run_params_init(&rp);
+    transcribe_stream_params sp;
+    transcribe_stream_params_init(&sp);
+    CHECK(transcribe_stream_begin(nullptr, &rp, &sp) == TRANSCRIBE_ERR_INVALID_ARG);
 
     // NULL run/stream params now mean "all defaults", so they are no
     // longer rejected as INVALID_ARG. With this model-less context the
@@ -98,10 +99,8 @@ void test_begin_null_args() {
     // gate (NOT_IMPLEMENTED); the point under test is that NULL params
     // is accepted, not the downstream gate's exact code.
     transcribe_session session;
-    CHECK(transcribe_stream_begin(&session, nullptr, &sp) !=
-          TRANSCRIBE_ERR_INVALID_ARG);
-    CHECK(transcribe_stream_begin(&session, &rp, nullptr) !=
-          TRANSCRIBE_ERR_INVALID_ARG);
+    CHECK(transcribe_stream_begin(&session, nullptr, &sp) != TRANSCRIBE_ERR_INVALID_ARG);
+    CHECK(transcribe_stream_begin(&session, &rp, nullptr) != TRANSCRIBE_ERR_INVALID_ARG);
 
     // None of these should have moved the context off IDLE.
     CHECK(transcribe_stream_get_state(&session) == TRANSCRIBE_STREAM_IDLE);
@@ -111,81 +110,72 @@ void test_begin_rejected_when_active() {
     transcribe_session session;
     session.stream_state = TRANSCRIBE_STREAM_ACTIVE;
 
-    transcribe_run_params rp; transcribe_run_params_init(&rp);
-    transcribe_stream_params sp; transcribe_stream_params_init(&sp);
-    CHECK(transcribe_stream_begin(&session, &rp, &sp) ==
-          TRANSCRIBE_ERR_INVALID_ARG);
+    transcribe_run_params rp;
+    transcribe_run_params_init(&rp);
+    transcribe_stream_params sp;
+    transcribe_stream_params_init(&sp);
+    CHECK(transcribe_stream_begin(&session, &rp, &sp) == TRANSCRIBE_ERR_INVALID_ARG);
     // Still ACTIVE — rejection must not clear lifecycle.
     CHECK(transcribe_stream_get_state(&session) == TRANSCRIBE_STREAM_ACTIVE);
 }
 
 void test_begin_no_model_returns_not_implemented() {
     // session with no model still reaches the model/arch check.
-    transcribe_session session;
-    transcribe_run_params rp; transcribe_run_params_init(&rp);
-    transcribe_stream_params sp; transcribe_stream_params_init(&sp);
-    CHECK(transcribe_stream_begin(&session, &rp, &sp) ==
-          TRANSCRIBE_ERR_NOT_IMPLEMENTED);
+    transcribe_session    session;
+    transcribe_run_params rp;
+    transcribe_run_params_init(&rp);
+    transcribe_stream_params sp;
+    transcribe_stream_params_init(&sp);
+    CHECK(transcribe_stream_begin(&session, &rp, &sp) == TRANSCRIBE_ERR_NOT_IMPLEMENTED);
     CHECK(transcribe_stream_get_state(&session) == TRANSCRIBE_STREAM_IDLE);
 }
 
-transcribe_status fake_stream_begin(
-    transcribe_session *              session,
-    const transcribe_run_params *         run_params,
-    const transcribe_stream_params *  stream_params)
-{
-    (void)session;
-    (void)run_params;
-    (void)stream_params;
+transcribe_status fake_stream_begin(transcribe_session *             session,
+                                    const transcribe_run_params *    run_params,
+                                    const transcribe_stream_params * stream_params) {
+    (void) session;
+    (void) run_params;
+    (void) stream_params;
     ++g_begin_calls;
     return TRANSCRIBE_OK;
 }
 
-transcribe_status fake_stream_feed(
-    transcribe_session *     session,
-    const float *            pcm,
-    int                      n_samples,
-    transcribe_stream_update * update)
-{
-    (void)session;
-    (void)pcm;
-    (void)n_samples;
-    (void)update;
+transcribe_status fake_stream_feed(transcribe_session *       session,
+                                   const float *              pcm,
+                                   int                        n_samples,
+                                   transcribe_stream_update * update) {
+    (void) session;
+    (void) pcm;
+    (void) n_samples;
+    (void) update;
     return TRANSCRIBE_OK;
 }
 
-transcribe_status fake_stream_finalize(
-    transcribe_session *      session,
-    transcribe_stream_update * update)
-{
-    (void)session;
-    (void)update;
+transcribe_status fake_stream_finalize(transcribe_session * session, transcribe_stream_update * update) {
+    (void) session;
+    (void) update;
     return TRANSCRIBE_OK;
 }
 
-transcribe_status fake_sequence_stream_begin(
-    transcribe_session *              session,
-    const transcribe_run_params *     run_params,
-    const transcribe_stream_params *  stream_params)
-{
-    (void)session;
-    (void)run_params;
-    (void)stream_params;
+transcribe_status fake_sequence_stream_begin(transcribe_session *             session,
+                                             const transcribe_run_params *    run_params,
+                                             const transcribe_stream_params * stream_params) {
+    (void) session;
+    (void) run_params;
+    (void) stream_params;
     g_feed_text_i = 0;
     return TRANSCRIBE_OK;
 }
 
-transcribe_status fake_sequence_stream_feed(
-    transcribe_session *       session,
-    const float *              pcm,
-    int                        n_samples,
-    transcribe_stream_update * update)
-{
-    (void)pcm;
-    (void)n_samples;
-    (void)update;
+transcribe_status fake_sequence_stream_feed(transcribe_session *       session,
+                                            const float *              pcm,
+                                            int                        n_samples,
+                                            transcribe_stream_update * update) {
+    (void) pcm;
+    (void) n_samples;
+    (void) update;
     if (g_feed_text_i < g_n_feed_texts) {
-        session->full_text = g_feed_texts[g_feed_text_i++];
+        session->full_text  = g_feed_texts[g_feed_text_i++];
         session->has_result = true;
         if (g_n_token_rows > 0) {
             session->tokens.clear();
@@ -212,24 +202,17 @@ transcribe_status fake_sequence_stream_feed(
     return TRANSCRIBE_OK;
 }
 
-transcribe_status fake_sequence_stream_finalize(
-    transcribe_session *       session,
-    transcribe_stream_update * update)
-{
-    (void)update;
-    session->full_text = g_finalize_text != nullptr ? g_finalize_text : "";
+transcribe_status fake_sequence_stream_finalize(transcribe_session * session, transcribe_stream_update * update) {
+    (void) update;
+    session->full_text  = g_finalize_text != nullptr ? g_finalize_text : "";
     session->has_result = true;
     return TRANSCRIBE_OK;
 }
 
-bool fake_accepts_no_ext(
-    const transcribe_model * model,
-    transcribe_ext_slot      slot,
-    uint32_t                 kind)
-{
-    (void)model;
-    (void)slot;
-    (void)kind;
+bool fake_accepts_no_ext(const transcribe_model * model, transcribe_ext_slot slot, uint32_t kind) {
+    (void) model;
+    (void) slot;
+    (void) kind;
     return false;
 }
 
@@ -238,14 +221,12 @@ int g_validate_calls = 0;
 // stream_validate that always rejects, modeling a family preflight that
 // found a bad extension value. Must run BEFORE the dispatcher clears the
 // snapshot; must NOT lead to stream_begin being called.
-transcribe_status fake_stream_validate_reject(
-    const transcribe_session *        session,
-    const transcribe_run_params *     run_params,
-    const transcribe_stream_params *  stream_params)
-{
-    (void)session;
-    (void)run_params;
-    (void)stream_params;
+transcribe_status fake_stream_validate_reject(const transcribe_session *       session,
+                                              const transcribe_run_params *    run_params,
+                                              const transcribe_stream_params * stream_params) {
+    (void) session;
+    (void) run_params;
+    (void) stream_params;
     ++g_validate_calls;
     return TRANSCRIBE_ERR_INVALID_ARG;
 }
@@ -257,7 +238,7 @@ void test_begin_rejects_unknown_ext_kind_before_hook() {
         nullptr,
         nullptr,
         nullptr,  // run_batch
-        nullptr,                  // stream_validate
+        nullptr,  // stream_validate
         fake_stream_begin,
         fake_stream_feed,
         fake_stream_finalize,
@@ -266,23 +247,24 @@ void test_begin_rejects_unknown_ext_kind_before_hook() {
     };
 
     transcribe_model model;
-    model.arch = &arch;
+    model.arch                    = &arch;
     model.caps.supports_streaming = true;
     model.caps.max_timestamp_kind = TRANSCRIBE_TIMESTAMPS_NONE;
 
     transcribe_session session;
-    session.model        = &model;
-    session.has_result   = true;
-    session.full_text    = "previous result";
+    session.model      = &model;
+    session.has_result = true;
+    session.full_text  = "previous result";
 
-    transcribe_run_params rp; transcribe_run_params_init(&rp);
-    transcribe_stream_params sp; transcribe_stream_params_init(&sp);
+    transcribe_run_params rp;
+    transcribe_run_params_init(&rp);
+    transcribe_stream_params sp;
+    transcribe_stream_params_init(&sp);
     const transcribe_ext ext = { sizeof(transcribe_ext), 0x58585858u };
-    sp.family = &ext;
+    sp.family                = &ext;
 
     g_begin_calls = 0;
-    CHECK(transcribe_stream_begin(&session, &rp, &sp) ==
-          TRANSCRIBE_ERR_INVALID_ARG);
+    CHECK(transcribe_stream_begin(&session, &rp, &sp) == TRANSCRIBE_ERR_INVALID_ARG);
     CHECK(g_begin_calls == 0);
     CHECK(transcribe_stream_get_state(&session) == TRANSCRIBE_STREAM_IDLE);
     CHECK(session.has_result);
@@ -296,7 +278,7 @@ void test_begin_rejects_tiny_ext_before_hook() {
         nullptr,
         nullptr,
         nullptr,  // run_batch
-        nullptr,                  // stream_validate
+        nullptr,  // stream_validate
         fake_stream_begin,
         fake_stream_feed,
         fake_stream_finalize,
@@ -305,7 +287,7 @@ void test_begin_rejects_tiny_ext_before_hook() {
     };
 
     transcribe_model model;
-    model.arch = &arch;
+    model.arch                    = &arch;
     model.caps.supports_streaming = true;
     model.caps.max_timestamp_kind = TRANSCRIBE_TIMESTAMPS_NONE;
 
@@ -314,14 +296,15 @@ void test_begin_rejects_tiny_ext_before_hook() {
     session.has_result = true;
     session.full_text  = "previous result";
 
-    transcribe_run_params rp; transcribe_run_params_init(&rp);
-    transcribe_stream_params sp; transcribe_stream_params_init(&sp);
+    transcribe_run_params rp;
+    transcribe_run_params_init(&rp);
+    transcribe_stream_params sp;
+    transcribe_stream_params_init(&sp);
     transcribe_ext ext = { 0, 0 };
-    sp.family = &ext;
+    sp.family          = &ext;
 
     g_begin_calls = 0;
-    CHECK(transcribe_stream_begin(&session, &rp, &sp) ==
-          TRANSCRIBE_ERR_BAD_STRUCT_SIZE);
+    CHECK(transcribe_stream_begin(&session, &rp, &sp) == TRANSCRIBE_ERR_BAD_STRUCT_SIZE);
     CHECK(g_begin_calls == 0);
     CHECK(transcribe_stream_get_state(&session) == TRANSCRIBE_STREAM_IDLE);
     CHECK(session.has_result);
@@ -351,7 +334,7 @@ void test_begin_family_preflight_reject_preserves_snapshot() {
     };
 
     transcribe_model model;
-    model.arch = &arch;
+    model.arch                    = &arch;
     model.caps.supports_streaming = true;
     model.caps.max_timestamp_kind = TRANSCRIBE_TIMESTAMPS_NONE;
 
@@ -365,19 +348,20 @@ void test_begin_family_preflight_reject_preserves_snapshot() {
     session.model              = &model;
     session.has_result         = true;
     session.full_text          = "previous result";
-    session.stream_state       = TRANSCRIBE_STREAM_FAILED;     // a prior failed stream
-    session.stream_last_status = TRANSCRIBE_ERR_BACKEND;       // its failing status
+    session.stream_state       = TRANSCRIBE_STREAM_FAILED;  // a prior failed stream
+    session.stream_last_status = TRANSCRIBE_ERR_BACKEND;    // its failing status
 
-    transcribe_run_params rp; transcribe_run_params_init(&rp);
-    transcribe_stream_params sp; transcribe_stream_params_init(&sp);
+    transcribe_run_params rp;
+    transcribe_run_params_init(&rp);
+    transcribe_stream_params sp;
+    transcribe_stream_params_init(&sp);
 
     g_validate_calls = 0;
     g_begin_calls    = 0;
-    CHECK(transcribe_stream_begin(&session, &rp, &sp) ==
-          TRANSCRIBE_ERR_INVALID_ARG);
+    CHECK(transcribe_stream_begin(&session, &rp, &sp) == TRANSCRIBE_ERR_INVALID_ARG);
     // Preflight ran, begin did not.
     CHECK(g_validate_calls == 1);
-    CHECK(g_begin_calls    == 0);
+    CHECK(g_begin_calls == 0);
     // Snapshot preserved, lifecycle untouched (NOT cleared, NOT moved).
     CHECK(session.has_result);
     CHECK(session.full_text == "previous result");
@@ -389,60 +373,53 @@ void test_begin_family_preflight_reject_preserves_snapshot() {
 }
 
 void test_feed_rejects_idle() {
-    transcribe_session session;
-    float pcm = 0.0f;
-    transcribe_stream_update upd; transcribe_stream_update_init(&upd);
-    upd.result_changed = true; // dirty sentinel — must be zeroed
-    upd.is_final       = true;
-    upd.revision       = 42;
+    transcribe_session       session;
+    float                    pcm = 0.0f;
+    transcribe_stream_update upd;
+    transcribe_stream_update_init(&upd);
+    upd.result_changed    = true;  // dirty sentinel — must be zeroed
+    upd.is_final          = true;
+    upd.revision          = 42;
     upd.input_received_ms = 999;
 
-    CHECK(transcribe_stream_feed(&session, &pcm, 1, &upd) ==
-          TRANSCRIBE_ERR_INVALID_ARG);
+    CHECK(transcribe_stream_feed(&session, &pcm, 1, &upd) == TRANSCRIBE_ERR_INVALID_ARG);
     // Dispatcher zero-inits update before the state check returns,
     // preserving the caller's struct_size.
-    CHECK(upd.struct_size       == sizeof(transcribe_stream_update));
-    CHECK(upd.result_changed    == false);
-    CHECK(upd.is_final          == false);
-    CHECK(upd.revision          == 0);
+    CHECK(upd.struct_size == sizeof(transcribe_stream_update));
+    CHECK(upd.result_changed == false);
+    CHECK(upd.is_final == false);
+    CHECK(upd.revision == 0);
     CHECK(upd.input_received_ms == 0);
 }
 
 void test_feed_rejects_finished_and_failed() {
     transcribe_session session;
-    float pcm = 0.0f;
+    float              pcm = 0.0f;
 
     session.stream_state = TRANSCRIBE_STREAM_FINISHED;
-    CHECK(transcribe_stream_feed(&session, &pcm, 1, nullptr) ==
-          TRANSCRIBE_ERR_INVALID_ARG);
+    CHECK(transcribe_stream_feed(&session, &pcm, 1, nullptr) == TRANSCRIBE_ERR_INVALID_ARG);
     CHECK(session.stream_state == TRANSCRIBE_STREAM_FINISHED);
 
     session.stream_state = TRANSCRIBE_STREAM_FAILED;
-    CHECK(transcribe_stream_feed(&session, &pcm, 1, nullptr) ==
-          TRANSCRIBE_ERR_INVALID_ARG);
+    CHECK(transcribe_stream_feed(&session, &pcm, 1, nullptr) == TRANSCRIBE_ERR_INVALID_ARG);
     CHECK(session.stream_state == TRANSCRIBE_STREAM_FAILED);
 }
 
 void test_feed_rejects_null_ctx_and_bad_input() {
     float pcm = 0.0f;
-    CHECK(transcribe_stream_feed(nullptr, &pcm, 1, nullptr) ==
-          TRANSCRIBE_ERR_INVALID_ARG);
+    CHECK(transcribe_stream_feed(nullptr, &pcm, 1, nullptr) == TRANSCRIBE_ERR_INVALID_ARG);
 
     transcribe_session session;
     session.stream_state = TRANSCRIBE_STREAM_ACTIVE;
 
     // Negative n_samples
-    CHECK(transcribe_stream_feed(&session, &pcm, -1, nullptr) ==
-          TRANSCRIBE_ERR_INVALID_ARG);
+    CHECK(transcribe_stream_feed(&session, &pcm, -1, nullptr) == TRANSCRIBE_ERR_INVALID_ARG);
     // Zero n_samples — polling without audio goes through the
     // accessors, not feed.
-    CHECK(transcribe_stream_feed(&session, &pcm, 0, nullptr) ==
-          TRANSCRIBE_ERR_INVALID_ARG);
+    CHECK(transcribe_stream_feed(&session, &pcm, 0, nullptr) == TRANSCRIBE_ERR_INVALID_ARG);
     // pcm NULL is rejected unconditionally, regardless of n_samples.
-    CHECK(transcribe_stream_feed(&session, nullptr, 16000, nullptr) ==
-          TRANSCRIBE_ERR_INVALID_ARG);
-    CHECK(transcribe_stream_feed(&session, nullptr, 0, nullptr) ==
-          TRANSCRIBE_ERR_INVALID_ARG);
+    CHECK(transcribe_stream_feed(&session, nullptr, 16000, nullptr) == TRANSCRIBE_ERR_INVALID_ARG);
+    CHECK(transcribe_stream_feed(&session, nullptr, 0, nullptr) == TRANSCRIBE_ERR_INVALID_ARG);
 
     // The ACTIVE state survives every malformed-input rejection
     // because the dispatcher returns before the family hook runs.
@@ -452,37 +429,33 @@ void test_feed_rejects_null_ctx_and_bad_input() {
 void test_feed_active_no_hook_returns_not_implemented() {
     transcribe_session session;
     session.stream_state = TRANSCRIBE_STREAM_ACTIVE;
-    float pcm = 0.0f;
+    float pcm            = 0.0f;
     // No model → defensive NOT_IMPLEMENTED branch.
-    CHECK(transcribe_stream_feed(&session, &pcm, 1, nullptr) ==
-          TRANSCRIBE_ERR_NOT_IMPLEMENTED);
+    CHECK(transcribe_stream_feed(&session, &pcm, 1, nullptr) == TRANSCRIBE_ERR_NOT_IMPLEMENTED);
 }
 
 void test_finalize_rejects_non_active() {
     transcribe_session session;
 
     // IDLE
-    CHECK(transcribe_stream_finalize(&session, nullptr) ==
-          TRANSCRIBE_ERR_INVALID_ARG);
+    CHECK(transcribe_stream_finalize(&session, nullptr) == TRANSCRIBE_ERR_INVALID_ARG);
 
     session.stream_state = TRANSCRIBE_STREAM_FINISHED;
-    CHECK(transcribe_stream_finalize(&session, nullptr) ==
-          TRANSCRIBE_ERR_INVALID_ARG);
+    CHECK(transcribe_stream_finalize(&session, nullptr) == TRANSCRIBE_ERR_INVALID_ARG);
 
     session.stream_state = TRANSCRIBE_STREAM_FAILED;
-    CHECK(transcribe_stream_finalize(&session, nullptr) ==
-          TRANSCRIBE_ERR_INVALID_ARG);
+    CHECK(transcribe_stream_finalize(&session, nullptr) == TRANSCRIBE_ERR_INVALID_ARG);
 
-    CHECK(transcribe_stream_finalize(nullptr, nullptr) ==
-          TRANSCRIBE_ERR_INVALID_ARG);
+    CHECK(transcribe_stream_finalize(nullptr, nullptr) == TRANSCRIBE_ERR_INVALID_ARG);
 }
 
 void test_finalize_update_zeroinit() {
-    transcribe_session session;
-    transcribe_stream_update upd; transcribe_stream_update_init(&upd);
-    upd.result_changed   = true;
-    upd.is_final         = false; // will be cleared then forced true on success path
-    upd.revision         = 99;
+    transcribe_session       session;
+    transcribe_stream_update upd;
+    transcribe_stream_update_init(&upd);
+    upd.result_changed     = true;
+    upd.is_final           = false;  // will be cleared then forced true on success path
+    upd.revision           = 99;
     upd.audio_committed_ms = 7;
 
     // No model + ACTIVE → returns NOT_IMPLEMENTED, but the dispatcher
@@ -491,12 +464,11 @@ void test_finalize_update_zeroinit() {
     // doesn't happen here — verify the early-return path leaves
     // update fully zeroed and preserves the caller's struct_size).
     session.stream_state = TRANSCRIBE_STREAM_ACTIVE;
-    CHECK(transcribe_stream_finalize(&session, &upd) ==
-          TRANSCRIBE_ERR_NOT_IMPLEMENTED);
-    CHECK(upd.struct_size        == sizeof(transcribe_stream_update));
-    CHECK(upd.result_changed     == false);
-    CHECK(upd.is_final           == false);
-    CHECK(upd.revision           == 0);
+    CHECK(transcribe_stream_finalize(&session, &upd) == TRANSCRIBE_ERR_NOT_IMPLEMENTED);
+    CHECK(upd.struct_size == sizeof(transcribe_stream_update));
+    CHECK(upd.result_changed == false);
+    CHECK(upd.is_final == false);
+    CHECK(upd.revision == 0);
     CHECK(upd.audio_committed_ms == 0);
 }
 
@@ -510,20 +482,20 @@ void test_reset_from_each_state() {
     // FINISHED: clears result + counters, returns to IDLE.
     {
         transcribe_session session;
-        session.stream_state         = TRANSCRIBE_STREAM_FINISHED;
-        session.has_result           = true;
-        session.full_text            = "stale";
-        session.stream_revision      = 7;
-        session.n_committed_tokens   = 5;
-        session.stream_last_status   = TRANSCRIBE_ERR_OOM;
+        session.stream_state          = TRANSCRIBE_STREAM_FINISHED;
+        session.has_result            = true;
+        session.full_text             = "stale";
+        session.stream_revision       = 7;
+        session.n_committed_tokens    = 5;
+        session.stream_last_status    = TRANSCRIBE_ERR_OOM;
         session.stream_audio_input_us = 12345;
         transcribe_stream_reset(&session);
-        CHECK(session.stream_state          == TRANSCRIBE_STREAM_IDLE);
-        CHECK(session.has_result            == false);
+        CHECK(session.stream_state == TRANSCRIBE_STREAM_IDLE);
+        CHECK(session.has_result == false);
         CHECK(session.full_text.empty());
-        CHECK(session.stream_revision       == 0);
-        CHECK(session.n_committed_tokens    == 0);
-        CHECK(session.stream_last_status    == TRANSCRIBE_OK);
+        CHECK(session.stream_revision == 0);
+        CHECK(session.n_committed_tokens == 0);
+        CHECK(session.stream_last_status == TRANSCRIBE_OK);
         CHECK(session.stream_audio_input_us == 0);
     }
     // FAILED: same as FINISHED — clear everything, back to IDLE.
@@ -534,10 +506,10 @@ void test_reset_from_each_state() {
         session.was_aborted          = true;
         session.n_committed_segments = 3;
         transcribe_stream_reset(&session);
-        CHECK(session.stream_state          == TRANSCRIBE_STREAM_IDLE);
-        CHECK(session.stream_last_status    == TRANSCRIBE_OK);
-        CHECK(session.was_aborted           == false);
-        CHECK(session.n_committed_segments  == 0);
+        CHECK(session.stream_state == TRANSCRIBE_STREAM_IDLE);
+        CHECK(session.stream_last_status == TRANSCRIBE_OK);
+        CHECK(session.was_aborted == false);
+        CHECK(session.n_committed_segments == 0);
     }
     // NULL session — no-op.
     transcribe_stream_reset(nullptr);
@@ -549,9 +521,10 @@ void test_run_rejected_while_active() {
     session.has_result   = true;
     session.full_text    = "active stream result";
 
-    transcribe_run_params rp; transcribe_run_params_init(&rp);
-    float pcm = 0.0f;
-    const transcribe_status st = transcribe_run(&session, &pcm, 1, &rp);
+    transcribe_run_params rp;
+    transcribe_run_params_init(&rp);
+    float                   pcm = 0.0f;
+    const transcribe_status st  = transcribe_run(&session, &pcm, 1, &rp);
     CHECK(st == TRANSCRIBE_ERR_INVALID_ARG);
     // Rejection must NOT clear the active stream's result snapshot.
     CHECK(session.has_result);
@@ -561,27 +534,28 @@ void test_run_rejected_while_active() {
 
 void test_run_clears_stream_snapshot_from_finished() {
     transcribe_session session;
-    session.stream_state         = TRANSCRIBE_STREAM_FINISHED;
-    session.stream_revision      = 12;
-    session.n_committed_tokens   = 4;
-    session.stream_last_status   = TRANSCRIBE_ERR_BACKEND;
+    session.stream_state          = TRANSCRIBE_STREAM_FINISHED;
+    session.stream_revision       = 12;
+    session.n_committed_tokens    = 4;
+    session.stream_last_status    = TRANSCRIBE_ERR_BACKEND;
     session.stream_audio_input_us = 55555;
-    session.has_result           = true;
-    session.full_text            = "old run text";
+    session.has_result            = true;
+    session.full_text             = "old run text";
 
-    transcribe_run_params rp; transcribe_run_params_init(&rp);
-    float pcm = 0.0f;
+    transcribe_run_params rp;
+    transcribe_run_params_init(&rp);
+    float                   pcm = 0.0f;
     // No model → NOT_IMPLEMENTED, but clear_result + state reset must
     // have already run by the time we get here.
-    const transcribe_status st = transcribe_run(&session, &pcm, 1, &rp);
+    const transcribe_status st  = transcribe_run(&session, &pcm, 1, &rp);
     CHECK(st == TRANSCRIBE_ERR_NOT_IMPLEMENTED);
-    CHECK(session.has_result          == false);
+    CHECK(session.has_result == false);
     CHECK(session.full_text.empty());
-    CHECK(session.stream_revision     == 0);
-    CHECK(session.n_committed_tokens  == 0);
-    CHECK(session.stream_last_status  == TRANSCRIBE_OK);
+    CHECK(session.stream_revision == 0);
+    CHECK(session.n_committed_tokens == 0);
+    CHECK(session.stream_last_status == TRANSCRIBE_OK);
     CHECK(session.stream_audio_input_us == 0);
-    CHECK(session.stream_state        == TRANSCRIBE_STREAM_IDLE);
+    CHECK(session.stream_state == TRANSCRIBE_STREAM_IDLE);
 }
 
 void test_clear_result_preserves_lifecycle() {
@@ -590,18 +564,18 @@ void test_clear_result_preserves_lifecycle() {
     // lifecycle. Verify directly so a future refactor doesn't silently
     // tangle the two.
     transcribe_session session;
-    session.stream_state       = TRANSCRIBE_STREAM_ACTIVE;
-    session.stream_revision    = 9;
-    session.n_committed_words  = 2;
-    session.has_result         = true;
-    session.full_text          = "snapshot";
+    session.stream_state      = TRANSCRIBE_STREAM_ACTIVE;
+    session.stream_revision   = 9;
+    session.n_committed_words = 2;
+    session.has_result        = true;
+    session.full_text         = "snapshot";
 
     session.clear_result();
-    CHECK(session.stream_state         == TRANSCRIBE_STREAM_ACTIVE);
-    CHECK(session.has_result           == false);
+    CHECK(session.stream_state == TRANSCRIBE_STREAM_ACTIVE);
+    CHECK(session.has_result == false);
     CHECK(session.full_text.empty());
-    CHECK(session.stream_revision      == 0);
-    CHECK(session.n_committed_words    == 0);
+    CHECK(session.stream_revision == 0);
+    CHECK(session.n_committed_words == 0);
 }
 
 void test_last_status_survives_reads() {
@@ -621,7 +595,7 @@ const transcribe::Arch & sequence_arch() {
         nullptr,
         nullptr,
         nullptr,
-        nullptr,                  // run_batch
+        nullptr,  // run_batch
         nullptr,
         fake_sequence_stream_begin,
         fake_sequence_stream_feed,
@@ -638,7 +612,7 @@ const transcribe::Arch & sequence_arch_named_parakeet() {
         nullptr,
         nullptr,
         nullptr,
-        nullptr,                  // run_batch
+        nullptr,  // run_batch
         nullptr,
         fake_sequence_stream_begin,
         fake_sequence_stream_feed,
@@ -655,7 +629,7 @@ const transcribe::Arch & sequence_arch_named_moonshine_streaming() {
         nullptr,
         nullptr,
         nullptr,
-        nullptr,                  // run_batch
+        nullptr,  // run_batch
         nullptr,
         fake_sequence_stream_begin,
         fake_sequence_stream_feed,
@@ -668,7 +642,7 @@ const transcribe::Arch & sequence_arch_named_moonshine_streaming() {
 
 void init_streaming_model(transcribe_model & model) {
     reset_sequence_globals();
-    model.arch = &sequence_arch();
+    model.arch                    = &sequence_arch();
     model.caps.supports_streaming = true;
     model.caps.max_timestamp_kind = TRANSCRIBE_TIMESTAMPS_NONE;
 }
@@ -679,17 +653,19 @@ void test_stream_text_on_finalize_policy() {
     transcribe_session session;
     session.model = &model;
 
-    g_feed_texts[0] = "hello wor";
-    g_n_feed_texts = 1;
-    g_finalize_text = "hello world";
+    g_feed_texts[0]           = "hello wor";
+    g_n_feed_texts            = 1;
+    g_finalize_text           = "hello world";
     g_feed_audio_committed_us = 123000;
 
-    transcribe_stream_params sp; transcribe_stream_params_init(&sp);
+    transcribe_stream_params sp;
+    transcribe_stream_params_init(&sp);
     sp.commit_policy = TRANSCRIBE_STREAM_COMMIT_ON_FINALIZE;
     CHECK(transcribe_stream_begin(&session, nullptr, &sp) == TRANSCRIBE_OK);
 
-    float pcm = 0.0f;
-    transcribe_stream_update upd; transcribe_stream_update_init(&upd);
+    float                    pcm = 0.0f;
+    transcribe_stream_update upd;
+    transcribe_stream_update_init(&upd);
     CHECK(transcribe_stream_feed(&session, &pcm, 1, &upd) == TRANSCRIBE_OK);
     CHECK(upd.result_changed);
     CHECK(!upd.committed_changed);
@@ -697,13 +673,15 @@ void test_stream_text_on_finalize_policy() {
     CHECK(upd.audio_committed_ms == 0);
     CHECK(transcribe_stream_n_committed_tokens(&session) == 0);
 
-    transcribe_stream_text text; transcribe_stream_text_init(&text);
+    transcribe_stream_text text;
+    transcribe_stream_text_init(&text);
     CHECK(transcribe_stream_get_text(&session, &text) == TRANSCRIBE_OK);
     CHECK(std::strcmp(text.full_text, "hello wor") == 0);
     CHECK(std::strcmp(text.committed_text, "") == 0);
     CHECK(std::strcmp(text.tentative_text, "hello wor") == 0);
 
-    transcribe_stream_update fin; transcribe_stream_update_init(&fin);
+    transcribe_stream_update fin;
+    transcribe_stream_update_init(&fin);
     CHECK(transcribe_stream_finalize(&session, &fin) == TRANSCRIBE_OK);
     CHECK(fin.is_final);
     CHECK(fin.result_changed);
@@ -723,19 +701,21 @@ void test_stream_auto_known_family_uses_family_stable_prefix() {
     transcribe_session session;
     session.model = &model;
 
-    g_feed_texts[0] = "family stable";
-    g_n_feed_texts = 1;
-    g_n_token_rows = 1;
-    g_token_texts[0] = "family stable";
+    g_feed_texts[0]             = "family stable";
+    g_n_feed_texts              = 1;
+    g_n_token_rows              = 1;
+    g_token_texts[0]            = "family stable";
     g_forced_n_committed_tokens = 1;
 
     CHECK(transcribe_stream_begin(&session, nullptr, nullptr) == TRANSCRIBE_OK);
 
-    float pcm = 0.0f;
-    transcribe_stream_update upd; transcribe_stream_update_init(&upd);
+    float                    pcm = 0.0f;
+    transcribe_stream_update upd;
+    transcribe_stream_update_init(&upd);
     CHECK(transcribe_stream_feed(&session, &pcm, 1, &upd) == TRANSCRIBE_OK);
 
-    transcribe_stream_text text; transcribe_stream_text_init(&text);
+    transcribe_stream_text text;
+    transcribe_stream_text_init(&text);
     CHECK(transcribe_stream_get_text(&session, &text) == TRANSCRIBE_OK);
     CHECK(std::strcmp(text.committed_text, "family stable") == 0);
     CHECK(std::strcmp(text.tentative_text, "") == 0);
@@ -747,21 +727,23 @@ void test_stream_auto_unknown_family_falls_back_to_generic_stable_prefix() {
     transcribe_session session;
     session.model = &model;
 
-    g_feed_texts[0] = "generic stable";
-    g_feed_texts[1] = "generic stable";
-    g_feed_texts[2] = "generic stable";
-    g_n_feed_texts = 3;
-    g_n_token_rows = 1;
-    g_token_texts[0] = "generic stable";
+    g_feed_texts[0]             = "generic stable";
+    g_feed_texts[1]             = "generic stable";
+    g_feed_texts[2]             = "generic stable";
+    g_n_feed_texts              = 3;
+    g_n_token_rows              = 1;
+    g_token_texts[0]            = "generic stable";
     g_forced_n_committed_tokens = 1;
 
     CHECK(transcribe_stream_begin(&session, nullptr, nullptr) == TRANSCRIBE_OK);
 
-    float pcm = 0.0f;
-    transcribe_stream_update upd; transcribe_stream_update_init(&upd);
+    float                    pcm = 0.0f;
+    transcribe_stream_update upd;
+    transcribe_stream_update_init(&upd);
     CHECK(transcribe_stream_feed(&session, &pcm, 1, &upd) == TRANSCRIBE_OK);
 
-    transcribe_stream_text text; transcribe_stream_text_init(&text);
+    transcribe_stream_text text;
+    transcribe_stream_text_init(&text);
     CHECK(transcribe_stream_get_text(&session, &text) == TRANSCRIBE_OK);
     CHECK(std::strcmp(text.committed_text, "") == 0);
     CHECK(std::strcmp(text.tentative_text, "generic stable") == 0);
@@ -792,23 +774,26 @@ void test_stream_stable_prefix_known_family_uses_family_boundary() {
     transcribe_session session;
     session.model = &model;
 
-    g_feed_texts[0] = "token stable";
-    g_n_feed_texts = 1;
-    g_n_token_rows = 1;
-    g_token_texts[0] = "token stable";
+    g_feed_texts[0]             = "token stable";
+    g_n_feed_texts              = 1;
+    g_n_token_rows              = 1;
+    g_token_texts[0]            = "token stable";
     g_forced_n_committed_tokens = 1;
 
-    transcribe_stream_params sp; transcribe_stream_params_init(&sp);
-    sp.commit_policy = TRANSCRIBE_STREAM_COMMIT_STABLE_PREFIX;
+    transcribe_stream_params sp;
+    transcribe_stream_params_init(&sp);
+    sp.commit_policy             = TRANSCRIBE_STREAM_COMMIT_STABLE_PREFIX;
     sp.stable_prefix_agreement_n = 3;
     CHECK(transcribe_stream_begin(&session, nullptr, &sp) == TRANSCRIBE_OK);
 
-    float pcm = 0.0f;
-    transcribe_stream_update upd; transcribe_stream_update_init(&upd);
+    float                    pcm = 0.0f;
+    transcribe_stream_update upd;
+    transcribe_stream_update_init(&upd);
     CHECK(transcribe_stream_feed(&session, &pcm, 1, &upd) == TRANSCRIBE_OK);
     CHECK(upd.committed_changed);
 
-    transcribe_stream_text text; transcribe_stream_text_init(&text);
+    transcribe_stream_text text;
+    transcribe_stream_text_init(&text);
     CHECK(transcribe_stream_get_text(&session, &text) == TRANSCRIBE_OK);
     CHECK(std::strcmp(text.committed_text, "token stable") == 0);
     CHECK(std::strcmp(text.tentative_text, "") == 0);
@@ -821,20 +806,22 @@ void test_stream_family_token_prefix_maps_trimmed_leading_space() {
     transcribe_session session;
     session.model = &model;
 
-    g_feed_texts[0] = "And";
-    g_n_feed_texts = 1;
-    g_n_token_rows = 1;
-    g_token_texts[0] = " And";
+    g_feed_texts[0]             = "And";
+    g_n_feed_texts              = 1;
+    g_n_token_rows              = 1;
+    g_token_texts[0]            = " And";
     g_forced_n_committed_tokens = 1;
 
     CHECK(transcribe_stream_begin(&session, nullptr, nullptr) == TRANSCRIBE_OK);
 
-    float pcm = 0.0f;
-    transcribe_stream_update upd; transcribe_stream_update_init(&upd);
+    float                    pcm = 0.0f;
+    transcribe_stream_update upd;
+    transcribe_stream_update_init(&upd);
     CHECK(transcribe_stream_feed(&session, &pcm, 1, &upd) == TRANSCRIBE_OK);
     CHECK(upd.committed_changed);
 
-    transcribe_stream_text text; transcribe_stream_text_init(&text);
+    transcribe_stream_text text;
+    transcribe_stream_text_init(&text);
     CHECK(transcribe_stream_get_text(&session, &text) == TRANSCRIBE_OK);
     CHECK(std::strcmp(text.full_text, "And") == 0);
     CHECK(std::strcmp(text.committed_text, "And") == 0);
@@ -847,22 +834,25 @@ void test_stream_text_stable_prefix_does_not_rewrite_committed() {
     transcribe_session session;
     session.model = &model;
 
-    g_feed_texts[0] = "hello wor";
-    g_feed_texts[1] = "hello world";
-    g_feed_texts[2] = "hullo world!";
-    g_n_feed_texts = 3;
-    g_finalize_text = "hullo world!!";
+    g_feed_texts[0]           = "hello wor";
+    g_feed_texts[1]           = "hello world";
+    g_feed_texts[2]           = "hullo world!";
+    g_n_feed_texts            = 3;
+    g_finalize_text           = "hullo world!!";
     g_feed_audio_committed_us = 0;
 
-    transcribe_stream_params sp; transcribe_stream_params_init(&sp);
-    sp.commit_policy = TRANSCRIBE_STREAM_COMMIT_STABLE_PREFIX;
+    transcribe_stream_params sp;
+    transcribe_stream_params_init(&sp);
+    sp.commit_policy             = TRANSCRIBE_STREAM_COMMIT_STABLE_PREFIX;
     sp.stable_prefix_agreement_n = 2;
     CHECK(transcribe_stream_begin(&session, nullptr, &sp) == TRANSCRIBE_OK);
 
-    float pcm = 0.0f;
-    transcribe_stream_update upd; transcribe_stream_update_init(&upd);
+    float                    pcm = 0.0f;
+    transcribe_stream_update upd;
+    transcribe_stream_update_init(&upd);
     CHECK(transcribe_stream_feed(&session, &pcm, 1, &upd) == TRANSCRIBE_OK);
-    transcribe_stream_text text; transcribe_stream_text_init(&text);
+    transcribe_stream_text text;
+    transcribe_stream_text_init(&text);
     CHECK(transcribe_stream_get_text(&session, &text) == TRANSCRIBE_OK);
     CHECK(std::strcmp(text.committed_text, "") == 0);
     CHECK(std::strcmp(text.tentative_text, "hello wor") == 0);
@@ -886,7 +876,8 @@ void test_stream_text_stable_prefix_does_not_rewrite_committed() {
     CHECK(std::strcmp(text.committed_text, "hello wor") == 0);
     CHECK(std::strcmp(text.tentative_text, "ld!") == 0);
 
-    transcribe_stream_update fin; transcribe_stream_update_init(&fin);
+    transcribe_stream_update fin;
+    transcribe_stream_update_init(&fin);
     CHECK(transcribe_stream_finalize(&session, &fin) == TRANSCRIBE_OK);
     CHECK(!fin.committed_changed);
     CHECK(fin.tentative_changed);
@@ -908,21 +899,24 @@ void test_stream_text_clamps_raw_tentative_offset_after_shrink() {
     g_feed_texts[0] = "hello wor";
     g_feed_texts[1] = "hello world";
     g_feed_texts[2] = "hi";
-    g_n_feed_texts = 3;
+    g_n_feed_texts  = 3;
     g_finalize_text = "hi";
 
-    transcribe_stream_params sp; transcribe_stream_params_init(&sp);
-    sp.commit_policy = TRANSCRIBE_STREAM_COMMIT_STABLE_PREFIX;
+    transcribe_stream_params sp;
+    transcribe_stream_params_init(&sp);
+    sp.commit_policy             = TRANSCRIBE_STREAM_COMMIT_STABLE_PREFIX;
     sp.stable_prefix_agreement_n = 2;
     CHECK(transcribe_stream_begin(&session, nullptr, &sp) == TRANSCRIBE_OK);
 
-    float pcm = 0.0f;
-    transcribe_stream_update upd; transcribe_stream_update_init(&upd);
+    float                    pcm = 0.0f;
+    transcribe_stream_update upd;
+    transcribe_stream_update_init(&upd);
     CHECK(transcribe_stream_feed(&session, &pcm, 1, &upd) == TRANSCRIBE_OK);
     transcribe_stream_update_init(&upd);
     CHECK(transcribe_stream_feed(&session, &pcm, 1, &upd) == TRANSCRIBE_OK);
 
-    transcribe_stream_text text; transcribe_stream_text_init(&text);
+    transcribe_stream_text text;
+    transcribe_stream_text_init(&text);
     CHECK(transcribe_stream_get_text(&session, &text) == TRANSCRIBE_OK);
     CHECK(std::strcmp(text.committed_text, "hello wor") == 0);
 
@@ -944,18 +938,19 @@ void test_stream_committed_row_hints_can_exceed_current_rows() {
     transcribe_session session;
     session.model = &model;
 
-    g_feed_texts[0] = "abc";
-    g_n_feed_texts = 1;
-    g_n_token_rows = 1;
-    g_token_texts[0] = "abc";
-    g_forced_n_committed_tokens = 7;
-    g_forced_n_committed_words = 3;
+    g_feed_texts[0]               = "abc";
+    g_n_feed_texts                = 1;
+    g_n_token_rows                = 1;
+    g_token_texts[0]              = "abc";
+    g_forced_n_committed_tokens   = 7;
+    g_forced_n_committed_words    = 3;
     g_forced_n_committed_segments = 2;
 
     CHECK(transcribe_stream_begin(&session, nullptr, nullptr) == TRANSCRIBE_OK);
 
-    float pcm = 0.0f;
-    transcribe_stream_update upd; transcribe_stream_update_init(&upd);
+    float                    pcm = 0.0f;
+    transcribe_stream_update upd;
+    transcribe_stream_update_init(&upd);
     CHECK(transcribe_stream_feed(&session, &pcm, 1, &upd) == TRANSCRIBE_OK);
     CHECK(transcribe_n_tokens(&session) == 1);
     CHECK(transcribe_stream_n_committed_tokens(&session) == 7);
@@ -969,28 +964,31 @@ void test_stream_text_stable_prefix_floors_utf8_boundary() {
     transcribe_session session;
     session.model = &model;
 
-    static const char cafe_acute[] = "caf\303\251"; // cafe + U+00E9
-    static const char cafe_circ[]  = "caf\303\252"; // cafe + U+00EA
-    g_feed_texts[0] = cafe_acute;
-    g_feed_texts[1] = cafe_circ;
-    g_n_feed_texts = 2;
-    g_finalize_text = cafe_circ;
-    g_feed_audio_committed_us = 0;
+    static const char cafe_acute[] = "caf\303\251";  // cafe + U+00E9
+    static const char cafe_circ[]  = "caf\303\252";  // cafe + U+00EA
+    g_feed_texts[0]                = cafe_acute;
+    g_feed_texts[1]                = cafe_circ;
+    g_n_feed_texts                 = 2;
+    g_finalize_text                = cafe_circ;
+    g_feed_audio_committed_us      = 0;
 
-    transcribe_stream_params sp; transcribe_stream_params_init(&sp);
-    sp.commit_policy = TRANSCRIBE_STREAM_COMMIT_STABLE_PREFIX;
+    transcribe_stream_params sp;
+    transcribe_stream_params_init(&sp);
+    sp.commit_policy             = TRANSCRIBE_STREAM_COMMIT_STABLE_PREFIX;
     sp.stable_prefix_agreement_n = 2;
     CHECK(transcribe_stream_begin(&session, nullptr, &sp) == TRANSCRIBE_OK);
 
-    float pcm = 0.0f;
-    transcribe_stream_update upd; transcribe_stream_update_init(&upd);
+    float                    pcm = 0.0f;
+    transcribe_stream_update upd;
+    transcribe_stream_update_init(&upd);
     CHECK(transcribe_stream_feed(&session, &pcm, 1, &upd) == TRANSCRIBE_OK);
 
     transcribe_stream_update_init(&upd);
     CHECK(transcribe_stream_feed(&session, &pcm, 1, &upd) == TRANSCRIBE_OK);
     CHECK(upd.committed_changed);
 
-    transcribe_stream_text text; transcribe_stream_text_init(&text);
+    transcribe_stream_text text;
+    transcribe_stream_text_init(&text);
     CHECK(transcribe_stream_get_text(&session, &text) == TRANSCRIBE_OK);
     CHECK(std::strcmp(text.full_text, cafe_circ) == 0);
     CHECK(std::strcmp(text.committed_text, "caf") == 0);
@@ -1008,21 +1006,24 @@ void test_stream_text_stable_prefix_respects_agreement_n() {
     g_feed_texts[0] = "agree now";
     g_feed_texts[1] = "agree now";
     g_feed_texts[2] = "agree now";
-    g_n_feed_texts = 3;
+    g_n_feed_texts  = 3;
     g_finalize_text = "agree now";
 
-    transcribe_stream_params sp; transcribe_stream_params_init(&sp);
-    sp.commit_policy = TRANSCRIBE_STREAM_COMMIT_STABLE_PREFIX;
+    transcribe_stream_params sp;
+    transcribe_stream_params_init(&sp);
+    sp.commit_policy             = TRANSCRIBE_STREAM_COMMIT_STABLE_PREFIX;
     sp.stable_prefix_agreement_n = 3;
     CHECK(transcribe_stream_begin(&session, nullptr, &sp) == TRANSCRIBE_OK);
 
-    float pcm = 0.0f;
-    transcribe_stream_update upd; transcribe_stream_update_init(&upd);
+    float                    pcm = 0.0f;
+    transcribe_stream_update upd;
+    transcribe_stream_update_init(&upd);
     CHECK(transcribe_stream_feed(&session, &pcm, 1, &upd) == TRANSCRIBE_OK);
     transcribe_stream_update_init(&upd);
     CHECK(transcribe_stream_feed(&session, &pcm, 1, &upd) == TRANSCRIBE_OK);
 
-    transcribe_stream_text text; transcribe_stream_text_init(&text);
+    transcribe_stream_text text;
+    transcribe_stream_text_init(&text);
     CHECK(transcribe_stream_get_text(&session, &text) == TRANSCRIBE_OK);
     CHECK(std::strcmp(text.committed_text, "") == 0);
     CHECK(std::strcmp(text.tentative_text, "agree now") == 0);
@@ -1043,10 +1044,10 @@ void test_old_stream_params_ignores_new_tail_fields() {
     transcribe_session session;
     session.model = &model;
 
-    transcribe_stream_params sp; transcribe_stream_params_init(&sp);
-    sp.struct_size = offsetof(transcribe_stream_params, commit_policy);
-    sp.commit_policy =
-        static_cast<transcribe_stream_commit_policy>(99);
+    transcribe_stream_params sp;
+    transcribe_stream_params_init(&sp);
+    sp.struct_size               = offsetof(transcribe_stream_params, commit_policy);
+    sp.commit_policy             = static_cast<transcribe_stream_commit_policy>(99);
     sp.stable_prefix_agreement_n = 99;
 
     CHECK(transcribe_stream_begin(&session, nullptr, &sp) == TRANSCRIBE_OK);
@@ -1060,24 +1061,27 @@ void test_stream_text_stable_prefix_intentionally_commits_partial_words() {
     transcribe_session session;
     session.model = &model;
 
-    g_feed_texts[0] = "turn le";
-    g_feed_texts[1] = "turn left";
-    g_n_feed_texts = 2;
-    g_finalize_text = "turn left";
+    g_feed_texts[0]           = "turn le";
+    g_feed_texts[1]           = "turn left";
+    g_n_feed_texts            = 2;
+    g_finalize_text           = "turn left";
     g_feed_audio_committed_us = 0;
 
-    transcribe_stream_params sp; transcribe_stream_params_init(&sp);
-    sp.commit_policy = TRANSCRIBE_STREAM_COMMIT_STABLE_PREFIX;
+    transcribe_stream_params sp;
+    transcribe_stream_params_init(&sp);
+    sp.commit_policy             = TRANSCRIBE_STREAM_COMMIT_STABLE_PREFIX;
     sp.stable_prefix_agreement_n = 2;
     CHECK(transcribe_stream_begin(&session, nullptr, &sp) == TRANSCRIBE_OK);
 
-    float pcm = 0.0f;
-    transcribe_stream_update upd; transcribe_stream_update_init(&upd);
+    float                    pcm = 0.0f;
+    transcribe_stream_update upd;
+    transcribe_stream_update_init(&upd);
     CHECK(transcribe_stream_feed(&session, &pcm, 1, &upd) == TRANSCRIBE_OK);
     transcribe_stream_update_init(&upd);
     CHECK(transcribe_stream_feed(&session, &pcm, 1, &upd) == TRANSCRIBE_OK);
 
-    transcribe_stream_text text; transcribe_stream_text_init(&text);
+    transcribe_stream_text text;
+    transcribe_stream_text_init(&text);
     CHECK(transcribe_stream_get_text(&session, &text) == TRANSCRIBE_OK);
     CHECK(std::strcmp(text.committed_text, "turn le") == 0);
     CHECK(std::strcmp(text.tentative_text, "ft") == 0);
@@ -1089,17 +1093,19 @@ void test_stream_update_old_prefix_tail_untouched() {
     transcribe_session session;
     session.model = &model;
 
-    g_feed_texts[0] = "old prefix";
-    g_n_feed_texts = 1;
-    g_finalize_text = "old prefix";
+    g_feed_texts[0]           = "old prefix";
+    g_n_feed_texts            = 1;
+    g_finalize_text           = "old prefix";
     g_feed_audio_committed_us = 0;
 
-    transcribe_stream_params sp; transcribe_stream_params_init(&sp);
+    transcribe_stream_params sp;
+    transcribe_stream_params_init(&sp);
     sp.commit_policy = TRANSCRIBE_STREAM_COMMIT_ON_FINALIZE;
     CHECK(transcribe_stream_begin(&session, nullptr, &sp) == TRANSCRIBE_OK);
 
-    transcribe_stream_update upd; transcribe_stream_update_init(&upd);
-    upd.struct_size = offsetof(transcribe_stream_update, committed_changed);
+    transcribe_stream_update upd;
+    transcribe_stream_update_init(&upd);
+    upd.struct_size       = offsetof(transcribe_stream_update, committed_changed);
     upd.committed_changed = true;
     upd.tentative_changed = false;
 
@@ -1114,21 +1120,21 @@ void test_stream_update_old_prefix_tail_untouched() {
 void test_begin_rejects_bad_commit_params_before_clear() {
     transcribe_session session;
     session.has_result = true;
-    session.full_text = "previous";
+    session.full_text  = "previous";
 
-    transcribe_run_params rp; transcribe_run_params_init(&rp);
+    transcribe_run_params rp;
+    transcribe_run_params_init(&rp);
 
-    transcribe_stream_params sp; transcribe_stream_params_init(&sp);
+    transcribe_stream_params sp;
+    transcribe_stream_params_init(&sp);
     sp.commit_policy = static_cast<transcribe_stream_commit_policy>(99);
-    CHECK(transcribe_stream_begin(&session, &rp, &sp) ==
-          TRANSCRIBE_ERR_INVALID_ARG);
+    CHECK(transcribe_stream_begin(&session, &rp, &sp) == TRANSCRIBE_ERR_INVALID_ARG);
     CHECK(session.has_result);
     CHECK(session.full_text == "previous");
 
     transcribe_stream_params_init(&sp);
     sp.stable_prefix_agreement_n = 33;
-    CHECK(transcribe_stream_begin(&session, &rp, &sp) ==
-          TRANSCRIBE_ERR_INVALID_ARG);
+    CHECK(transcribe_stream_begin(&session, &rp, &sp) == TRANSCRIBE_ERR_INVALID_ARG);
     CHECK(session.has_result);
     CHECK(session.full_text == "previous");
 }
@@ -1145,7 +1151,7 @@ void test_begin_rejects_bad_commit_params_before_clear() {
 bool g_abort_flag = false;
 
 bool abort_cb_returns_flag(void * userdata) {
-    (void)userdata;
+    (void) userdata;
     return g_abort_flag;
 }
 
@@ -1153,41 +1159,34 @@ bool abort_cb_returns_flag(void * userdata) {
 // some output before hitting a terminal error mid-feed. The partial
 // snapshot must remain readable (the dispatcher does not clear it on the
 // failure path).
-transcribe_status fake_failing_stream_feed(
-    transcribe_session *       session,
-    const float *              pcm,
-    int                        n_samples,
-    transcribe_stream_update * update)
-{
-    (void)pcm;
-    (void)n_samples;
-    (void)update;
+transcribe_status fake_failing_stream_feed(transcribe_session *       session,
+                                           const float *              pcm,
+                                           int                        n_samples,
+                                           transcribe_stream_update * update) {
+    (void) pcm;
+    (void) n_samples;
+    (void) update;
     session->full_text  = "partial before failure";
     session->has_result = true;
     return TRANSCRIBE_ERR_BACKEND;
 }
 
-transcribe_status fake_failing_stream_finalize(
-    transcribe_session *       session,
-    transcribe_stream_update * update)
-{
-    (void)session;
-    (void)update;
+transcribe_status fake_failing_stream_finalize(transcribe_session * session, transcribe_stream_update * update) {
+    (void) session;
+    (void) update;
     return TRANSCRIBE_ERR_BACKEND;
 }
 
 // Polls the session abort callback the way a real family hook must. When
 // the callback fires, poll_abort() sets session->was_aborted and we
 // return the terminal ABORTED status; otherwise the feed succeeds.
-transcribe_status fake_aborting_stream_feed(
-    transcribe_session *       session,
-    const float *              pcm,
-    int                        n_samples,
-    transcribe_stream_update * update)
-{
-    (void)pcm;
-    (void)n_samples;
-    (void)update;
+transcribe_status fake_aborting_stream_feed(transcribe_session *       session,
+                                            const float *              pcm,
+                                            int                        n_samples,
+                                            transcribe_stream_update * update) {
+    (void) pcm;
+    (void) n_samples;
+    (void) update;
     if (session->poll_abort()) {
         return TRANSCRIBE_ERR_ABORTED;
     }
@@ -1202,9 +1201,9 @@ const transcribe::Arch & failing_arch() {
         nullptr,
         nullptr,
         nullptr,
-        nullptr,                     // run_batch
+        nullptr,            // run_batch
         nullptr,
-        fake_stream_begin,           // begin succeeds -> ACTIVE
+        fake_stream_begin,  // begin succeeds -> ACTIVE
         fake_failing_stream_feed,
         fake_failing_stream_finalize,
         nullptr,
@@ -1219,7 +1218,7 @@ const transcribe::Arch & aborting_arch() {
         nullptr,
         nullptr,
         nullptr,
-        nullptr,                  // run_batch
+        nullptr,  // run_batch
         nullptr,
         fake_stream_begin,
         fake_aborting_stream_feed,
@@ -1231,7 +1230,7 @@ const transcribe::Arch & aborting_arch() {
 }
 
 void setup_streaming_model(transcribe_model & model, const transcribe::Arch & arch) {
-    model.arch = &arch;
+    model.arch                    = &arch;
     model.caps.supports_streaming = true;
     model.caps.max_timestamp_kind = TRANSCRIBE_TIMESTAMPS_NONE;
 }
@@ -1245,8 +1244,9 @@ void test_feed_failure_transitions_to_failed() {
     CHECK(transcribe_stream_begin(&session, nullptr, nullptr) == TRANSCRIBE_OK);
     CHECK(transcribe_stream_get_state(&session) == TRANSCRIBE_STREAM_ACTIVE);
 
-    float pcm = 0.0f;
-    transcribe_stream_update upd; transcribe_stream_update_init(&upd);
+    float                    pcm = 0.0f;
+    transcribe_stream_update upd;
+    transcribe_stream_update_init(&upd);
     CHECK(transcribe_stream_feed(&session, &pcm, 1, &upd) == TRANSCRIBE_ERR_BACKEND);
 
     // ACTIVE -> FAILED, terminal status preserved, partial result readable.
@@ -1261,8 +1261,7 @@ void test_feed_failure_transitions_to_failed() {
 
     // A FAILED stream rejects further feeds and the terminal status survives
     // the rejected call.
-    CHECK(transcribe_stream_feed(&session, &pcm, 1, nullptr) ==
-          TRANSCRIBE_ERR_INVALID_ARG);
+    CHECK(transcribe_stream_feed(&session, &pcm, 1, nullptr) == TRANSCRIBE_ERR_INVALID_ARG);
     CHECK(transcribe_stream_get_state(&session) == TRANSCRIBE_STREAM_FAILED);
     CHECK(transcribe_stream_last_status(&session) == TRANSCRIBE_ERR_BACKEND);
 
@@ -1281,7 +1280,8 @@ void test_finalize_failure_transitions_to_failed() {
     // Begin only (no feed — failing_arch's feed would fail first); finalize
     // an ACTIVE stream and let the family hook fail.
     CHECK(transcribe_stream_begin(&session, nullptr, nullptr) == TRANSCRIBE_OK);
-    transcribe_stream_update upd; transcribe_stream_update_init(&upd);
+    transcribe_stream_update upd;
+    transcribe_stream_update_init(&upd);
     CHECK(transcribe_stream_finalize(&session, &upd) == TRANSCRIBE_ERR_BACKEND);
     CHECK(transcribe_stream_get_state(&session) == TRANSCRIBE_STREAM_FAILED);
     CHECK(transcribe_stream_last_status(&session) == TRANSCRIBE_ERR_BACKEND);
@@ -1300,8 +1300,9 @@ void test_feed_abort_sets_was_aborted() {
 
     CHECK(transcribe_stream_begin(&session, nullptr, nullptr) == TRANSCRIBE_OK);
 
-    float pcm = 0.0f;
-    transcribe_stream_update upd; transcribe_stream_update_init(&upd);
+    float                    pcm = 0.0f;
+    transcribe_stream_update upd;
+    transcribe_stream_update_init(&upd);
 
     // First feed: callback says "don't abort" -> succeeds, not aborted.
     g_abort_flag = false;
@@ -1343,8 +1344,9 @@ void test_two_sessions_independent_streams() {
     transcribe_set_abort_callback(&b, abort_cb_returns_flag, nullptr);
     g_abort_flag = false;
 
-    float pcm = 0.0f;
-    transcribe_stream_update upd; transcribe_stream_update_init(&upd);
+    float                    pcm = 0.0f;
+    transcribe_stream_update upd;
+    transcribe_stream_update_init(&upd);
 
     // A enters ACTIVE; B is untouched.
     CHECK(transcribe_stream_begin(&a, nullptr, nullptr) == TRANSCRIBE_OK);
@@ -1391,32 +1393,27 @@ void test_two_sessions_independent_streams() {
 // (ASan: heap-use-after-free; plain build: the scribbled bytes); with it the
 // feed must see the original string.
 
-transcribe_run_params g_retained_rp;        // the family-side shallow copy
+transcribe_run_params g_retained_rp;  // the family-side shallow copy
 std::string           g_language_seen_at_feed;
 
-transcribe_status retain_stream_begin(
-    transcribe_session *              session,
-    const transcribe_run_params *     run_params,
-    const transcribe_stream_params *  stream_params)
-{
-    (void)session;
-    (void)stream_params;
+transcribe_status retain_stream_begin(transcribe_session *             session,
+                                      const transcribe_run_params *    run_params,
+                                      const transcribe_stream_params * stream_params) {
+    (void) session;
+    (void) stream_params;
     g_retained_rp = *run_params;  // exactly what parakeet/moonshine do
     return TRANSCRIBE_OK;
 }
 
-transcribe_status retain_stream_feed(
-    transcribe_session *       session,
-    const float *              pcm,
-    int                        n_samples,
-    transcribe_stream_update * update)
-{
-    (void)session;
-    (void)pcm;
-    (void)n_samples;
-    (void)update;
-    g_language_seen_at_feed =
-        g_retained_rp.language != nullptr ? g_retained_rp.language : "<null>";
+transcribe_status retain_stream_feed(transcribe_session *       session,
+                                     const float *              pcm,
+                                     int                        n_samples,
+                                     transcribe_stream_update * update) {
+    (void) session;
+    (void) pcm;
+    (void) n_samples;
+    (void) update;
+    g_language_seen_at_feed = g_retained_rp.language != nullptr ? g_retained_rp.language : "<null>";
     return TRANSCRIBE_OK;
 }
 
@@ -1427,7 +1424,7 @@ void test_begin_copies_param_strings_out() {
         nullptr,
         nullptr,
         nullptr,  // run_batch
-        nullptr,                  // stream_validate
+        nullptr,  // stream_validate
         retain_stream_begin,
         retain_stream_feed,
         fake_stream_finalize,
@@ -1436,7 +1433,7 @@ void test_begin_copies_param_strings_out() {
     };
 
     transcribe_model model;
-    model.arch = &arch;
+    model.arch                    = &arch;
     model.caps.supports_streaming = true;
     model.caps.max_timestamp_kind = TRANSCRIBE_TIMESTAMPS_NONE;
 
@@ -1446,14 +1443,14 @@ void test_begin_copies_param_strings_out() {
     // FFI-shaped caller: the params struct and its language string live on
     // the heap and are destroyed the moment begin returns (a ctypes binding
     // garbage-collects them exactly like this).
-    auto * rp = static_cast<transcribe_run_params *>(
-        std::malloc(sizeof(transcribe_run_params)));
+    auto * rp = static_cast<transcribe_run_params *>(std::malloc(sizeof(transcribe_run_params)));
     transcribe_run_params_init(rp);
     char * lang = static_cast<char *>(std::malloc(16));
     std::snprintf(lang, 16, "en-US");
     rp->language = lang;
 
-    transcribe_stream_params sp; transcribe_stream_params_init(&sp);
+    transcribe_stream_params sp;
+    transcribe_stream_params_init(&sp);
     g_language_seen_at_feed.clear();
     CHECK(transcribe_stream_begin(&session, rp, &sp) == TRANSCRIBE_OK);
 
@@ -1464,7 +1461,8 @@ void test_begin_copies_param_strings_out() {
     std::free(lang);
     std::free(rp);
 
-    transcribe_stream_update up; transcribe_stream_update_init(&up);
+    transcribe_stream_update up;
+    transcribe_stream_update_init(&up);
     const float pcm[160] = {};
     CHECK(transcribe_stream_feed(&session, pcm, 160, &up) == TRANSCRIBE_OK);
     CHECK(g_language_seen_at_feed == "en-US");
@@ -1498,25 +1496,27 @@ void test_begin_accepts_min_prefix_run_params() {
     };
 
     transcribe_model model;
-    model.arch = &arch;
+    model.arch                    = &arch;
     model.caps.supports_streaming = true;
     model.caps.max_timestamp_kind = TRANSCRIBE_TIMESTAMPS_NONE;
 
     transcribe_session session;
     session.model = &model;
 
-    const size_t min_size = offsetof(transcribe_run_params, family) +
-                            sizeof(((transcribe_run_params *) nullptr)->family);
+    const size_t min_size =
+        offsetof(transcribe_run_params, family) + sizeof(((transcribe_run_params *) nullptr)->family);
 
     // Stage full defaults on the stack, then heap-allocate ONLY the
     // prefix and declare exactly that many bytes via struct_size.
-    transcribe_run_params staged; transcribe_run_params_init(&staged);
+    transcribe_run_params staged;
+    transcribe_run_params_init(&staged);
     staged.struct_size = min_size;
-    staged.language = "en";  // exercise the string copy alongside
-    auto * rp = static_cast<transcribe_run_params *>(std::malloc(min_size));
+    staged.language    = "en";  // exercise the string copy alongside
+    auto * rp          = static_cast<transcribe_run_params *>(std::malloc(min_size));
     std::memcpy(rp, &staged, min_size);
 
-    transcribe_stream_params sp; transcribe_stream_params_init(&sp);
+    transcribe_stream_params sp;
+    transcribe_stream_params_init(&sp);
     g_retained_rp = transcribe_run_params{};
     g_language_seen_at_feed.clear();
     CHECK(transcribe_stream_begin(&session, rp, &sp) == TRANSCRIBE_OK);
@@ -1528,7 +1528,8 @@ void test_begin_accepts_min_prefix_run_params() {
     CHECK(g_retained_rp.struct_size == min_size);
     CHECK(g_retained_rp.spec_k_drafts == -1);
 
-    transcribe_stream_update up; transcribe_stream_update_init(&up);
+    transcribe_stream_update up;
+    transcribe_stream_update_init(&up);
     const float pcm[160] = {};
     CHECK(transcribe_stream_feed(&session, pcm, 160, &up) == TRANSCRIBE_OK);
     CHECK(g_language_seen_at_feed == "en");
@@ -1536,7 +1537,7 @@ void test_begin_accepts_min_prefix_run_params() {
     transcribe_stream_reset(&session);
 }
 
-} // namespace
+}  // namespace
 
 int main() {
     test_accessors_on_null_ctx();
diff --git a/tests/thread_default_unit.cpp b/tests/thread_default_unit.cpp
index 61f2ee45..9e67e184 100644
--- a/tests/thread_default_unit.cpp
+++ b/tests/thread_default_unit.cpp
@@ -19,38 +19,37 @@
 #include <cstdio>
 
 #if defined(__linux__)
-#include <sched.h>
+#    include <sched.h>
 #elif defined(_WIN32)
-#ifndef WIN32_LEAN_AND_MEAN
-#define WIN32_LEAN_AND_MEAN
-#endif
-#ifndef NOMINMAX  // else <windows.h>'s min/max macros clobber std::min/std::max
-#define NOMINMAX
-#endif
-#include <windows.h>
+#    ifndef WIN32_LEAN_AND_MEAN
+#        define WIN32_LEAN_AND_MEAN
+#    endif
+#    ifndef NOMINMAX  // else <windows.h>'s min/max macros clobber std::min/std::max
+#        define NOMINMAX
+#    endif
+#    include <windows.h>
 #endif
 
 namespace {
 
 int g_failures = 0;
 
-#define CHECK(cond)                                                         \
-    do {                                                                    \
-        if (!(cond)) {                                                      \
-            std::fprintf(stderr, "FAIL %s:%d: %s\n",                        \
-                         __FILE__, __LINE__, #cond);                        \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK(cond)                                                              \
+    do {                                                                         \
+        if (!(cond)) {                                                           \
+            std::fprintf(stderr, "FAIL %s:%d: %s\n", __FILE__, __LINE__, #cond); \
+            ++g_failures;                                                        \
+        }                                                                        \
     } while (0)
 
 // default_n_threads(): cap and range, independent of platform.
 void test_default_range_and_cap() {
     const int uncapped = transcribe::default_n_threads(/*cap=*/0);
-    CHECK(uncapped >= 1);                       // always at least one thread
+    CHECK(uncapped >= 1);  // always at least one thread
 
     const int capped8 = transcribe::default_n_threads(8);
     CHECK(capped8 >= 1);
-    CHECK(capped8 <= 8);                        // cap is honored
+    CHECK(capped8 <= 8);                              // cap is honored
     CHECK(capped8 == (uncapped < 8 ? uncapped : 8));  // cap = min(uncapped, 8)
 
     CHECK(transcribe::default_n_threads(1) == 1);     // cap of 1 pins to 1
@@ -86,7 +85,9 @@ void test_affinity_honored_linux() {
     int cpus[CPU_SETSIZE];
     int n_cpus = 0;
     for (int c = 0; c < CPU_SETSIZE && n_cpus < avail; ++c) {
-        if (CPU_ISSET(c, &original)) cpus[n_cpus++] = c;
+        if (CPU_ISSET(c, &original)) {
+            cpus[n_cpus++] = c;
+        }
     }
 
     // Pin to exactly one CPU -> default_n_threads must be 1.
@@ -119,8 +120,8 @@ void test_affinity_honored_linux() {
 // core count. Pin the process to K CPUs via SetProcessAffinityMask and expect K.
 // Skips gracefully if affinity changes aren't permitted.
 void test_affinity_honored_windows() {
-    const HANDLE proc = GetCurrentProcess();
-    DWORD_PTR proc_mask = 0, sys_mask = 0;
+    const HANDLE proc      = GetCurrentProcess();
+    DWORD_PTR    proc_mask = 0, sys_mask = 0;
     if (!GetProcessAffinityMask(proc, &proc_mask, &sys_mask) || proc_mask == 0) {
         std::fprintf(stderr, "SKIP affinity test: GetProcessAffinityMask failed\n");
         return;
diff --git a/tests/threadpool_oversubscription.c b/tests/threadpool_oversubscription.c
index cf133000..4a7e0522 100644
--- a/tests/threadpool_oversubscription.c
+++ b/tests/threadpool_oversubscription.c
@@ -21,21 +21,23 @@
 // oversubscribes. A watchdog turns a hang into a test FAILURE (exit code 2)
 // instead of an indefinite hang.
 
-#include "ggml.h"
 #include "ggml-cpu.h"
+#include "ggml.h"
 
+#include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <stdint.h>
 
 #if defined(_WIN32)
-#include <windows.h>
+#    include <windows.h>
+
 static DWORD WINAPI watchdog_main(LPVOID arg) {
-    DWORD timeout_ms = (DWORD)(uintptr_t)arg;
+    DWORD timeout_ms = (DWORD) (uintptr_t) arg;
     Sleep(timeout_ms);
     fprintf(stderr,
-        "DEADLOCK: ggml_graph_compute did not finish within %lu ms "
-        "(ggml_barrier livelock under CPU oversubscription)\n", timeout_ms);
+            "DEADLOCK: ggml_graph_compute did not finish within %lu ms "
+            "(ggml_barrier livelock under CPU oversubscription)\n",
+            timeout_ms);
     fflush(stderr);
     ExitProcess(2);
     return 0;
@@ -43,30 +45,33 @@ static DWORD WINAPI watchdog_main(LPVOID arg) {
 #endif
 
 int main(int argc, char ** argv) {
-    const int n_threads = argc > 1 ? atoi(argv[1]) : 4;    // > available CPUs below
-    const int n_iters   = argc > 2 ? atoi(argv[2]) : 50;   // each does many barriers
-    const int chain     = argc > 3 ? atoi(argv[3]) : 64;   // graph nodes per compute
+    const int n_threads = argc > 1 ? atoi(argv[1]) : 4;   // > available CPUs below
+    const int n_iters   = argc > 2 ? atoi(argv[2]) : 50;  // each does many barriers
+    const int chain     = argc > 3 ? atoi(argv[3]) : 64;  // graph nodes per compute
 
 #if defined(_WIN32)
     // Force oversubscription: restrict the process to 2 logical CPUs, so the
     // default n_threads=4 has more threads than cores (what a 2-vCPU CI box has
     // naturally). Without this the bug only shows on machines with few cores.
-    if (!SetProcessAffinityMask(GetCurrentProcess(), (DWORD_PTR)0x3)) {
+    if (!SetProcessAffinityMask(GetCurrentProcess(), (DWORD_PTR) 0x3)) {
         fprintf(stderr, "warning: SetProcessAffinityMask failed (%lu)\n", GetLastError());
     }
     // 15s watchdog -> converts a hang into exit code 2 instead of hanging CI.
-    CreateThread(NULL, 0, watchdog_main, (LPVOID)(uintptr_t)15000, 0, NULL);
+    CreateThread(NULL, 0, watchdog_main, (LPVOID) (uintptr_t) 15000, 0, NULL);
 #endif
 
     struct ggml_init_params params = {
-        /*.mem_size   =*/ (size_t)512 * 1024 * 1024,
-        /*.mem_buffer =*/ NULL,
-        /*.no_alloc   =*/ false,
+        /*.mem_size   =*/(size_t) 512 * 1024 * 1024,
+        /*.mem_buffer =*/NULL,
+        /*.no_alloc   =*/false,
     };
     struct ggml_context * ctx = ggml_init(params);
-    if (!ctx) { fprintf(stderr, "ggml_init failed\n"); return 1; }
+    if (!ctx) {
+        fprintf(stderr, "ggml_init failed\n");
+        return 1;
+    }
 
-    const int n = 1024;
+    const int            n = 1024;
     struct ggml_tensor * a = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, n);
     struct ggml_tensor * b = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, n);
     for (int i = 0; i < n; i++) {
@@ -84,8 +89,7 @@ int main(int argc, char ** argv) {
     struct ggml_cgraph * gf = ggml_new_graph(ctx);
     ggml_build_forward_expand(gf, cur);
 
-    printf("n_threads=%d iters=%d chain=%d (process pinned to 2 logical CPUs)\n",
-           n_threads, n_iters, chain);
+    printf("n_threads=%d iters=%d chain=%d (process pinned to 2 logical CPUs)\n", n_threads, n_iters, chain);
     fflush(stdout);
 
     for (int it = 0; it < n_iters; it++) {
@@ -94,7 +98,10 @@ int main(int argc, char ** argv) {
             fprintf(stderr, "ggml_graph_compute failed at iter %d (status %d)\n", it, st);
             return 1;
         }
-        if ((it % 10) == 0) { printf("  iter %d ok\n", it); fflush(stdout); }
+        if ((it % 10) == 0) {
+            printf("  iter %d ok\n", it);
+            fflush(stdout);
+        }
     }
 
     printf("PASS: %d computes completed, no barrier deadlock\n", n_iters);
diff --git a/tests/tokenizer_decode_only_unit.cpp b/tests/tokenizer_decode_only_unit.cpp
index 82f7bf7b..21f6a01a 100644
--- a/tests/tokenizer_decode_only_unit.cpp
+++ b/tests/tokenizer_decode_only_unit.cpp
@@ -35,26 +35,22 @@ namespace {
 
 int g_failures = 0;
 
-#define CHECK(cond)                                                         \
-    do {                                                                    \
-        if (!(cond)) {                                                      \
-            std::fprintf(stderr, "FAIL %s:%d: %s\n",                        \
-                         __FILE__, __LINE__, #cond);                        \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK(cond)                                                              \
+    do {                                                                         \
+        if (!(cond)) {                                                           \
+            std::fprintf(stderr, "FAIL %s:%d: %s\n", __FILE__, __LINE__, #cond); \
+            ++g_failures;                                                        \
+        }                                                                        \
     } while (0)
 
-#define CHECK_STR_EQ(a, b)                                                  \
-    do {                                                                    \
-        const std::string _av = (a);                                        \
-        const std::string _bv = (b);                                        \
-        if (_av != _bv) {                                                   \
-            std::fprintf(stderr,                                            \
-                         "FAIL %s:%d: \"%s\" != \"%s\"\n",                  \
-                         __FILE__, __LINE__,                                \
-                         _av.c_str(), _bv.c_str());                         \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK_STR_EQ(a, b)                                                                                        \
+    do {                                                                                                          \
+        const std::string _av = (a);                                                                              \
+        const std::string _bv = (b);                                                                              \
+        if (_av != _bv) {                                                                                         \
+            std::fprintf(stderr, "FAIL %s:%d: \"%s\" != \"%s\"\n", __FILE__, __LINE__, _av.c_str(), _bv.c_str()); \
+            ++g_failures;                                                                                         \
+        }                                                                                                         \
     } while (0)
 
 // UTF-8 of "é" is the two raw bytes 0xC3 0xA9. Under GPT-2's
@@ -62,16 +58,16 @@ int g_failures = 0;
 // ("©"). The UTF-8 encoding of those two codepoints is the four bytes
 // 0xC3 0x83 0xC2 0xA9 (the bytes of "é"). decode_gpt2_bytes inverts
 // the remap per codepoint to recover 0xC3 0xA9.
-const char k_eacute_raw[]   = "\xC3\xA9";              // "é" raw UTF-8
-const char k_eacute_remap[] = "\xC3\x83\xC2\xA9";      // "é" UTF-8
+const char k_eacute_raw[]   = "\xC3\xA9";          // "é" raw UTF-8
+const char k_eacute_remap[] = "\xC3\x83\xC2\xA9";  // "é" UTF-8
 
 void test_gpt2_decode_only() {
     transcribe::Tokenizer tok;
 
     std::vector<std::string> vocab;
-    vocab.emplace_back("hello");                  // id 0: ASCII passes through
-    vocab.emplace_back(k_eacute_remap);           // id 1: byte-remapped "é"
-    vocab.emplace_back("<|endoftext|>");          // id 2: special, falls back
+    vocab.emplace_back("hello");          // id 0: ASCII passes through
+    vocab.emplace_back(k_eacute_remap);   // id 1: byte-remapped "é"
+    vocab.emplace_back("<|endoftext|>");  // id 2: special, falls back
 
     transcribe::Tokenizer::DecodeOnlySpecials specials;
     specials.bos_id = 11;
@@ -99,15 +95,15 @@ void test_gpt2_decode_only() {
 
     // Decode: id 0 is ASCII, id 1 inverts the remap to raw "é".
     {
-        const int ids[] = {0};
+        const int ids[] = { 0 };
         CHECK_STR_EQ(tok.decode(ids, 1), "hello");
     }
     {
-        const int ids[] = {1};
+        const int ids[] = { 1 };
         CHECK_STR_EQ(tok.decode(ids, 1), k_eacute_raw);
     }
     {
-        const int ids[] = {0, 1};
+        const int ids[] = { 0, 1 };
         CHECK_STR_EQ(tok.decode(ids, 2), std::string("hello") + k_eacute_raw);
     }
 }
@@ -124,8 +120,8 @@ void test_raw_bytes_decode_only() {
     for (int i = 0; i < 256; ++i) {
         vocab.emplace_back(1, static_cast<char>(static_cast<unsigned char>(i)));
     }
-    vocab.emplace_back("hello");                  // id 256
-    vocab.emplace_back(k_eacute_raw);             // id 257: raw "é" bytes
+    vocab.emplace_back("hello");       // id 256
+    vocab.emplace_back(k_eacute_raw);  // id 257: raw "é" bytes
 
     transcribe::Tokenizer::DecodeOnlySpecials specials;
     specials.eos_id = 50257;
@@ -149,7 +145,9 @@ void test_raw_bytes_decode_only() {
         std::vector<int32_t> out;
         CHECK(tok.encode(k_eacute_raw, out) == TRANSCRIBE_OK);
         CHECK(out.size() == 1);
-        if (out.size() == 1) CHECK(out[0] == 257);
+        if (out.size() == 1) {
+            CHECK(out[0] == 257);
+        }
     }
     {
         // No multi-byte token covers "x" — encode falls back to the
@@ -157,7 +155,9 @@ void test_raw_bytes_decode_only() {
         std::vector<int32_t> out;
         CHECK(tok.encode("x", out) == TRANSCRIBE_OK);
         CHECK(out.size() == 1);
-        if (out.size() == 1) CHECK(out[0] == 0x78);
+        if (out.size() == 1) {
+            CHECK(out[0] == 0x78);
+        }
     }
     {
         // "hello" doesn't merge into a single token because real BPE
@@ -169,31 +169,29 @@ void test_raw_bytes_decode_only() {
         CHECK(tok.encode("hello", out) == TRANSCRIBE_OK);
         CHECK(out.size() == 5);
         std::vector<int> ids_int(out.begin(), out.end());
-        CHECK_STR_EQ(tok.decode(ids_int.data(),
-                                static_cast<int>(ids_int.size())),
-                     "hello");
+        CHECK_STR_EQ(tok.decode(ids_int.data(), static_cast<int>(ids_int.size())), "hello");
     }
 
     // Decode: raw-bytes mode concatenates verbatim, no remap inversion.
     {
-        const int ids[] = {256, 257};
+        const int ids[] = { 256, 257 };
         CHECK_STR_EQ(tok.decode(ids, 2), std::string("hello") + k_eacute_raw);
     }
     // Out-of-range ids are silently skipped (defensive).
     {
-        const int ids[] = {256, 9999};
+        const int ids[] = { 256, 9999 };
         CHECK_STR_EQ(tok.decode(ids, 2), "hello");
     }
 }
 
 void test_empty_vocab_rejected() {
-    transcribe::Tokenizer tok;
+    transcribe::Tokenizer    tok;
     std::vector<std::string> empty;
     CHECK(tok.load_decode_only_gpt2(empty) == TRANSCRIBE_ERR_INVALID_ARG);
     CHECK(tok.load_decode_only_raw_bytes(empty) == TRANSCRIBE_ERR_INVALID_ARG);
 }
 
-} // namespace
+}  // namespace
 
 int main() {
     test_gpt2_decode_only();
diff --git a/tests/tokenizer_smoke.cpp b/tests/tokenizer_smoke.cpp
index b1ea57c5..8995e0c6 100644
--- a/tests/tokenizer_smoke.cpp
+++ b/tests/tokenizer_smoke.cpp
@@ -33,11 +33,10 @@
 // should not) expose tokenizer details directly in 2B; the test target
 // has src/ on its PRIVATE include path so this stays internal.
 
-#include "transcribe.h"
-
 #include "arch/parakeet/parakeet.h"
 #include "transcribe-model.h"
 #include "transcribe-tokenizer.h"
+#include "transcribe.h"
 
 #include <sys/stat.h>
 
@@ -46,7 +45,7 @@
 #include <string>
 
 #ifndef TRANSCRIBE_TEST_FIXTURES_DIR
-#  error "TRANSCRIBE_TEST_FIXTURES_DIR must be defined by the build system"
+#    error "TRANSCRIBE_TEST_FIXTURES_DIR must be defined by the build system"
 #endif
 
 namespace {
@@ -55,30 +54,26 @@ const std::string g_fixtures_dir = TRANSCRIBE_TEST_FIXTURES_DIR;
 
 int g_failures = 0;
 
-#define CHECK(cond)                                                         \
-    do {                                                                    \
-        if (!(cond)) {                                                      \
-            std::fprintf(stderr, "FAIL %s:%d: %s\n",                        \
-                         __FILE__, __LINE__, #cond);                        \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK(cond)                                                              \
+    do {                                                                         \
+        if (!(cond)) {                                                           \
+            std::fprintf(stderr, "FAIL %s:%d: %s\n", __FILE__, __LINE__, #cond); \
+            ++g_failures;                                                        \
+        }                                                                        \
     } while (0)
 
-#define CHECK_STR_EQ(a, b)                                                  \
-    do {                                                                    \
-        const std::string _av = (a);                                        \
-        const std::string _bv = (b);                                        \
-        if (_av != _bv) {                                                   \
-            std::fprintf(stderr,                                            \
-                         "FAIL %s:%d: \"%s\" != \"%s\"\n",                  \
-                         __FILE__, __LINE__,                                \
-                         _av.c_str(), _bv.c_str());                         \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK_STR_EQ(a, b)                                                                                        \
+    do {                                                                                                          \
+        const std::string _av = (a);                                                                              \
+        const std::string _bv = (b);                                                                              \
+        if (_av != _bv) {                                                                                         \
+            std::fprintf(stderr, "FAIL %s:%d: \"%s\" != \"%s\"\n", __FILE__, __LINE__, _av.c_str(), _bv.c_str()); \
+            ++g_failures;                                                                                         \
+        }                                                                                                         \
     } while (0)
 
 bool file_exists(const std::string & path) {
-    struct stat st {};
+    struct stat st{};
     return ::stat(path.c_str(), &st) == 0;
 }
 
@@ -87,27 +82,23 @@ bool file_exists(const std::string & path) {
 // caps->native_sample_rate == 16000, caps->supports_translate == false.
 // Returns the loaded model on success or nullptr on failure (with
 // g_failures incremented).
-struct transcribe_model * load_or_fail(const char * fixture_name,
-                                       const char * expected_variant)
-{
-    const std::string p = g_fixtures_dir + "/" + fixture_name;
-    transcribe_model_load_params mp; transcribe_model_load_params_init(&mp);
+struct transcribe_model * load_or_fail(const char * fixture_name, const char * expected_variant) {
+    const std::string            p = g_fixtures_dir + "/" + fixture_name;
+    transcribe_model_load_params mp;
+    transcribe_model_load_params_init(&mp);
     struct transcribe_model * model = nullptr;
-    const transcribe_status st = transcribe_model_load_file(p.c_str(), &mp, &model);
+    const transcribe_status   st    = transcribe_model_load_file(p.c_str(), &mp, &model);
     if (st != TRANSCRIBE_OK) {
-        std::fprintf(stderr,
-                     "FAIL load %s: expected OK, got %s\n",
-                     fixture_name, transcribe_status_string(st));
+        std::fprintf(stderr, "FAIL load %s: expected OK, got %s\n", fixture_name, transcribe_status_string(st));
         ++g_failures;
         return nullptr;
     }
     if (model == nullptr) {
-        std::fprintf(stderr,
-                     "FAIL load %s: model pointer not set\n", fixture_name);
+        std::fprintf(stderr, "FAIL load %s: model pointer not set\n", fixture_name);
         ++g_failures;
         return nullptr;
     }
-    CHECK_STR_EQ(transcribe_model_arch_string(model),    "parakeet");
+    CHECK_STR_EQ(transcribe_model_arch_string(model), "parakeet");
     CHECK_STR_EQ(transcribe_model_variant_string(model), expected_variant);
     // After load the loader binds a runtime backend; the
     // exact label is platform-dependent (Metal on Apple Silicon, CPU
@@ -115,17 +106,15 @@ struct transcribe_model * load_or_fail(const char * fixture_name,
     {
         const std::string backend = transcribe_model_backend(model);
         if (backend.empty()) {
-            std::fprintf(stderr,
-                         "FAIL %s: backend is empty after step 1\n",
-                         fixture_name);
+            std::fprintf(stderr, "FAIL %s: backend is empty after step 1\n", fixture_name);
             ++g_failures;
         }
     }
 
-    transcribe_capabilities caps_buf; transcribe_capabilities_init(&caps_buf);
-    const bool caps_ok =
-        transcribe_model_get_capabilities(model, &caps_buf) == TRANSCRIBE_OK;
-    const transcribe_capabilities * caps = caps_ok ? &caps_buf : nullptr;
+    transcribe_capabilities caps_buf;
+    transcribe_capabilities_init(&caps_buf);
+    const bool                      caps_ok = transcribe_model_get_capabilities(model, &caps_buf) == TRANSCRIBE_OK;
+    const transcribe_capabilities * caps    = caps_ok ? &caps_buf : nullptr;
     CHECK(caps != nullptr);
     if (caps != nullptr) {
         CHECK(caps->native_sample_rate == 16000);
@@ -145,29 +134,29 @@ void check_toy_vocab(const transcribe::Tokenizer * tok) {
     // Spot-check id -> piece. The bytes literal for ▁ is U+2581 in
     // UTF-8 (0xE2 0x96 0x81); the test source uses the actual code
     // point so the file stays UTF-8 throughout.
-    CHECK_STR_EQ(tok->token(0),  "<unk>");
-    CHECK_STR_EQ(tok->token(1),  "<s>");
-    CHECK_STR_EQ(tok->token(2),  "</s>");
-    CHECK_STR_EQ(tok->token(3),  "\xE2\x96\x81hello");
-    CHECK_STR_EQ(tok->token(4),  "\xE2\x96\x81world");
+    CHECK_STR_EQ(tok->token(0), "<unk>");
+    CHECK_STR_EQ(tok->token(1), "<s>");
+    CHECK_STR_EQ(tok->token(2), "</s>");
+    CHECK_STR_EQ(tok->token(3), "\xE2\x96\x81hello");
+    CHECK_STR_EQ(tok->token(4), "\xE2\x96\x81world");
     CHECK_STR_EQ(tok->token(11), "\xE2\x96\x81the");
     CHECK_STR_EQ(tok->token(15), "<blank>");
 
     // Out-of-range id returns the empty-string sentinel rather than
     // reading off the end of the vector.
-    CHECK_STR_EQ(tok->token(-1),    "");
+    CHECK_STR_EQ(tok->token(-1), "");
     CHECK_STR_EQ(tok->token(10000), "");
 
     // Reverse lookup.
-    CHECK(tok->find("<unk>")               == 0);
-    CHECK(tok->find("\xE2\x96\x81hello")   == 3);
-    CHECK(tok->find("\xE2\x96\x81world")   == 4);
+    CHECK(tok->find("<unk>") == 0);
+    CHECK(tok->find("\xE2\x96\x81hello") == 3);
+    CHECK(tok->find("\xE2\x96\x81world") == 4);
     CHECK(tok->find("definitely not here") == -1);
 
     // Special token ids match the fixture KV.
-    CHECK(tok->unk_id()   == 0);
-    CHECK(tok->bos_id()   == 1);
-    CHECK(tok->eos_id()   == 2);
+    CHECK(tok->unk_id() == 0);
+    CHECK(tok->bos_id() == 1);
+    CHECK(tok->eos_id() == 2);
     CHECK(tok->blank_id() == 15);
 
     CHECK_STR_EQ(tok->model_type(), "unigram");
@@ -175,28 +164,28 @@ void check_toy_vocab(const transcribe::Tokenizer * tok) {
     // Decode: SentencePiece word-boundary marker becomes ASCII space.
     // Sequence: ▁hello ▁world  ->  " hello world".
     {
-        const int ids[] = {3, 4};
+        const int ids[] = { 3, 4 };
         CHECK_STR_EQ(tok->decode(ids, 2), " hello world");
     }
     // Continuation piece in the middle: ▁hello s ▁world -> " hellos world".
     {
-        const int ids[] = {3, 8, 4};
+        const int ids[] = { 3, 8, 4 };
         CHECK_STR_EQ(tok->decode(ids, 3), " hellos world");
     }
     // First piece has no marker: ed ▁the -> "ed the".
     {
-        const int ids[] = {9, 11};
+        const int ids[] = { 9, 11 };
         CHECK_STR_EQ(tok->decode(ids, 2), "ed the");
     }
     // Out-of-range ids are skipped silently.
     {
-        const int ids[] = {3, -1, 4};
+        const int ids[] = { 3, -1, 4 };
         CHECK_STR_EQ(tok->decode(ids, 3), " hello world");
     }
     // Empty / null inputs return an empty string.
     CHECK_STR_EQ(tok->decode(nullptr, 0), "");
     {
-        const int ids[] = {3};
+        const int ids[] = { 3 };
         CHECK_STR_EQ(tok->decode(ids, 0), "");
     }
 }
@@ -209,22 +198,23 @@ void check_toy_vocab(const transcribe::Tokenizer * tok) {
 // stand: language detect off, languages list is the documented
 // information-gap state.
 void test_v2_fixture() {
-    struct transcribe_model * model =
-        load_or_fail("tokenizer_minimal.gguf", "tdt-0.6b-v2");
-    if (model == nullptr) return;
-
-    transcribe_capabilities caps_buf; transcribe_capabilities_init(&caps_buf);
-    const bool caps_ok =
-        transcribe_model_get_capabilities(model, &caps_buf) == TRANSCRIBE_OK;
-    const transcribe_capabilities * caps = caps_ok ? &caps_buf : nullptr;
+    struct transcribe_model * model = load_or_fail("tokenizer_minimal.gguf", "tdt-0.6b-v2");
+    if (model == nullptr) {
+        return;
+    }
+
+    transcribe_capabilities caps_buf;
+    transcribe_capabilities_init(&caps_buf);
+    const bool                      caps_ok = transcribe_model_get_capabilities(model, &caps_buf) == TRANSCRIBE_OK;
+    const transcribe_capabilities * caps    = caps_ok ? &caps_buf : nullptr;
     CHECK(caps != nullptr);
     if (caps != nullptr) {
         CHECK(caps->supports_language_detect == false);
-        CHECK(caps->supports_streaming       == false);
+        CHECK(caps->supports_streaming == false);
         // Information gap, not a claim. Documented in
         // arch/parakeet/model.cpp.
         CHECK(caps->n_languages == 0);
-        CHECK(caps->languages   == nullptr);
+        CHECK(caps->languages == nullptr);
     }
 
     const transcribe::Tokenizer * tok = model->tokenizer();
@@ -245,24 +235,25 @@ void test_v2_fixture() {
 // loader does not corrupt or branch the tokenizer based on capability
 // KV).
 void test_v3_fixture() {
-    struct transcribe_model * model =
-        load_or_fail("tokenizer_minimal_v3.gguf", "tdt-0.6b-v3");
-    if (model == nullptr) return;
-
-    transcribe_capabilities caps_buf; transcribe_capabilities_init(&caps_buf);
-    const bool caps_ok =
-        transcribe_model_get_capabilities(model, &caps_buf) == TRANSCRIBE_OK;
-    const transcribe_capabilities * caps = caps_ok ? &caps_buf : nullptr;
+    struct transcribe_model * model = load_or_fail("tokenizer_minimal_v3.gguf", "tdt-0.6b-v3");
+    if (model == nullptr) {
+        return;
+    }
+
+    transcribe_capabilities caps_buf;
+    transcribe_capabilities_init(&caps_buf);
+    const bool                      caps_ok = transcribe_model_get_capabilities(model, &caps_buf) == TRANSCRIBE_OK;
+    const transcribe_capabilities * caps    = caps_ok ? &caps_buf : nullptr;
     CHECK(caps != nullptr);
     if (caps != nullptr) {
         // Capability KV overrode the family default.
         CHECK(caps->supports_language_detect == true);
         // Streaming KV not present in the fixture, so the family
         // default (false) stands.
-        CHECK(caps->supports_streaming       == false);
+        CHECK(caps->supports_streaming == false);
         // general.languages was a four-element string array.
         CHECK(caps->n_languages == 4);
-        CHECK(caps->languages   != nullptr);
+        CHECK(caps->languages != nullptr);
         if (caps->languages != nullptr && caps->n_languages == 4) {
             CHECK_STR_EQ(caps->languages[0], "en");
             CHECK_STR_EQ(caps->languages[1], "de");
@@ -289,18 +280,18 @@ void test_v3_fixture() {
 // "library picks", positive means "use this many"). The central
 // dispatcher rejects it before the family handler runs.
 void test_n_threads_validation() {
-    struct transcribe_model * model =
-        load_or_fail("tokenizer_minimal.gguf", "tdt-0.6b-v2");
-    if (model == nullptr) return;
-
-    transcribe_session_params cp; transcribe_session_params_init(&cp);
-    cp.n_threads = -1;
-    struct transcribe_session * ctx = (struct transcribe_session *)0xdeadbeef;
-    const transcribe_status st = transcribe_session_init(model, &cp, &ctx);
+    struct transcribe_model * model = load_or_fail("tokenizer_minimal.gguf", "tdt-0.6b-v2");
+    if (model == nullptr) {
+        return;
+    }
+
+    transcribe_session_params cp;
+    transcribe_session_params_init(&cp);
+    cp.n_threads                    = -1;
+    struct transcribe_session * ctx = (struct transcribe_session *) 0xdeadbeef;
+    const transcribe_status     st  = transcribe_session_init(model, &cp, &ctx);
     if (st != TRANSCRIBE_ERR_INVALID_ARG) {
-        std::fprintf(stderr,
-                     "FAIL n_threads<0: expected INVALID_ARG, got %s\n",
-                     transcribe_status_string(st));
+        std::fprintf(stderr, "FAIL n_threads<0: expected INVALID_ARG, got %s\n", transcribe_status_string(st));
         ++g_failures;
     }
     // Contract: out_ctx is cleared on every non-OK return.
@@ -310,13 +301,11 @@ void test_n_threads_validation() {
     }
 
     // Sanity: n_threads == 0 (library default) succeeds.
-    cp.n_threads = 0;
-    ctx = nullptr;
+    cp.n_threads                  = 0;
+    ctx                           = nullptr;
     const transcribe_status st_ok = transcribe_session_init(model, &cp, &ctx);
     if (st_ok != TRANSCRIBE_OK) {
-        std::fprintf(stderr,
-                     "FAIL n_threads=0: expected OK, got %s\n",
-                     transcribe_status_string(st_ok));
+        std::fprintf(stderr, "FAIL n_threads=0: expected OK, got %s\n", transcribe_status_string(st_ok));
         ++g_failures;
     }
     if (ctx == nullptr) {
@@ -328,7 +317,7 @@ void test_n_threads_validation() {
     transcribe_model_free(model);
 }
 
-} // namespace
+}  // namespace
 
 int main() {
     // Build-system backstop. Same rationale as loader_smoke: the
@@ -343,8 +332,7 @@ int main() {
     for (const char * name : required_fixtures) {
         const std::string p = g_fixtures_dir + "/" + name;
         if (!file_exists(p)) {
-            std::fprintf(stderr,
-                         "tokenizer_smoke: fixture not found: %s\n", p.c_str());
+            std::fprintf(stderr, "tokenizer_smoke: fixture not found: %s\n", p.c_str());
             all_present = false;
         }
     }
diff --git a/tests/voxtral_realtime_real_smoke.cpp b/tests/voxtral_realtime_real_smoke.cpp
index 9f2b42be..0d445418 100644
--- a/tests/voxtral_realtime_real_smoke.cpp
+++ b/tests/voxtral_realtime_real_smoke.cpp
@@ -24,7 +24,6 @@
 //     GGUF. If unset/missing, exits 77 (CTest "skipped").
 
 #include "transcribe.h"
-
 #include "wav.h"
 
 #include <sys/stat.h>
@@ -38,33 +37,30 @@ namespace {
 
 int g_failures = 0;
 
-#define CHECK(cond)                                                         \
-    do {                                                                    \
-        if (!(cond)) {                                                      \
-            std::fprintf(stderr, "FAIL %s:%d: %s\n",                        \
-                         __FILE__, __LINE__, #cond);                        \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK(cond)                                                              \
+    do {                                                                         \
+        if (!(cond)) {                                                           \
+            std::fprintf(stderr, "FAIL %s:%d: %s\n", __FILE__, __LINE__, #cond); \
+            ++g_failures;                                                        \
+        }                                                                        \
     } while (0)
 
-#define CHECK_EQ_INT(actual, expected)                                      \
-    do {                                                                    \
-        const long long _a = static_cast<long long>(actual);                \
-        const long long _e = static_cast<long long>(expected);              \
-        if (_a != _e) {                                                     \
-            std::fprintf(stderr,                                            \
-                         "FAIL %s:%d: %s = %lld, expected %lld\n",          \
-                         __FILE__, __LINE__, #actual, _a, _e);              \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK_EQ_INT(actual, expected)                                                                           \
+    do {                                                                                                         \
+        const long long _a = static_cast<long long>(actual);                                                     \
+        const long long _e = static_cast<long long>(expected);                                                   \
+        if (_a != _e) {                                                                                          \
+            std::fprintf(stderr, "FAIL %s:%d: %s = %lld, expected %lld\n", __FILE__, __LINE__, #actual, _a, _e); \
+            ++g_failures;                                                                                        \
+        }                                                                                                        \
     } while (0)
 
 bool file_exists(const std::string & path) {
-    struct stat st {};
+    struct stat st{};
     return ::stat(path.c_str(), &st) == 0;
 }
 
-} // namespace
+}  // namespace
 
 int main() {
     const char * model_path = std::getenv("TRANSCRIBE_VOXTRAL_REALTIME_GGUF");
@@ -75,8 +71,7 @@ int main() {
         return 77;
     }
 
-    const std::string sample_path =
-        std::string(TRANSCRIBE_TEST_SAMPLES_DIR) + "/jfk.wav";
+    const std::string sample_path = std::string(TRANSCRIBE_TEST_SAMPLES_DIR) + "/jfk.wav";
     if (!file_exists(sample_path)) {
         std::fprintf(stderr, "skipping: %s missing\n", sample_path.c_str());
         return 77;
@@ -85,16 +80,14 @@ int main() {
     std::vector<float> pcm;
     {
         std::string err;
-        if (!transcribe_cli::load_wav_mono_16k(sample_path, pcm, err) ||
-            pcm.empty())
-        {
-            std::fprintf(stderr, "failed to load %s: %s\n",
-                         sample_path.c_str(), err.c_str());
+        if (!transcribe_cli::load_wav_mono_16k(sample_path, pcm, err) || pcm.empty()) {
+            std::fprintf(stderr, "failed to load %s: %s\n", sample_path.c_str(), err.c_str());
             return 1;
         }
     }
 
-    transcribe_model_load_params mp; transcribe_model_load_params_init(&mp);
+    transcribe_model_load_params mp;
+    transcribe_model_load_params_init(&mp);
     struct transcribe_model * model = nullptr;
     if (transcribe_model_load_file(model_path, &mp, &model) != TRANSCRIBE_OK) {
         std::fprintf(stderr, "model load failed: %s\n", model_path);
@@ -103,40 +96,43 @@ int main() {
 
     // (1) Unbounded capability.
     {
-        transcribe_capabilities caps; transcribe_capabilities_init(&caps);
+        transcribe_capabilities caps;
+        transcribe_capabilities_init(&caps);
         CHECK(transcribe_model_get_capabilities(model, &caps) == TRANSCRIBE_OK);
-        CHECK_EQ_INT(caps.max_audio_ms, 0);   // 0 == unbounded
+        CHECK_EQ_INT(caps.max_audio_ms, 0);  // 0 == unbounded
     }
 
     // (2) Session limits report unbounded at the default context AND under a
     //     tiny n_ctx — the knob is a no-op for this family.
     auto check_unbounded_limits = [&](int32_t n_ctx) {
-        transcribe_session_params sp; transcribe_session_params_init(&sp);
-        sp.n_ctx = n_ctx;
+        transcribe_session_params sp;
+        transcribe_session_params_init(&sp);
+        sp.n_ctx                      = n_ctx;
         struct transcribe_session * s = nullptr;
         CHECK(transcribe_session_init(model, &sp, &s) == TRANSCRIBE_OK);
-        transcribe_session_limits lim; transcribe_session_limits_init(&lim);
+        transcribe_session_limits lim;
+        transcribe_session_limits_init(&lim);
         CHECK(transcribe_session_get_limits(s, &lim) == TRANSCRIBE_OK);
-        CHECK_EQ_INT(lim.effective_n_ctx, 0);          // unbounded
-        CHECK_EQ_INT(lim.effective_max_audio_ms, 0);   // unbounded
-        CHECK_EQ_INT(lim.max_kv_bytes, 0);             // unbounded
+        CHECK_EQ_INT(lim.effective_n_ctx, 0);         // unbounded
+        CHECK_EQ_INT(lim.effective_max_audio_ms, 0);  // unbounded
+        CHECK_EQ_INT(lim.max_kv_bytes, 0);            // unbounded
         transcribe_session_free(s);
     };
-    check_unbounded_limits(0);    // default
-    check_unbounded_limits(64);   // tiny n_ctx — still unbounded (no-op)
+    check_unbounded_limits(0);   // default
+    check_unbounded_limits(64);  // tiny n_ctx — still unbounded (no-op)
 
     // (3) One-shot with a tiny n_ctx transcribes normally (n_ctx no-op).
     {
-        transcribe_session_params sp; transcribe_session_params_init(&sp);
-        sp.n_ctx = 64;
+        transcribe_session_params sp;
+        transcribe_session_params_init(&sp);
+        sp.n_ctx                      = 64;
         struct transcribe_session * s = nullptr;
         CHECK(transcribe_session_init(model, &sp, &s) == TRANSCRIBE_OK);
-        const transcribe_status rst =
-            transcribe_run(s, pcm.data(), (int) pcm.size(), nullptr);
-        CHECK(rst == TRANSCRIBE_OK);                   // NOT INPUT_TOO_LONG
-        CHECK(transcribe_was_truncated(s) == false);   // not truncated
+        const transcribe_status rst = transcribe_run(s, pcm.data(), (int) pcm.size(), nullptr);
+        CHECK(rst == TRANSCRIBE_OK);                  // NOT INPUT_TOO_LONG
+        CHECK(transcribe_was_truncated(s) == false);  // not truncated
         const char * text = transcribe_full_text(s);
-        CHECK(text != nullptr && text[0] != '\0');     // real transcript
+        CHECK(text != nullptr && text[0] != '\0');    // real transcript
         transcribe_session_free(s);
     }
 
@@ -144,13 +140,14 @@ int main() {
     //     (Regression guard for the --n-ctx clamp that corrupted the realtime
     //     batch decode below its audio horizon.)
     {
-        transcribe_session_params sp; transcribe_session_params_init(&sp);
-        sp.n_ctx = 64;
+        transcribe_session_params sp;
+        transcribe_session_params_init(&sp);
+        sp.n_ctx                      = 64;
         struct transcribe_session * s = nullptr;
         CHECK(transcribe_session_init(model, &sp, &s) == TRANSCRIBE_OK);
-        std::vector<float> pcm2 = pcm;
-        const float * pcms[2] = { pcm.data(), pcm2.data() };
-        const int     lens[2] = { (int) pcm.size(), (int) pcm2.size() };
+        std::vector<float> pcm2    = pcm;
+        const float *      pcms[2] = { pcm.data(), pcm2.data() };
+        const int          lens[2] = { (int) pcm.size(), (int) pcm2.size() };
         CHECK(transcribe_run_batch(s, pcms, lens, 2, nullptr) == TRANSCRIBE_OK);
         CHECK_EQ_INT(transcribe_batch_n_results(s), 2);
         for (int i = 0; i < 2; ++i) {
@@ -165,8 +162,7 @@ int main() {
     transcribe_model_free(model);
 
     if (g_failures > 0) {
-        std::fprintf(stderr, "voxtral_realtime_real_smoke: %d failures\n",
-                     g_failures);
+        std::fprintf(stderr, "voxtral_realtime_real_smoke: %d failures\n", g_failures);
         return EXIT_FAILURE;
     }
     std::fprintf(stdout, "voxtral_realtime_real_smoke: ok\n");
diff --git a/tests/wav_loader_smoke.cpp b/tests/wav_loader_smoke.cpp
index b191a949..c7154d9c 100644
--- a/tests/wav_loader_smoke.cpp
+++ b/tests/wav_loader_smoke.cpp
@@ -22,7 +22,7 @@
 #include <vector>
 
 #ifndef TRANSCRIBE_TEST_SAMPLES_DIR
-#  error "TRANSCRIBE_TEST_SAMPLES_DIR must be defined by the build system"
+#    error "TRANSCRIBE_TEST_SAMPLES_DIR must be defined by the build system"
 #endif
 
 namespace {
@@ -31,19 +31,18 @@ const std::string g_samples_dir = TRANSCRIBE_TEST_SAMPLES_DIR;
 
 int g_failures = 0;
 
-#define CHECK(cond)                                                         \
-    do {                                                                    \
-        if (!(cond)) {                                                      \
-            std::fprintf(stderr, "FAIL %s:%d: %s\n",                        \
-                         __FILE__, __LINE__, #cond);                        \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK(cond)                                                              \
+    do {                                                                         \
+        if (!(cond)) {                                                           \
+            std::fprintf(stderr, "FAIL %s:%d: %s\n", __FILE__, __LINE__, #cond); \
+            ++g_failures;                                                        \
+        }                                                                        \
     } while (0)
 
 void test_load_jfk() {
-    const std::string path = g_samples_dir + "/jfk.wav";
+    const std::string  path = g_samples_dir + "/jfk.wav";
     std::vector<float> pcm;
-    std::string err;
+    std::string        err;
 
     const bool ok = transcribe_cli::load_wav_mono_16k(path, pcm, err);
     if (!ok) {
@@ -76,9 +75,8 @@ void test_load_jfk() {
 
 void test_load_missing() {
     std::vector<float> pcm = { 1.0f, 2.0f, 3.0f };
-    std::string err = "stale";
-    const bool ok = transcribe_cli::load_wav_mono_16k(
-        "/__wav_loader_smoke_missing__.wav", pcm, err);
+    std::string        err = "stale";
+    const bool         ok  = transcribe_cli::load_wav_mono_16k("/__wav_loader_smoke_missing__.wav", pcm, err);
     CHECK(!ok);
     CHECK(!err.empty());
     // out_pcm.clear() is the loader's first line; relying on it pins the
@@ -87,7 +85,7 @@ void test_load_missing() {
     CHECK(pcm.empty());
 }
 
-} // namespace
+}  // namespace
 
 int main() {
     test_load_jfk();
diff --git a/tests/whisper_bin_e2e_smoke.cpp b/tests/whisper_bin_e2e_smoke.cpp
index b06fa619..4323fb5b 100644
--- a/tests/whisper_bin_e2e_smoke.cpp
+++ b/tests/whisper_bin_e2e_smoke.cpp
@@ -28,7 +28,6 @@
 
 #include "transcribe.h"
 #include "transcribe/whisper.h"
-
 #include "wav.h"
 
 #include <sys/stat.h>
@@ -40,37 +39,37 @@
 #include <vector>
 
 #ifndef TRANSCRIBE_TEST_SAMPLES_DIR
-#  error "TRANSCRIBE_TEST_SAMPLES_DIR must be defined by the build system"
+#    error "TRANSCRIBE_TEST_SAMPLES_DIR must be defined by the build system"
 #endif
 
 namespace {
 
-int g_failures = 0;
+int g_failures     = 0;
 int g_subtests_run = 0;
 
-#define CHECK(cond)                                                         \
-    do {                                                                    \
-        if (!(cond)) {                                                      \
-            std::fprintf(stderr, "FAIL %s:%d: %s\n",                        \
-                         __FILE__, __LINE__, #cond);                        \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK(cond)                                                              \
+    do {                                                                         \
+        if (!(cond)) {                                                           \
+            std::fprintf(stderr, "FAIL %s:%d: %s\n", __FILE__, __LINE__, #cond); \
+            ++g_failures;                                                        \
+        }                                                                        \
     } while (0)
 
 bool file_exists(const char * path) {
-    struct stat st {};
+    struct stat st{};
     return ::stat(path, &st) == 0;
 }
 
 bool contains(const char * haystack, const char * needle) {
-    if (haystack == nullptr) return false;
+    if (haystack == nullptr) {
+        return false;
+    }
     return std::strstr(haystack, needle) != nullptr;
 }
 
 bool load_wav(const char * fname, std::vector<float> & out) {
     std::string err;
-    return transcribe_cli::load_wav_mono_16k(
-        std::string(TRANSCRIBE_TEST_SAMPLES_DIR) + "/" + fname, out, err);
+    return transcribe_cli::load_wav_mono_16k(std::string(TRANSCRIBE_TEST_SAMPLES_DIR) + "/" + fname, out, err);
 }
 
 const char * env_or_null(const char * key) {
@@ -87,25 +86,24 @@ void test_multilingual(const char * model_path) {
         return;
     }
 
-    transcribe_model_load_params mp; transcribe_model_load_params_init(&mp);
-    mp.backend = TRANSCRIBE_BACKEND_CPU;
+    transcribe_model_load_params mp;
+    transcribe_model_load_params_init(&mp);
+    mp.backend               = TRANSCRIBE_BACKEND_CPU;
     transcribe_model * model = nullptr;
-    transcribe_status st =
-        transcribe_model_load_file(model_path, &mp, &model);
+    transcribe_status  st    = transcribe_model_load_file(model_path, &mp, &model);
     CHECK(st == TRANSCRIBE_OK);
     if (st != TRANSCRIBE_OK || model == nullptr) {
-        std::fprintf(stderr, "FAIL load (multi): %s\n",
-                     transcribe_status_string(st));
+        std::fprintf(stderr, "FAIL load (multi): %s\n", transcribe_status_string(st));
         return;
     }
 
     // Identity / capabilities.
     CHECK(std::strcmp(transcribe_model_arch_string(model), "whisper") == 0);
     CHECK(contains(transcribe_model_variant_string(model), "whisper-tiny"));
-    transcribe_capabilities caps_buf; transcribe_capabilities_init(&caps_buf);
-    const bool caps_ok =
-        transcribe_model_get_capabilities(model, &caps_buf) == TRANSCRIBE_OK;
-    const transcribe_capabilities * caps = caps_ok ? &caps_buf : nullptr;
+    transcribe_capabilities caps_buf;
+    transcribe_capabilities_init(&caps_buf);
+    const bool                      caps_ok = transcribe_model_get_capabilities(model, &caps_buf) == TRANSCRIBE_OK;
+    const transcribe_capabilities * caps    = caps_ok ? &caps_buf : nullptr;
     CHECK(caps != nullptr);
     if (caps != nullptr) {
         CHECK(caps->native_sample_rate == 16000);
@@ -124,14 +122,15 @@ void test_multilingual(const char * model_path) {
 
     // Tokenizer: encode is now available via tiktoken-style merge loop.
     {
-        int32_t buf[64];
+        int32_t   buf[64];
         const int n = transcribe_tokenize(model, " hello world", buf, 64);
         CHECK(n > 0);
     }
 
-    transcribe_session_params cp; transcribe_session_params_init(&cp);
+    transcribe_session_params cp;
+    transcribe_session_params_init(&cp);
     transcribe_session * ctx = nullptr;
-    st = transcribe_session_init(model, &cp, &ctx);
+    st                       = transcribe_session_init(model, &cp, &ctx);
     CHECK(st == TRANSCRIBE_OK);
     if (st != TRANSCRIBE_OK || ctx == nullptr) {
         transcribe_model_free(model);
@@ -140,10 +139,10 @@ void test_multilingual(const char * model_path) {
 
     // English JFK with explicit hint.
     {
-        transcribe_run_params rp; transcribe_run_params_init(&rp);
+        transcribe_run_params rp;
+        transcribe_run_params_init(&rp);
         rp.language = "en";
-        st = transcribe_run(ctx, jfk.data(),
-                            static_cast<int>(jfk.size()), &rp);
+        st          = transcribe_run(ctx, jfk.data(), static_cast<int>(jfk.size()), &rp);
         CHECK(st == TRANSCRIBE_OK);
         const char * text = transcribe_full_text(ctx);
         CHECK(text != nullptr);
@@ -156,10 +155,10 @@ void test_multilingual(const char * model_path) {
     // German with explicit --language de — exercises the
     // arithmetic-derived lang_token_ids on the .bin path.
     {
-        transcribe_run_params rp; transcribe_run_params_init(&rp);
+        transcribe_run_params rp;
+        transcribe_run_params_init(&rp);
         rp.language = "de";
-        st = transcribe_run(ctx, german.data(),
-                            static_cast<int>(german.size()), &rp);
+        st          = transcribe_run(ctx, german.data(), static_cast<int>(german.size()), &rp);
         CHECK(st == TRANSCRIBE_OK);
         const char * text = transcribe_full_text(ctx);
         CHECK(text != nullptr);
@@ -193,26 +192,28 @@ void test_multilingual(const char * model_path) {
             "ending <|endoftext|> here",
         };
         for (const char * t : literals) {
-            transcribe_run_params rp; transcribe_run_params_init(&rp);
+            transcribe_run_params rp;
+            transcribe_run_params_init(&rp);
             rp.language = "en";
-            transcribe_whisper_run_ext wp; transcribe_whisper_run_ext_init(&wp);
+            transcribe_whisper_run_ext wp;
+            transcribe_whisper_run_ext_init(&wp);
             wp.initial_prompt = t;
-            rp.family = &wp.ext;
-            st = transcribe_run(ctx, jfk.data(),
-                                static_cast<int>(jfk.size()), &rp);
+            rp.family         = &wp.ext;
+            st                = transcribe_run(ctx, jfk.data(), static_cast<int>(jfk.size()), &rp);
             CHECK(st == TRANSCRIBE_ERR_INVALID_ARG);
         }
     }
 
     // Text initial_prompt — now ACCEPTED (tiktoken encoder works).
     {
-        transcribe_run_params rp; transcribe_run_params_init(&rp);
+        transcribe_run_params rp;
+        transcribe_run_params_init(&rp);
         rp.language = "en";
-        transcribe_whisper_run_ext wp; transcribe_whisper_run_ext_init(&wp);
+        transcribe_whisper_run_ext wp;
+        transcribe_whisper_run_ext_init(&wp);
         wp.initial_prompt = "Inaugural address";
-        rp.family = &wp.ext;
-        st = transcribe_run(ctx, jfk.data(),
-                            static_cast<int>(jfk.size()), &rp);
+        rp.family         = &wp.ext;
+        st                = transcribe_run(ctx, jfk.data(), static_cast<int>(jfk.size()), &rp);
         CHECK(st == TRANSCRIBE_OK);
         CHECK(contains(transcribe_full_text(ctx), "country"));
     }
@@ -230,21 +231,13 @@ void test_multilingual(const char * model_path) {
     {
         std::vector<float> product_pcm;
         if (!load_wav("product-names.wav", product_pcm)) {
-            std::fprintf(stderr,
-                         "FAIL: could not load product-names.wav\n");
+            std::fprintf(stderr, "FAIL: could not load product-names.wav\n");
             ++g_failures;
         } else {
             auto product_hits = [](const char * text) {
                 const char * terms[] = {
-                    "QuirkQuid",
-                    "P3-Quattro",
-                    "O3-Omni",
-                    "B3-BondX",
-                    "E3-Equity",
-                    "W3-WrapZ",
-                    "O2-Outlier",
-                    "U3-UniFund",
-                    "M3-Mover",
+                    "QuirkQuid", "P3-Quattro", "O3-Omni",    "B3-BondX", "E3-Equity",
+                    "W3-WrapZ",  "O2-Outlier", "U3-UniFund", "M3-Mover",
                 };
                 int n = 0;
                 for (const char * term : terms) {
@@ -255,25 +248,23 @@ void test_multilingual(const char * model_path) {
                 return n;
             };
 
-            transcribe_run_params rp; transcribe_run_params_init(&rp);
+            transcribe_run_params rp;
+            transcribe_run_params_init(&rp);
             rp.language = "en";
-            st = transcribe_run(ctx, product_pcm.data(),
-                                static_cast<int>(product_pcm.size()), &rp);
+            st          = transcribe_run(ctx, product_pcm.data(), static_cast<int>(product_pcm.size()), &rp);
             CHECK(st == TRANSCRIBE_OK);
-            const int unprompted_hits =
-                product_hits(transcribe_full_text(ctx));
+            const int unprompted_hits = product_hits(transcribe_full_text(ctx));
 
-            transcribe_whisper_run_ext wp; transcribe_whisper_run_ext_init(&wp);
+            transcribe_whisper_run_ext wp;
+            transcribe_whisper_run_ext_init(&wp);
             wp.initial_prompt =
                 "QuirkQuid Quill Inc, P3-Quattro, O3-Omni, "
                 "B3-BondX, E3-Equity, W3-WrapZ, O2-Outlier, "
                 "U3-UniFund, M3-Mover";
             rp.family = &wp.ext;
-            st = transcribe_run(ctx, product_pcm.data(),
-                                static_cast<int>(product_pcm.size()), &rp);
+            st        = transcribe_run(ctx, product_pcm.data(), static_cast<int>(product_pcm.size()), &rp);
             CHECK(st == TRANSCRIBE_OK);
-            const int prompted_hits =
-                product_hits(transcribe_full_text(ctx));
+            const int prompted_hits = product_hits(transcribe_full_text(ctx));
             CHECK(prompted_hits >= 5);
             CHECK(prompted_hits > unprompted_hits + 3);
         }
@@ -282,19 +273,19 @@ void test_multilingual(const char * model_path) {
     // prompt_tokens (pre-encoded ids) — round-trip through
     // transcribe_tokenize.
     {
-        int32_t tok_buf[32];
-        const int n = transcribe_tokenize(model, " inaugural address",
-                                          tok_buf, 32);
+        int32_t   tok_buf[32];
+        const int n = transcribe_tokenize(model, " inaugural address", tok_buf, 32);
         CHECK(n > 0);
         if (n > 0) {
-            transcribe_run_params rp; transcribe_run_params_init(&rp);
+            transcribe_run_params rp;
+            transcribe_run_params_init(&rp);
             rp.language = "en";
-            transcribe_whisper_run_ext wp; transcribe_whisper_run_ext_init(&wp);
+            transcribe_whisper_run_ext wp;
+            transcribe_whisper_run_ext_init(&wp);
             wp.prompt_tokens   = tok_buf;
             wp.n_prompt_tokens = static_cast<size_t>(n);
-            rp.family = &wp.ext;
-            st = transcribe_run(ctx, jfk.data(),
-                                static_cast<int>(jfk.size()), &rp);
+            rp.family          = &wp.ext;
+            st                 = transcribe_run(ctx, jfk.data(), static_cast<int>(jfk.size()), &rp);
             CHECK(st == TRANSCRIBE_OK);
             CHECK(contains(transcribe_full_text(ctx), "country"));
         }
@@ -313,23 +304,22 @@ void test_english_only(const char * model_path) {
         return;
     }
 
-    transcribe_model_load_params mp; transcribe_model_load_params_init(&mp);
-    mp.backend = TRANSCRIBE_BACKEND_CPU;
+    transcribe_model_load_params mp;
+    transcribe_model_load_params_init(&mp);
+    mp.backend               = TRANSCRIBE_BACKEND_CPU;
     transcribe_model * model = nullptr;
-    transcribe_status st =
-        transcribe_model_load_file(model_path, &mp, &model);
+    transcribe_status  st    = transcribe_model_load_file(model_path, &mp, &model);
     CHECK(st == TRANSCRIBE_OK);
     if (st != TRANSCRIBE_OK || model == nullptr) {
-        std::fprintf(stderr, "FAIL load (.en): %s\n",
-                     transcribe_status_string(st));
+        std::fprintf(stderr, "FAIL load (.en): %s\n", transcribe_status_string(st));
         return;
     }
 
     CHECK(contains(transcribe_model_variant_string(model), "whisper-tiny.en"));
-    transcribe_capabilities caps_buf; transcribe_capabilities_init(&caps_buf);
-    const bool caps_ok =
-        transcribe_model_get_capabilities(model, &caps_buf) == TRANSCRIBE_OK;
-    const transcribe_capabilities * caps = caps_ok ? &caps_buf : nullptr;
+    transcribe_capabilities caps_buf;
+    transcribe_capabilities_init(&caps_buf);
+    const bool                      caps_ok = transcribe_model_get_capabilities(model, &caps_buf) == TRANSCRIBE_OK;
+    const transcribe_capabilities * caps    = caps_ok ? &caps_buf : nullptr;
     CHECK(caps != nullptr);
     if (caps != nullptr) {
         CHECK(!caps->supports_language_detect);
@@ -341,9 +331,10 @@ void test_english_only(const char * model_path) {
         }
     }
 
-    transcribe_session_params cp; transcribe_session_params_init(&cp);
+    transcribe_session_params cp;
+    transcribe_session_params_init(&cp);
     transcribe_session * ctx = nullptr;
-    st = transcribe_session_init(model, &cp, &ctx);
+    st                       = transcribe_session_init(model, &cp, &ctx);
     CHECK(st == TRANSCRIBE_OK);
     if (st != TRANSCRIBE_OK || ctx == nullptr) {
         transcribe_model_free(model);
@@ -353,39 +344,39 @@ void test_english_only(const char * model_path) {
     // No language hint — lang detection short-circuits to "en"
     // because the model only advertises one language.
     {
-        transcribe_run_params rp; transcribe_run_params_init(&rp);
-        st = transcribe_run(ctx, jfk.data(),
-                            static_cast<int>(jfk.size()), &rp);
+        transcribe_run_params rp;
+        transcribe_run_params_init(&rp);
+        st = transcribe_run(ctx, jfk.data(), static_cast<int>(jfk.size()), &rp);
         CHECK(st == TRANSCRIBE_OK);
         CHECK(contains(transcribe_full_text(ctx), "country"));
     }
 
     // Explicit --language en accepted (no <|en|> token to resolve).
     {
-        transcribe_run_params rp; transcribe_run_params_init(&rp);
+        transcribe_run_params rp;
+        transcribe_run_params_init(&rp);
         rp.language = "en";
-        st = transcribe_run(ctx, jfk.data(),
-                            static_cast<int>(jfk.size()), &rp);
+        st          = transcribe_run(ctx, jfk.data(), static_cast<int>(jfk.size()), &rp);
         CHECK(st == TRANSCRIBE_OK);
         CHECK(contains(transcribe_full_text(ctx), "country"));
     }
 
     // Non-English language — rejected with a non-OK status.
     {
-        transcribe_run_params rp; transcribe_run_params_init(&rp);
+        transcribe_run_params rp;
+        transcribe_run_params_init(&rp);
         rp.language = "de";
-        st = transcribe_run(ctx, jfk.data(),
-                            static_cast<int>(jfk.size()), &rp);
+        st          = transcribe_run(ctx, jfk.data(), static_cast<int>(jfk.size()), &rp);
         CHECK(st != TRANSCRIBE_OK);
     }
 
     // Translate task — rejected (no <|translate|> token).
     {
-        transcribe_run_params rp; transcribe_run_params_init(&rp);
+        transcribe_run_params rp;
+        transcribe_run_params_init(&rp);
         rp.task     = TRANSCRIBE_TASK_TRANSLATE;
         rp.language = "en";
-        st = transcribe_run(ctx, jfk.data(),
-                            static_cast<int>(jfk.size()), &rp);
+        st          = transcribe_run(ctx, jfk.data(), static_cast<int>(jfk.size()), &rp);
         CHECK(st != TRANSCRIBE_OK);
     }
 
@@ -394,15 +385,13 @@ void test_english_only(const char * model_path) {
     ++g_subtests_run;
 }
 
-} // namespace
+}  // namespace
 
 int main() {
     const char * multi_path = env_or_null("TRANSCRIBE_WHISPER_BIN_TINY_Q8_0");
     const char * en_path    = env_or_null("TRANSCRIBE_WHISPER_BIN_TINY_EN");
 
-    if ((multi_path == nullptr || !file_exists(multi_path)) &&
-        (en_path    == nullptr || !file_exists(en_path)))
-    {
+    if ((multi_path == nullptr || !file_exists(multi_path)) && (en_path == nullptr || !file_exists(en_path))) {
         std::fprintf(stderr,
                      "SKIP: neither TRANSCRIBE_WHISPER_BIN_TINY_Q8_0 nor "
                      "TRANSCRIBE_WHISPER_BIN_TINY_EN is set\n");
@@ -417,8 +406,7 @@ int main() {
     }
 
     if (g_failures > 0) {
-        std::fprintf(stderr, "FAILED: %d check(s) (%d subtest(s) ran)\n",
-                     g_failures, g_subtests_run);
+        std::fprintf(stderr, "FAILED: %d check(s) (%d subtest(s) ran)\n", g_failures, g_subtests_run);
         return 1;
     }
     std::fprintf(stderr, "OK (%d subtest(s) ran)\n", g_subtests_run);
diff --git a/tests/whisper_bin_parser_unit.cpp b/tests/whisper_bin_parser_unit.cpp
index d28f218a..1e8e008c 100644
--- a/tests/whisper_bin_parser_unit.cpp
+++ b/tests/whisper_bin_parser_unit.cpp
@@ -51,17 +51,16 @@ namespace {
 int g_failures = 0;
 int g_skipped  = 0;
 
-#define CHECK(cond)                                                         \
-    do {                                                                    \
-        if (!(cond)) {                                                      \
-            std::fprintf(stderr, "FAIL %s:%d: %s\n",                        \
-                         __FILE__, __LINE__, #cond);                        \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK(cond)                                                              \
+    do {                                                                         \
+        if (!(cond)) {                                                           \
+            std::fprintf(stderr, "FAIL %s:%d: %s\n", __FILE__, __LINE__, #cond); \
+            ++g_failures;                                                        \
+        }                                                                        \
     } while (0)
 
 bool file_exists(const char * path) {
-    struct stat st {};
+    struct stat st{};
     return ::stat(path, &st) == 0;
 }
 
@@ -77,7 +76,7 @@ void test_silero_rejected() {
         return;
     }
     transcribe::bin_loader::WhisperBinModel m;
-    const auto rc = transcribe::bin_loader::parse_whisper_bin(path, m);
+    const auto                              rc = transcribe::bin_loader::parse_whisper_bin(path, m);
     CHECK(rc == TRANSCRIBE_ERR_UNSUPPORTED_ARCH);
 }
 
@@ -88,7 +87,7 @@ void test_truncated_rejected() {
         return;
     }
     transcribe::bin_loader::WhisperBinModel m;
-    const auto rc = transcribe::bin_loader::parse_whisper_bin(path, m);
+    const auto                              rc = transcribe::bin_loader::parse_whisper_bin(path, m);
     // for-tests fixtures pass the hparams gate (real geometry) but
     // fail at the tensor-manifest pass with no tensors declared.
     CHECK(rc == TRANSCRIBE_ERR_GGUF);
@@ -101,17 +100,17 @@ void test_tiny_q8_parsed() {
         return;
     }
     transcribe::bin_loader::WhisperBinModel m;
-    const auto rc = transcribe::bin_loader::parse_whisper_bin(path, m);
+    const auto                              rc = transcribe::bin_loader::parse_whisper_bin(path, m);
     CHECK(rc == TRANSCRIBE_OK);
 
     // Tiny multilingual whisper geometry.
     CHECK(m.hp.n_audio_layer == 4);
-    CHECK(m.hp.n_text_layer  == 4);
+    CHECK(m.hp.n_text_layer == 4);
     CHECK(m.hp.n_audio_state == 384);
-    CHECK(m.hp.n_text_state  == 384);
-    CHECK(m.hp.n_audio_head  == 6);
-    CHECK(m.hp.n_text_head   == 6);
-    CHECK(m.hp.n_mels        == 80);
+    CHECK(m.hp.n_text_state == 384);
+    CHECK(m.hp.n_audio_head == 6);
+    CHECK(m.hp.n_text_head == 6);
+    CHECK(m.hp.n_mels == 80);
     CHECK(m.is_multilingual);
     CHECK(m.num_languages == 99);
 
@@ -125,11 +124,15 @@ void test_tiny_q8_parsed() {
     CHECK(m.tensors.size() >= 160 && m.tensors.size() <= 200);
 
     // Spot-check a couple of canonical legacy names.
-    bool saw_conv1 = false;
+    bool saw_conv1     = false;
     bool saw_token_emb = false;
     for (const auto & t : m.tensors) {
-        if (t.name == "encoder.conv1.weight") saw_conv1 = true;
-        if (t.name == "decoder.token_embedding.weight") saw_token_emb = true;
+        if (t.name == "encoder.conv1.weight") {
+            saw_conv1 = true;
+        }
+        if (t.name == "decoder.token_embedding.weight") {
+            saw_token_emb = true;
+        }
     }
     CHECK(saw_conv1);
     CHECK(saw_token_emb);
@@ -137,8 +140,7 @@ void test_tiny_q8_parsed() {
 
 void test_missing_path() {
     transcribe::bin_loader::WhisperBinModel m;
-    const auto rc = transcribe::bin_loader::parse_whisper_bin(
-        "/nonexistent/path/that/does/not/exist.bin", m);
+    const auto rc = transcribe::bin_loader::parse_whisper_bin("/nonexistent/path/that/does/not/exist.bin", m);
     CHECK(rc == TRANSCRIBE_ERR_FILE_NOT_FOUND);
 }
 
@@ -147,16 +149,17 @@ void test_missing_path() {
 // so the parser will fail at the manifest stage if it gets past the
 // header checks — but for these tests we only care about the
 // hparams + mel-filter-dim gates.
-bool write_synthetic_bin(const std::string &  path,
-                         int32_t              n_vocab,
-                         int32_t              n_audio_layer,
-                         int32_t              n_text_layer,
-                         int32_t              n_mels,
-                         int32_t              n_mel_filters,
-                         int32_t              n_fft_filters)
-{
+bool write_synthetic_bin(const std::string & path,
+                         int32_t             n_vocab,
+                         int32_t             n_audio_layer,
+                         int32_t             n_text_layer,
+                         int32_t             n_mels,
+                         int32_t             n_mel_filters,
+                         int32_t             n_fft_filters) {
     std::ofstream f(path, std::ios::binary | std::ios::trunc);
-    if (!f) return false;
+    if (!f) {
+        return false;
+    }
     auto wi = [&](int32_t v) {
         f.write(reinterpret_cast<const char *>(&v), sizeof(v));
     };
@@ -164,33 +167,30 @@ bool write_synthetic_bin(const std::string &  path,
     f.write(reinterpret_cast<const char *>(&magic), sizeof(magic));
     // 11 × int32 hparams.
     wi(n_vocab);
-    wi(1500);              // n_audio_ctx
-    wi(384);               // n_audio_state
-    wi(6);                 // n_audio_head
+    wi(1500);  // n_audio_ctx
+    wi(384);   // n_audio_state
+    wi(6);     // n_audio_head
     wi(n_audio_layer);
-    wi(448);               // n_text_ctx
-    wi(384);               // n_text_state
-    wi(6);                 // n_text_head
+    wi(448);   // n_text_ctx
+    wi(384);   // n_text_state
+    wi(6);     // n_text_head
     wi(n_text_layer);
     wi(n_mels);
-    wi(0);                 // ftype
+    wi(0);  // ftype
     // mel filter dims, then n_mel_filters * n_fft_filters floats.
     wi(n_mel_filters);
     wi(n_fft_filters);
-    const size_t fb_bytes =
-        static_cast<size_t>(n_mel_filters) *
-        static_cast<size_t>(n_fft_filters) * sizeof(float);
+    const size_t fb_bytes = static_cast<size_t>(n_mel_filters) * static_cast<size_t>(n_fft_filters) * sizeof(float);
     std::vector<char> zeros(fb_bytes, 0);
     f.write(zeros.data(), zeros.size());
     return static_cast<bool>(f);
 }
 
 void test_bad_n_fft() {
-    char tmpl[] = "/tmp/transcribe_bin_test_XXXXXX.bin";
-    const int fd = ::mkstemps(tmpl, 4);
+    char      tmpl[] = "/tmp/transcribe_bin_test_XXXXXX.bin";
+    const int fd     = ::mkstemps(tmpl, 4);
     if (fd < 0) {
-        std::fprintf(stderr,
-                     "SKIP: could not create tempfile for synthetic bin\n");
+        std::fprintf(stderr, "SKIP: could not create tempfile for synthetic bin\n");
         ++g_skipped;
         return;
     }
@@ -200,15 +200,13 @@ void test_bad_n_fft() {
     // Whisper-shaped hparams but non-canonical n_fft (200 instead of
     // 201). Parser must reject before we even get to the vocab phase.
     if (!write_synthetic_bin(path, 51865, 4, 4, 80, 80, 200)) {
-        std::fprintf(stderr,
-                     "SKIP: failed to write synthetic .bin\n");
+        std::fprintf(stderr, "SKIP: failed to write synthetic .bin\n");
         ++g_skipped;
         ::unlink(path.c_str());
         return;
     }
     transcribe::bin_loader::WhisperBinModel m;
-    const auto rc = transcribe::bin_loader::parse_whisper_bin(
-        path.c_str(), m);
+    const auto                              rc = transcribe::bin_loader::parse_whisper_bin(path.c_str(), m);
     CHECK(rc == TRANSCRIBE_ERR_GGUF);
     ::unlink(path.c_str());
 }
@@ -218,8 +216,8 @@ void test_distil_layer_count_accepted() {
     // whisper-shaped hparams should pass the hparams gate. We don't
     // care that the parser later fails at "no tensors" — the hparams
     // check should not be the gating step.
-    char tmpl[] = "/tmp/transcribe_bin_test_XXXXXX.bin";
-    const int fd = ::mkstemps(tmpl, 4);
+    char      tmpl[] = "/tmp/transcribe_bin_test_XXXXXX.bin";
+    const int fd     = ::mkstemps(tmpl, 4);
     if (fd < 0) {
         ++g_skipped;
         return;
@@ -233,8 +231,7 @@ void test_distil_layer_count_accepted() {
         return;
     }
     transcribe::bin_loader::WhisperBinModel m;
-    const auto rc = transcribe::bin_loader::parse_whisper_bin(
-        path.c_str(), m);
+    const auto                              rc = transcribe::bin_loader::parse_whisper_bin(path.c_str(), m);
     // Header + mel filters parse; we then run out of bytes for the
     // vocab/tensor sections. The expected status is ERR_GGUF (with a
     // "no tensors" / truncated diagnostic), NOT UNSUPPORTED_ARCH —
@@ -243,7 +240,7 @@ void test_distil_layer_count_accepted() {
     ::unlink(path.c_str());
 }
 
-} // namespace
+}  // namespace
 
 int main() {
     test_missing_path();
@@ -254,9 +251,7 @@ int main() {
     test_tiny_q8_parsed();
 
     if (g_failures > 0) {
-        std::fprintf(stderr,
-                     "FAILED: %d check(s); %d sub-test(s) skipped\n",
-                     g_failures, g_skipped);
+        std::fprintf(stderr, "FAILED: %d check(s); %d sub-test(s) skipped\n", g_failures, g_skipped);
         return 1;
     }
     std::fprintf(stderr, "OK (%d sub-test(s) skipped)\n", g_skipped);
diff --git a/tests/whisper_bin_tokenize_parity.cpp b/tests/whisper_bin_tokenize_parity.cpp
index b58051a6..f8d3099d 100644
--- a/tests/whisper_bin_tokenize_parity.cpp
+++ b/tests/whisper_bin_tokenize_parity.cpp
@@ -38,17 +38,16 @@ namespace {
 
 int g_failures = 0;
 
-#define CHECK(cond)                                                         \
-    do {                                                                    \
-        if (!(cond)) {                                                      \
-            std::fprintf(stderr, "FAIL %s:%d: %s\n",                        \
-                         __FILE__, __LINE__, #cond);                        \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK(cond)                                                              \
+    do {                                                                         \
+        if (!(cond)) {                                                           \
+            std::fprintf(stderr, "FAIL %s:%d: %s\n", __FILE__, __LINE__, #cond); \
+            ++g_failures;                                                        \
+        }                                                                        \
     } while (0)
 
 bool file_exists(const char * path) {
-    struct stat st {};
+    struct stat st{};
     return ::stat(path, &st) == 0;
 }
 
@@ -57,10 +56,8 @@ const char * env_or_null(const char * key) {
     return (v != nullptr && v[0] != '\0') ? v : nullptr;
 }
 
-std::vector<int32_t> tokenize(const transcribe_model * model,
-                              const char *             text)
-{
-    int32_t buf[256];
+std::vector<int32_t> tokenize(const transcribe_model * model, const char * text) {
+    int32_t   buf[256];
     const int n = transcribe_tokenize(model, text, buf, 256);
     if (n < 0) {
         return {};
@@ -71,56 +68,48 @@ std::vector<int32_t> tokenize(const transcribe_model * model,
 std::string fmt_ids(const std::vector<int32_t> & v) {
     std::string s = "[";
     for (size_t i = 0; i < v.size(); ++i) {
-        if (i) s += ", ";
+        if (i) {
+            s += ", ";
+        }
         s += std::to_string(v[i]);
     }
     s += "]";
     return s;
 }
 
-void compare(const transcribe_model * gguf,
-             const transcribe_model * bin,
-             const char *             text)
-{
+void compare(const transcribe_model * gguf, const transcribe_model * bin, const char * text) {
     const auto a = tokenize(gguf, text);
-    const auto b = tokenize(bin,  text);
+    const auto b = tokenize(bin, text);
     if (a == b && !a.empty()) {
         return;
     }
-    std::fprintf(stderr,
-                 "FAIL parity for %s\n  gguf: %s\n  bin:  %s\n",
-                 text, fmt_ids(a).c_str(), fmt_ids(b).c_str());
+    std::fprintf(stderr, "FAIL parity for %s\n  gguf: %s\n  bin:  %s\n", text, fmt_ids(a).c_str(), fmt_ids(b).c_str());
     ++g_failures;
 }
 
-} // namespace
+}  // namespace
 
 int main() {
     const char * gguf_path = env_or_null("TRANSCRIBE_WHISPER_GGUF_TINY");
     const char * bin_path  = env_or_null("TRANSCRIBE_WHISPER_BIN_TINY_Q8_0");
-    if (gguf_path == nullptr || bin_path == nullptr ||
-        !file_exists(gguf_path) || !file_exists(bin_path))
-    {
+    if (gguf_path == nullptr || bin_path == nullptr || !file_exists(gguf_path) || !file_exists(bin_path)) {
         std::fprintf(stderr,
                      "SKIP: TRANSCRIBE_WHISPER_GGUF_TINY and "
                      "TRANSCRIBE_WHISPER_BIN_TINY_Q8_0 must both be set\n");
         return 77;
     }
 
-    transcribe_model_load_params mp; transcribe_model_load_params_init(&mp);
+    transcribe_model_load_params mp;
+    transcribe_model_load_params_init(&mp);
     mp.backend = TRANSCRIBE_BACKEND_CPU;
 
     transcribe_model * gguf = nullptr;
-    if (transcribe_model_load_file(gguf_path, &mp, &gguf) != TRANSCRIBE_OK ||
-        gguf == nullptr)
-    {
+    if (transcribe_model_load_file(gguf_path, &mp, &gguf) != TRANSCRIBE_OK || gguf == nullptr) {
         std::fprintf(stderr, "FAIL: could not load GGUF %s\n", gguf_path);
         return 1;
     }
     transcribe_model * bin = nullptr;
-    if (transcribe_model_load_file(bin_path, &mp, &bin) != TRANSCRIBE_OK ||
-        bin == nullptr)
-    {
+    if (transcribe_model_load_file(bin_path, &mp, &bin) != TRANSCRIBE_OK || bin == nullptr) {
         std::fprintf(stderr, "FAIL: could not load .bin %s\n", bin_path);
         transcribe_model_free(gguf);
         return 1;
diff --git a/tests/whisper_e2e_smoke.cpp b/tests/whisper_e2e_smoke.cpp
index 9505f3ce..6e92524f 100644
--- a/tests/whisper_e2e_smoke.cpp
+++ b/tests/whisper_e2e_smoke.cpp
@@ -8,7 +8,6 @@
 
 #include "transcribe.h"
 #include "transcribe/whisper.h"
-
 #include "wav.h"
 
 #include <sys/stat.h>
@@ -23,79 +22,73 @@
 #include <vector>
 
 #ifndef TRANSCRIBE_TEST_SAMPLES_DIR
-#  define TRANSCRIBE_TEST_SAMPLES_DIR "samples"
+#    define TRANSCRIBE_TEST_SAMPLES_DIR "samples"
 #endif
 
 namespace {
 
 int g_failures = 0;
 
-#define CHECK(cond)                                                         \
-    do {                                                                    \
-        if (!(cond)) {                                                      \
-            std::fprintf(stderr, "FAIL %s:%d: %s\n",                        \
-                         __FILE__, __LINE__, #cond);                        \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK(cond)                                                              \
+    do {                                                                         \
+        if (!(cond)) {                                                           \
+            std::fprintf(stderr, "FAIL %s:%d: %s\n", __FILE__, __LINE__, #cond); \
+            ++g_failures;                                                        \
+        }                                                                        \
     } while (0)
 
-#define CHECK_EQ_INT(actual, expected)                                      \
-    do {                                                                    \
-        const long long _a = static_cast<long long>(actual);                \
-        const long long _e = static_cast<long long>(expected);              \
-        if (_a != _e) {                                                     \
-            std::fprintf(stderr,                                            \
-                         "FAIL %s:%d: %s = %lld, expected %lld\n",          \
-                         __FILE__, __LINE__, #actual, _a, _e);              \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK_EQ_INT(actual, expected)                                                                           \
+    do {                                                                                                         \
+        const long long _a = static_cast<long long>(actual);                                                     \
+        const long long _e = static_cast<long long>(expected);                                                   \
+        if (_a != _e) {                                                                                          \
+            std::fprintf(stderr, "FAIL %s:%d: %s = %lld, expected %lld\n", __FILE__, __LINE__, #actual, _a, _e); \
+            ++g_failures;                                                                                        \
+        }                                                                                                        \
     } while (0)
 
 bool file_exists(const std::string & path) {
-    struct stat st {};
+    struct stat st{};
     return ::stat(path.c_str(), &st) == 0;
 }
 
-} // namespace
+}  // namespace
 
 int main() {
     const char * env = std::getenv("TRANSCRIBE_WHISPER_GGUF");
     if (env == nullptr || env[0] == '\0') {
-        std::fprintf(stderr,
-                     "whisper_e2e_smoke: TRANSCRIBE_WHISPER_GGUF not set; skipping.\n");
+        std::fprintf(stderr, "whisper_e2e_smoke: TRANSCRIBE_WHISPER_GGUF not set; skipping.\n");
         return 77;
     }
     const std::string model_path = env;
     if (!file_exists(model_path)) {
-        std::fprintf(stderr,
-                     "whisper_e2e_smoke: model not found: %s\n",
-                     model_path.c_str());
+        std::fprintf(stderr, "whisper_e2e_smoke: model not found: %s\n", model_path.c_str());
         return 77;
     }
 
-    const std::string wav_path =
-        std::string(TRANSCRIBE_TEST_SAMPLES_DIR) + "/jfk.wav";
+    const std::string  wav_path = std::string(TRANSCRIBE_TEST_SAMPLES_DIR) + "/jfk.wav";
     std::vector<float> pcm;
-    std::string wav_err;
+    std::string        wav_err;
     if (!transcribe_cli::load_wav_mono_16k(wav_path, pcm, wav_err)) {
         std::fprintf(stderr, "whisper_e2e_smoke: wav load: %s\n", wav_err.c_str());
         return EXIT_FAILURE;
     }
 
-    transcribe_model_load_params mp; transcribe_model_load_params_init(&mp);
-    mp.backend = TRANSCRIBE_BACKEND_CPU;
+    transcribe_model_load_params mp;
+    transcribe_model_load_params_init(&mp);
+    mp.backend                      = TRANSCRIBE_BACKEND_CPU;
     struct transcribe_model * model = nullptr;
-    transcribe_status st = transcribe_model_load_file(model_path.c_str(), &mp, &model);
+    transcribe_status         st    = transcribe_model_load_file(model_path.c_str(), &mp, &model);
     if (st != TRANSCRIBE_OK || model == nullptr) {
         std::fprintf(stderr, "FAIL load: %s\n", transcribe_status_string(st));
         return EXIT_FAILURE;
     }
 
     CHECK(std::strcmp(transcribe_model_arch_string(model), "whisper") == 0);
-    transcribe_capabilities caps_buf; transcribe_capabilities_init(&caps_buf);
-    const bool caps_ok =
-        transcribe_model_get_capabilities(model, &caps_buf) == TRANSCRIBE_OK;
-    const transcribe_capabilities * caps = caps_ok ? &caps_buf : nullptr;
+    transcribe_capabilities caps_buf;
+    transcribe_capabilities_init(&caps_buf);
+    const bool                      caps_ok = transcribe_model_get_capabilities(model, &caps_buf) == TRANSCRIBE_OK;
+    const transcribe_capabilities * caps    = caps_ok ? &caps_buf : nullptr;
     CHECK(caps != nullptr);
     if (caps != nullptr) {
         CHECK_EQ_INT(caps->native_sample_rate, 16000);
@@ -113,10 +106,11 @@ int main() {
         CHECK(transcribe_model_supports(model, TRANSCRIBE_FEATURE_INITIAL_PROMPT));
     }
 
-    transcribe_session_params cp; transcribe_session_params_init(&cp);
-    cp.kv_type = TRANSCRIBE_KV_TYPE_F32;
+    transcribe_session_params cp;
+    transcribe_session_params_init(&cp);
+    cp.kv_type                      = TRANSCRIBE_KV_TYPE_F32;
     struct transcribe_session * ctx = nullptr;
-    st = transcribe_session_init(model, &cp, &ctx);
+    st                              = transcribe_session_init(model, &cp, &ctx);
     if (st != TRANSCRIBE_OK || ctx == nullptr) {
         std::fprintf(stderr, "FAIL context init: %s\n", transcribe_status_string(st));
         transcribe_model_free(model);
@@ -124,64 +118,67 @@ int main() {
     }
 
     {
-        transcribe_run_params rp; transcribe_run_params_init(&rp);
+        transcribe_run_params rp;
+        transcribe_run_params_init(&rp);
         st = transcribe_run(ctx, pcm.data(), static_cast<int>(pcm.size()), &rp);
         CHECK(st == TRANSCRIBE_OK);
         CHECK(std::strstr(transcribe_full_text(ctx), "country") != nullptr);
-        CHECK_EQ_INT(transcribe_returned_timestamp_kind(ctx),
-                     TRANSCRIBE_TIMESTAMPS_SEGMENT);
+        CHECK_EQ_INT(transcribe_returned_timestamp_kind(ctx), TRANSCRIBE_TIMESTAMPS_SEGMENT);
         CHECK(transcribe_n_segments(ctx) >= 1);
         {
-            transcribe_segment seg; transcribe_segment_init(&seg);
+            transcribe_segment seg;
+            transcribe_segment_init(&seg);
             CHECK_EQ_INT(transcribe_get_segment(ctx, 0, &seg), TRANSCRIBE_OK);
             CHECK(seg.t1_ms >= seg.t0_ms);
         }
     }
 
     {
-        transcribe_run_params rp; transcribe_run_params_init(&rp);
-        rp.language = "en";
+        transcribe_run_params rp;
+        transcribe_run_params_init(&rp);
+        rp.language   = "en";
         rp.timestamps = TRANSCRIBE_TIMESTAMPS_SEGMENT;
-        st = transcribe_run(ctx, pcm.data(), static_cast<int>(pcm.size()), &rp);
+        st            = transcribe_run(ctx, pcm.data(), static_cast<int>(pcm.size()), &rp);
         CHECK(st == TRANSCRIBE_OK);
         CHECK(std::strstr(transcribe_full_text(ctx), "country") != nullptr);
-        CHECK_EQ_INT(transcribe_returned_timestamp_kind(ctx),
-                     TRANSCRIBE_TIMESTAMPS_SEGMENT);
+        CHECK_EQ_INT(transcribe_returned_timestamp_kind(ctx), TRANSCRIBE_TIMESTAMPS_SEGMENT);
         CHECK_EQ_INT(transcribe_n_segments(ctx), 1);
         if (transcribe_n_segments(ctx) == 1) {
-            transcribe_segment seg; transcribe_segment_init(&seg);
+            transcribe_segment seg;
+            transcribe_segment_init(&seg);
             CHECK_EQ_INT(transcribe_get_segment(ctx, 0, &seg), TRANSCRIBE_OK);
             CHECK(seg.t1_ms > seg.t0_ms);
         }
     }
 
     {
-        transcribe_run_params rp; transcribe_run_params_init(&rp);
-        rp.language = "en";
+        transcribe_run_params rp;
+        transcribe_run_params_init(&rp);
+        rp.language   = "en";
         rp.timestamps = TRANSCRIBE_TIMESTAMPS_NONE;
-        st = transcribe_run(ctx, pcm.data(), static_cast<int>(pcm.size()), &rp);
+        st            = transcribe_run(ctx, pcm.data(), static_cast<int>(pcm.size()), &rp);
         CHECK(st == TRANSCRIBE_OK);
         CHECK(std::strstr(transcribe_full_text(ctx), "country") != nullptr);
-        CHECK_EQ_INT(transcribe_returned_timestamp_kind(ctx),
-                     TRANSCRIBE_TIMESTAMPS_NONE);
+        CHECK_EQ_INT(transcribe_returned_timestamp_kind(ctx), TRANSCRIBE_TIMESTAMPS_NONE);
     }
 
     {
-        transcribe_run_params rp; transcribe_run_params_init(&rp);
-        rp.task = TRANSCRIBE_TASK_TRANSLATE;
-        rp.language = "en";
+        transcribe_run_params rp;
+        transcribe_run_params_init(&rp);
+        rp.task       = TRANSCRIBE_TASK_TRANSLATE;
+        rp.language   = "en";
         rp.timestamps = TRANSCRIBE_TIMESTAMPS_NONE;
-        st = transcribe_run(ctx, pcm.data(), static_cast<int>(pcm.size()), &rp);
+        st            = transcribe_run(ctx, pcm.data(), static_cast<int>(pcm.size()), &rp);
         CHECK(st == TRANSCRIBE_OK);
         CHECK(std::strstr(transcribe_full_text(ctx), "country") != nullptr);
-        CHECK_EQ_INT(transcribe_returned_timestamp_kind(ctx),
-                     TRANSCRIBE_TIMESTAMPS_NONE);
+        CHECK_EQ_INT(transcribe_returned_timestamp_kind(ctx), TRANSCRIBE_TIMESTAMPS_NONE);
     }
 
     {
-        transcribe_run_params rp; transcribe_run_params_init(&rp);
+        transcribe_run_params rp;
+        transcribe_run_params_init(&rp);
         rp.timestamps = TRANSCRIBE_TIMESTAMPS_WORD;
-        st = transcribe_run(ctx, pcm.data(), static_cast<int>(pcm.size()), &rp);
+        st            = transcribe_run(ctx, pcm.data(), static_cast<int>(pcm.size()), &rp);
         CHECK(st == TRANSCRIBE_ERR_UNSUPPORTED_TIMESTAMPS);
     }
 
@@ -206,10 +203,11 @@ int main() {
         // trigger_after=5: let a handful of decode steps run, then
         // abort. This exercises the per-step poll, not the pre-run
         // placeholder.
-        AbortState state{0, 5};
+        AbortState state{ 0, 5 };
         transcribe_set_abort_callback(ctx, abort_cb, &state);
 
-        transcribe_run_params rp; transcribe_run_params_init(&rp);
+        transcribe_run_params rp;
+        transcribe_run_params_init(&rp);
         st = transcribe_run(ctx, pcm.data(), static_cast<int>(pcm.size()), &rp);
         CHECK_EQ_INT(st, TRANSCRIBE_ERR_ABORTED);
         CHECK(transcribe_was_aborted(ctx));
@@ -221,10 +219,11 @@ int main() {
         // trigger_after=0: abort before the very first poll return
         // succeeds → pre-run chunk-level check fires. Run never even
         // builds the encoder graph.
-        AbortState state{0, 0};
+        AbortState state{ 0, 0 };
         transcribe_set_abort_callback(ctx, abort_cb, &state);
 
-        transcribe_run_params rp; transcribe_run_params_init(&rp);
+        transcribe_run_params rp;
+        transcribe_run_params_init(&rp);
         st = transcribe_run(ctx, pcm.data(), static_cast<int>(pcm.size()), &rp);
         CHECK_EQ_INT(st, TRANSCRIBE_ERR_ABORTED);
         CHECK(transcribe_was_aborted(ctx));
@@ -235,7 +234,8 @@ int main() {
     // and clears was_aborted.
     transcribe_set_abort_callback(ctx, nullptr, nullptr);
     {
-        transcribe_run_params rp; transcribe_run_params_init(&rp);
+        transcribe_run_params rp;
+        transcribe_run_params_init(&rp);
         st = transcribe_run(ctx, pcm.data(), static_cast<int>(pcm.size()), &rp);
         CHECK_EQ_INT(st, TRANSCRIBE_OK);
         CHECK(!transcribe_was_aborted(ctx));
@@ -247,7 +247,8 @@ int main() {
     // avg_logprob are real numbers from the decoder, not zero.
     {
         CHECK_EQ_INT(transcribe_get_whisper_chunk_count(ctx), 1);
-        transcribe_whisper_chunk_trace tr; transcribe_whisper_chunk_trace_init(&tr);
+        transcribe_whisper_chunk_trace tr;
+        transcribe_whisper_chunk_trace_init(&tr);
         CHECK_EQ_INT(transcribe_get_whisper_chunk_trace(ctx, 0, &tr), TRANSCRIBE_OK);
         CHECK(tr.t0_ms == 0);
         CHECK(tr.t1_ms > tr.t0_ms);
@@ -261,10 +262,10 @@ int main() {
         CHECK(tr.avg_logprob < 0.0f); /* log probabilities are negative */
         CHECK(!tr.no_speech_triggered);
         /* Out-of-range index returns a zeroed trace. */
-        transcribe_whisper_chunk_trace oor; transcribe_whisper_chunk_trace_init(&oor);
+        transcribe_whisper_chunk_trace oor;
+        transcribe_whisper_chunk_trace_init(&oor);
         CHECK_EQ_INT(transcribe_get_whisper_chunk_trace(ctx, 99, &oor), TRANSCRIBE_OK);
-        CHECK(oor.t0_ms == 0 && oor.t1_ms == 0 &&
-              oor.temperature_used == 0.0f && oor.n_fallbacks == 0);
+        CHECK(oor.t0_ms == 0 && oor.t1_ms == 0 && oor.temperature_used == 0.0f && oor.n_fallbacks == 0);
     }
 
     // Long-form chunk loop with dynamic stride.
@@ -273,22 +274,22 @@ int main() {
     // runs at least twice and we expect at least two chunk traces.
     {
         std::vector<float> long_pcm;
-        const int repeats = 4;
+        const int          repeats = 4;
         long_pcm.reserve(pcm.size() * repeats);
         for (int i = 0; i < repeats; ++i) {
             long_pcm.insert(long_pcm.end(), pcm.begin(), pcm.end());
         }
-        transcribe_run_params rp; transcribe_run_params_init(&rp);
-        rp.language = "en";
+        transcribe_run_params rp;
+        transcribe_run_params_init(&rp);
+        rp.language   = "en";
         rp.timestamps = TRANSCRIBE_TIMESTAMPS_SEGMENT;
-        st = transcribe_run(ctx, long_pcm.data(),
-                            static_cast<int>(long_pcm.size()), &rp);
+        st            = transcribe_run(ctx, long_pcm.data(), static_cast<int>(long_pcm.size()), &rp);
         CHECK_EQ_INT(st, TRANSCRIBE_OK);
-        const char * text = transcribe_full_text(ctx);
+        const char * text         = transcribe_full_text(ctx);
         /* The transcript must include the canonical "country" at least
          * once from each of the four JFK repetitions. Require ≥ 2 so
          * the check remains robust to occasional tier-fallback noise. */
-        int country_hits = 0;
+        int          country_hits = 0;
         for (const char * p = text; (p = std::strstr(p, "country")) != nullptr; ++p) {
             ++country_hits;
         }
@@ -297,7 +298,8 @@ int main() {
         /* Every chunk trace's temperature is on the fallback tuple. */
         const int n_chunks = transcribe_get_whisper_chunk_count(ctx);
         for (int i = 0; i < n_chunks; ++i) {
-            transcribe_whisper_chunk_trace tr; transcribe_whisper_chunk_trace_init(&tr);
+            transcribe_whisper_chunk_trace tr;
+            transcribe_whisper_chunk_trace_init(&tr);
             CHECK_EQ_INT(transcribe_get_whisper_chunk_trace(ctx, i, &tr), TRANSCRIBE_OK);
             CHECK(tr.temperature_used >= 0.0f);
             CHECK(tr.temperature_used <= 1.0f + 1e-3f);
@@ -336,15 +338,18 @@ int main() {
     // avg_logprob. The gate requires both conditions per HF
     // _need_fallback; disabling either one disables the skip.
     {
-        transcribe_run_params rp; transcribe_run_params_init(&rp);
-        transcribe_whisper_run_ext wp; transcribe_whisper_run_ext_init(&wp);
+        transcribe_run_params rp;
+        transcribe_run_params_init(&rp);
+        transcribe_whisper_run_ext wp;
+        transcribe_whisper_run_ext_init(&wp);
         wp.no_speech_thold = TRANSCRIBE_WHISPER_THOLD_DISABLED;
-        rp.family = &wp.ext;
-        st = transcribe_run(ctx, pcm.data(), static_cast<int>(pcm.size()), &rp);
+        rp.family          = &wp.ext;
+        st                 = transcribe_run(ctx, pcm.data(), static_cast<int>(pcm.size()), &rp);
         CHECK_EQ_INT(st, TRANSCRIBE_OK);
         const int n = transcribe_get_whisper_chunk_count(ctx);
         for (int i = 0; i < n; ++i) {
-            transcribe_whisper_chunk_trace tr; transcribe_whisper_chunk_trace_init(&tr);
+            transcribe_whisper_chunk_trace tr;
+            transcribe_whisper_chunk_trace_init(&tr);
             CHECK_EQ_INT(transcribe_get_whisper_chunk_trace(ctx, i, &tr), TRANSCRIBE_OK);
             /* no_speech skip gate MUST NOT fire when no_speech_thold
              * is disabled; no_speech_prob itself still populates
@@ -353,15 +358,18 @@ int main() {
         }
     }
     {
-        transcribe_run_params rp; transcribe_run_params_init(&rp);
-        transcribe_whisper_run_ext wp; transcribe_whisper_run_ext_init(&wp);
+        transcribe_run_params rp;
+        transcribe_run_params_init(&rp);
+        transcribe_whisper_run_ext wp;
+        transcribe_whisper_run_ext_init(&wp);
         wp.logprob_thold = TRANSCRIBE_WHISPER_LOGPROB_DISABLED;
-        rp.family = &wp.ext;
-        st = transcribe_run(ctx, pcm.data(), static_cast<int>(pcm.size()), &rp);
+        rp.family        = &wp.ext;
+        st               = transcribe_run(ctx, pcm.data(), static_cast<int>(pcm.size()), &rp);
         CHECK_EQ_INT(st, TRANSCRIBE_OK);
         const int n = transcribe_get_whisper_chunk_count(ctx);
         for (int i = 0; i < n; ++i) {
-            transcribe_whisper_chunk_trace tr; transcribe_whisper_chunk_trace_init(&tr);
+            transcribe_whisper_chunk_trace tr;
+            transcribe_whisper_chunk_trace_init(&tr);
             CHECK_EQ_INT(transcribe_get_whisper_chunk_trace(ctx, i, &tr), TRANSCRIBE_OK);
             CHECK(!tr.no_speech_triggered);
         }
@@ -380,21 +388,24 @@ int main() {
     // escalate through every hotter tier before discarding, producing
     // n_fallbacks >= 1 here.
     {
-        transcribe_run_params rp; transcribe_run_params_init(&rp);
-        transcribe_whisper_run_ext wp; transcribe_whisper_run_ext_init(&wp);
-        wp.no_speech_thold = -1.0f;
-        wp.logprob_thold   =  0.0f;
+        transcribe_run_params rp;
+        transcribe_run_params_init(&rp);
+        transcribe_whisper_run_ext wp;
+        transcribe_whisper_run_ext_init(&wp);
+        wp.no_speech_thold         = -1.0f;
+        wp.logprob_thold           = 0.0f;
         /* Disable compression threshold so compression-ratio failures
          * don't accidentally trigger fallback before the no-speech
          * check gets a chance. */
         wp.compression_ratio_thold = TRANSCRIBE_WHISPER_THOLD_DISABLED;
-        rp.family = &wp.ext;
-        st = transcribe_run(ctx, pcm.data(), static_cast<int>(pcm.size()), &rp);
+        rp.family                  = &wp.ext;
+        st                         = transcribe_run(ctx, pcm.data(), static_cast<int>(pcm.size()), &rp);
         CHECK_EQ_INT(st, TRANSCRIBE_OK);
         const int n = transcribe_get_whisper_chunk_count(ctx);
         CHECK(n >= 1);
         if (n >= 1) {
-            transcribe_whisper_chunk_trace tr; transcribe_whisper_chunk_trace_init(&tr);
+            transcribe_whisper_chunk_trace tr;
+            transcribe_whisper_chunk_trace_init(&tr);
             CHECK_EQ_INT(transcribe_get_whisper_chunk_trace(ctx, 0, &tr), TRANSCRIBE_OK);
             CHECK(tr.no_speech_triggered);
             CHECK_EQ_INT(tr.n_fallbacks, 0);
@@ -412,32 +423,31 @@ int main() {
     // which is why we use the repeated-JFK 40 s PCM here.
     {
         std::vector<float> long_pcm;
-        const int repeats = 4;
+        const int          repeats = 4;
         long_pcm.reserve(pcm.size() * repeats);
         for (int i = 0; i < repeats; ++i) {
             long_pcm.insert(long_pcm.end(), pcm.begin(), pcm.end());
         }
 
-        transcribe_whisper_run_ext wp; transcribe_whisper_run_ext_init(&wp);
-        wp.temperature = 0.4f;           /* forces the sampler active */
-        wp.temperature_inc = 0.0f;       /* single-tier, no fallback  */
-        wp.compression_ratio_thold =
-            TRANSCRIBE_WHISPER_THOLD_DISABLED;
-        wp.logprob_thold = TRANSCRIBE_WHISPER_LOGPROB_DISABLED;
-        wp.no_speech_thold = TRANSCRIBE_WHISPER_THOLD_DISABLED;
-        wp.seed = 42;
+        transcribe_whisper_run_ext wp;
+        transcribe_whisper_run_ext_init(&wp);
+        wp.temperature             = 0.4f; /* forces the sampler active */
+        wp.temperature_inc         = 0.0f; /* single-tier, no fallback  */
+        wp.compression_ratio_thold = TRANSCRIBE_WHISPER_THOLD_DISABLED;
+        wp.logprob_thold           = TRANSCRIBE_WHISPER_LOGPROB_DISABLED;
+        wp.no_speech_thold         = TRANSCRIBE_WHISPER_THOLD_DISABLED;
+        wp.seed                    = 42;
 
-        transcribe_run_params rp; transcribe_run_params_init(&rp);
+        transcribe_run_params rp;
+        transcribe_run_params_init(&rp);
         rp.language = "en";
-        rp.family = &wp.ext;
+        rp.family   = &wp.ext;
 
-        st = transcribe_run(ctx, long_pcm.data(),
-                            static_cast<int>(long_pcm.size()), &rp);
+        st = transcribe_run(ctx, long_pcm.data(), static_cast<int>(long_pcm.size()), &rp);
         CHECK_EQ_INT(st, TRANSCRIBE_OK);
         std::string text_a = transcribe_full_text(ctx);
 
-        st = transcribe_run(ctx, long_pcm.data(),
-                            static_cast<int>(long_pcm.size()), &rp);
+        st = transcribe_run(ctx, long_pcm.data(), static_cast<int>(long_pcm.size()), &rp);
         CHECK_EQ_INT(st, TRANSCRIBE_OK);
         std::string text_b = transcribe_full_text(ctx);
 
@@ -453,12 +463,14 @@ int main() {
     // into a non-OK status). No abort callback is set; the rejection
     // happens inside transcribe_run, not the callback.
     {
-        transcribe_run_params rp; transcribe_run_params_init(&rp);
-        transcribe_whisper_run_ext wp; transcribe_whisper_run_ext_init(&wp);
+        transcribe_run_params rp;
+        transcribe_run_params_init(&rp);
+        transcribe_whisper_run_ext wp;
+        transcribe_whisper_run_ext_init(&wp);
         wp.prompt_condition         = TRANSCRIBE_WHISPER_PROMPT_ALL_SEGMENTS;
         wp.condition_on_prev_tokens = false;
-        rp.family = &wp.ext;
-        st = transcribe_run(ctx, pcm.data(), static_cast<int>(pcm.size()), &rp);
+        rp.family                   = &wp.ext;
+        st                          = transcribe_run(ctx, pcm.data(), static_cast<int>(pcm.size()), &rp);
         CHECK_EQ_INT(st, TRANSCRIBE_ERR_INVALID_ARG);
     }
 
@@ -470,11 +482,13 @@ int main() {
     // directly against the vocab. "<|en|>" is a real id (50259 for
     // multilingual whisper) and must be rejected before any compute.
     {
-        transcribe_run_params rp; transcribe_run_params_init(&rp);
-        transcribe_whisper_run_ext wp; transcribe_whisper_run_ext_init(&wp);
+        transcribe_run_params rp;
+        transcribe_run_params_init(&rp);
+        transcribe_whisper_run_ext wp;
+        transcribe_whisper_run_ext_init(&wp);
         wp.initial_prompt = "Inaugural <|en|> address";
-        rp.family = &wp.ext;
-        st = transcribe_run(ctx, pcm.data(), static_cast<int>(pcm.size()), &rp);
+        rp.family         = &wp.ext;
+        st                = transcribe_run(ctx, pcm.data(), static_cast<int>(pcm.size()), &rp);
         CHECK_EQ_INT(st, TRANSCRIBE_ERR_INVALID_ARG);
     }
 
@@ -483,13 +497,15 @@ int main() {
     // and surfaces as INVALID_ARG so the API contract is observable.
     {
         /* multilingual whisper-tiny: <|startofprev|> = 50361 */
-        int32_t bad[] = { 50361, 100, 200 };
-        transcribe_run_params rp; transcribe_run_params_init(&rp);
-        transcribe_whisper_run_ext wp; transcribe_whisper_run_ext_init(&wp);
+        int32_t               bad[] = { 50361, 100, 200 };
+        transcribe_run_params rp;
+        transcribe_run_params_init(&rp);
+        transcribe_whisper_run_ext wp;
+        transcribe_whisper_run_ext_init(&wp);
         wp.prompt_tokens   = bad;
         wp.n_prompt_tokens = 3;
-        rp.family = &wp.ext;
-        st = transcribe_run(ctx, pcm.data(), static_cast<int>(pcm.size()), &rp);
+        rp.family          = &wp.ext;
+        st                 = transcribe_run(ctx, pcm.data(), static_cast<int>(pcm.size()), &rp);
         CHECK_EQ_INT(st, TRANSCRIBE_ERR_INVALID_ARG);
     }
 
@@ -498,11 +514,13 @@ int main() {
     // pathological audio); we assert that the run completes and
     // "country" still appears.
     {
-        transcribe_run_params rp; transcribe_run_params_init(&rp);
-        transcribe_whisper_run_ext wp; transcribe_whisper_run_ext_init(&wp);
+        transcribe_run_params rp;
+        transcribe_run_params_init(&rp);
+        transcribe_whisper_run_ext wp;
+        transcribe_whisper_run_ext_init(&wp);
         wp.initial_prompt = "Inaugural address";
-        rp.family = &wp.ext;
-        st = transcribe_run(ctx, pcm.data(), static_cast<int>(pcm.size()), &rp);
+        rp.family         = &wp.ext;
+        st                = transcribe_run(ctx, pcm.data(), static_cast<int>(pcm.size()), &rp);
         CHECK_EQ_INT(st, TRANSCRIBE_OK);
         CHECK(std::strstr(transcribe_full_text(ctx), "country") != nullptr);
     }
@@ -511,17 +529,18 @@ int main() {
     // and confirm the run completes. Use transcribe_tokenize for
     // realistic ids matching the model's vocab.
     {
-        int32_t tok_buf[32];
-        const int n = transcribe_tokenize(model, " inaugural address",
-                                          tok_buf, 32);
+        int32_t   tok_buf[32];
+        const int n = transcribe_tokenize(model, " inaugural address", tok_buf, 32);
         CHECK(n > 0);
         if (n > 0) {
-            transcribe_run_params rp; transcribe_run_params_init(&rp);
-            transcribe_whisper_run_ext wp; transcribe_whisper_run_ext_init(&wp);
+            transcribe_run_params rp;
+            transcribe_run_params_init(&rp);
+            transcribe_whisper_run_ext wp;
+            transcribe_whisper_run_ext_init(&wp);
             wp.prompt_tokens   = tok_buf;
             wp.n_prompt_tokens = static_cast<size_t>(n);
-            rp.family = &wp.ext;
-            st = transcribe_run(ctx, pcm.data(), static_cast<int>(pcm.size()), &rp);
+            rp.family          = &wp.ext;
+            st                 = transcribe_run(ctx, pcm.data(), static_cast<int>(pcm.size()), &rp);
             CHECK_EQ_INT(st, TRANSCRIBE_OK);
             CHECK(std::strstr(transcribe_full_text(ctx), "country") != nullptr);
         }
@@ -532,28 +551,17 @@ int main() {
     // move the transcript toward the exact dashed/camel-cased names,
     // matching HF's prompt_ids path on the same clip.
     {
-        const std::string product_path =
-            std::string(TRANSCRIBE_TEST_SAMPLES_DIR) + "/product-names.wav";
+        const std::string  product_path = std::string(TRANSCRIBE_TEST_SAMPLES_DIR) + "/product-names.wav";
         std::vector<float> product_pcm;
-        std::string product_err;
-        if (!transcribe_cli::load_wav_mono_16k(product_path,
-                                               product_pcm, product_err))
-        {
-            std::fprintf(stderr, "whisper_e2e_smoke: wav load: %s\n",
-                         product_err.c_str());
+        std::string        product_err;
+        if (!transcribe_cli::load_wav_mono_16k(product_path, product_pcm, product_err)) {
+            std::fprintf(stderr, "whisper_e2e_smoke: wav load: %s\n", product_err.c_str());
             ++g_failures;
         } else {
             auto product_hits = [](const char * text) {
                 const char * terms[] = {
-                    "QuirkQuid",
-                    "P3-Quattro",
-                    "O3-Omni",
-                    "B3-BondX",
-                    "E3-Equity",
-                    "W3-WrapZ",
-                    "O2-Outlier",
-                    "U3-UniFund",
-                    "M3-Mover",
+                    "QuirkQuid", "P3-Quattro", "O3-Omni",    "B3-BondX", "E3-Equity",
+                    "W3-WrapZ",  "O2-Outlier", "U3-UniFund", "M3-Mover",
                 };
                 int n = 0;
                 for (const char * term : terms) {
@@ -564,26 +572,24 @@ int main() {
                 return n;
             };
 
-            transcribe_run_params rp; transcribe_run_params_init(&rp);
-            rp.language = "en";
+            transcribe_run_params rp;
+            transcribe_run_params_init(&rp);
+            rp.language   = "en";
             rp.timestamps = TRANSCRIBE_TIMESTAMPS_SEGMENT;
-            st = transcribe_run(ctx, product_pcm.data(),
-                                static_cast<int>(product_pcm.size()), &rp);
+            st            = transcribe_run(ctx, product_pcm.data(), static_cast<int>(product_pcm.size()), &rp);
             CHECK_EQ_INT(st, TRANSCRIBE_OK);
-            const int unprompted_hits =
-                product_hits(transcribe_full_text(ctx));
+            const int unprompted_hits = product_hits(transcribe_full_text(ctx));
 
-            transcribe_whisper_run_ext wp; transcribe_whisper_run_ext_init(&wp);
+            transcribe_whisper_run_ext wp;
+            transcribe_whisper_run_ext_init(&wp);
             wp.initial_prompt =
                 "QuirkQuid Quill Inc, P3-Quattro, O3-Omni, "
                 "B3-BondX, E3-Equity, W3-WrapZ, O2-Outlier, "
                 "U3-UniFund, M3-Mover";
             rp.family = &wp.ext;
-            st = transcribe_run(ctx, product_pcm.data(),
-                                static_cast<int>(product_pcm.size()), &rp);
+            st        = transcribe_run(ctx, product_pcm.data(), static_cast<int>(product_pcm.size()), &rp);
             CHECK_EQ_INT(st, TRANSCRIBE_OK);
-            const int prompted_hits =
-                product_hits(transcribe_full_text(ctx));
+            const int prompted_hits = product_hits(transcribe_full_text(ctx));
             CHECK(prompted_hits >= 5);
             CHECK(prompted_hits > unprompted_hits + 3);
         }
@@ -594,11 +600,13 @@ int main() {
     // prompt was used", but the run must succeed with output that
     // still contains "country" (matches the no-prompt default).
     {
-        transcribe_run_params rp; transcribe_run_params_init(&rp);
-        transcribe_whisper_run_ext wp; transcribe_whisper_run_ext_init(&wp);
+        transcribe_run_params rp;
+        transcribe_run_params_init(&rp);
+        transcribe_whisper_run_ext wp;
+        transcribe_whisper_run_ext_init(&wp);
         wp.initial_prompt = "   \t\n  ";
-        rp.family = &wp.ext;
-        st = transcribe_run(ctx, pcm.data(), static_cast<int>(pcm.size()), &rp);
+        rp.family         = &wp.ext;
+        st                = transcribe_run(ctx, pcm.data(), static_cast<int>(pcm.size()), &rp);
         CHECK_EQ_INT(st, TRANSCRIBE_OK);
         CHECK(std::strstr(transcribe_full_text(ctx), "country") != nullptr);
     }
@@ -608,24 +616,23 @@ int main() {
     // doesn't degrade the obvious markers in the transcript.
     {
         std::vector<float> long_pcm;
-        const int repeats = 4;
+        const int          repeats = 4;
         long_pcm.reserve(pcm.size() * repeats);
         for (int i = 0; i < repeats; ++i) {
             long_pcm.insert(long_pcm.end(), pcm.begin(), pcm.end());
         }
-        transcribe_run_params rp; transcribe_run_params_init(&rp);
-        transcribe_whisper_run_ext wp; transcribe_whisper_run_ext_init(&wp);
+        transcribe_run_params rp;
+        transcribe_run_params_init(&rp);
+        transcribe_whisper_run_ext wp;
+        transcribe_whisper_run_ext_init(&wp);
         wp.condition_on_prev_tokens = true;
-        rp.language = "en";
-        rp.family = &wp.ext;
-        st = transcribe_run(ctx, long_pcm.data(),
-                            static_cast<int>(long_pcm.size()), &rp);
+        rp.language                 = "en";
+        rp.family                   = &wp.ext;
+        st                          = transcribe_run(ctx, long_pcm.data(), static_cast<int>(long_pcm.size()), &rp);
         CHECK_EQ_INT(st, TRANSCRIBE_OK);
-        const char * text = transcribe_full_text(ctx);
-        int country_hits = 0;
-        for (const char * p = text;
-             (p = std::strstr(p, "country")) != nullptr; ++p)
-        {
+        const char * text         = transcribe_full_text(ctx);
+        int          country_hits = 0;
+        for (const char * p = text; (p = std::strstr(p, "country")) != nullptr; ++p) {
             ++country_hits;
         }
         CHECK(country_hits >= 2);
@@ -637,20 +644,21 @@ int main() {
     // window. Run completes; "country" still present from the audio.
     {
         std::vector<float> long_pcm;
-        const int repeats = 4;
+        const int          repeats = 4;
         long_pcm.reserve(pcm.size() * repeats);
         for (int i = 0; i < repeats; ++i) {
             long_pcm.insert(long_pcm.end(), pcm.begin(), pcm.end());
         }
-        transcribe_run_params rp; transcribe_run_params_init(&rp);
-        transcribe_whisper_run_ext wp; transcribe_whisper_run_ext_init(&wp);
+        transcribe_run_params rp;
+        transcribe_run_params_init(&rp);
+        transcribe_whisper_run_ext wp;
+        transcribe_whisper_run_ext_init(&wp);
         wp.initial_prompt           = "Inaugural address";
         wp.prompt_condition         = TRANSCRIBE_WHISPER_PROMPT_ALL_SEGMENTS;
         wp.condition_on_prev_tokens = true;
-        rp.language = "en";
-        rp.family = &wp.ext;
-        st = transcribe_run(ctx, long_pcm.data(),
-                            static_cast<int>(long_pcm.size()), &rp);
+        rp.language                 = "en";
+        rp.family                   = &wp.ext;
+        st                          = transcribe_run(ctx, long_pcm.data(), static_cast<int>(long_pcm.size()), &rp);
         CHECK_EQ_INT(st, TRANSCRIBE_OK);
         CHECK(std::strstr(transcribe_full_text(ctx), "country") != nullptr);
     }
@@ -664,17 +672,17 @@ int main() {
     // which we prove by observing that transcribe_returned_timestamp_kind
     // reports something other than the pre-run NONE sentinel.
     {
-        AbortState state{0, 5};
+        AbortState state{ 0, 5 };
         transcribe_set_abort_callback(ctx, abort_cb, &state);
-        transcribe_run_params rp; transcribe_run_params_init(&rp);
+        transcribe_run_params rp;
+        transcribe_run_params_init(&rp);
         rp.timestamps = TRANSCRIBE_TIMESTAMPS_SEGMENT;
-        st = transcribe_run(ctx, pcm.data(), static_cast<int>(pcm.size()), &rp);
+        st            = transcribe_run(ctx, pcm.data(), static_cast<int>(pcm.size()), &rp);
         CHECK_EQ_INT(st, TRANSCRIBE_ERR_ABORTED);
         CHECK(transcribe_was_aborted(ctx));
         /* The explicit SEGMENT request appears on the context even
          * after abort, confirming has_result=true was committed. */
-        CHECK_EQ_INT(transcribe_returned_timestamp_kind(ctx),
-                     TRANSCRIBE_TIMESTAMPS_SEGMENT);
+        CHECK_EQ_INT(transcribe_returned_timestamp_kind(ctx), TRANSCRIBE_TIMESTAMPS_SEGMENT);
         transcribe_set_abort_callback(ctx, nullptr, nullptr);
     }
 
diff --git a/tests/whisper_tokenize_parity.cpp b/tests/whisper_tokenize_parity.cpp
index 764d2629..b71338d3 100644
--- a/tests/whisper_tokenize_parity.cpp
+++ b/tests/whisper_tokenize_parity.cpp
@@ -30,13 +30,12 @@ namespace {
 
 int g_failures = 0;
 
-#define CHECK(cond)                                                         \
-    do {                                                                    \
-        if (!(cond)) {                                                      \
-            std::fprintf(stderr, "FAIL %s:%d: %s\n",                        \
-                         __FILE__, __LINE__, #cond);                        \
-            ++g_failures;                                                   \
-        }                                                                   \
+#define CHECK(cond)                                                              \
+    do {                                                                         \
+        if (!(cond)) {                                                           \
+            std::fprintf(stderr, "FAIL %s:%d: %s\n", __FILE__, __LINE__, #cond); \
+            ++g_failures;                                                        \
+        }                                                                        \
     } while (0)
 
 bool file_exists(const std::string & path) {
@@ -50,27 +49,24 @@ struct Case {
 };
 
 void check_case(const struct transcribe_model * model, const Case & c) {
-    int32_t tokens[64];
+    int32_t   tokens[64];
     const int n = transcribe_tokenize(model, c.text, tokens, 64);
     if (n < 0 || static_cast<size_t>(n) != c.expected.size()) {
-        std::fprintf(stderr,
-                     "FAIL tokenize(%s): n=%d, expected size %zu\n",
-                     c.text, n, c.expected.size());
+        std::fprintf(stderr, "FAIL tokenize(%s): n=%d, expected size %zu\n", c.text, n, c.expected.size());
         ++g_failures;
         return;
     }
     for (int i = 0; i < n; ++i) {
         if (tokens[i] != c.expected[i]) {
-            std::fprintf(stderr,
-                         "FAIL tokenize(%s): tokens[%d]=%d, expected %d\n",
-                         c.text, i, tokens[i], c.expected[i]);
+            std::fprintf(stderr, "FAIL tokenize(%s): tokens[%d]=%d, expected %d\n", c.text, i, tokens[i],
+                         c.expected[i]);
             ++g_failures;
             return;
         }
     }
 }
 
-} // namespace
+}  // namespace
 
 int main() {
     const char * env = std::getenv("TRANSCRIBE_WHISPER_GGUF");
@@ -82,17 +78,15 @@ int main() {
     }
     const std::string model_path = env;
     if (!file_exists(model_path)) {
-        std::fprintf(stderr,
-                     "whisper_tokenize_parity: model not found: %s\n",
-                     model_path.c_str());
+        std::fprintf(stderr, "whisper_tokenize_parity: model not found: %s\n", model_path.c_str());
         return 77;
     }
 
-    transcribe_model_load_params mp; transcribe_model_load_params_init(&mp);
-    mp.backend = TRANSCRIBE_BACKEND_CPU;
+    transcribe_model_load_params mp;
+    transcribe_model_load_params_init(&mp);
+    mp.backend                      = TRANSCRIBE_BACKEND_CPU;
     struct transcribe_model * model = nullptr;
-    const transcribe_status st = transcribe_model_load_file(
-        model_path.c_str(), &mp, &model);
+    const transcribe_status   st    = transcribe_model_load_file(model_path.c_str(), &mp, &model);
     if (st != TRANSCRIBE_OK || model == nullptr) {
         std::fprintf(stderr, "FAIL load: %s\n", transcribe_status_string(st));
         return EXIT_FAILURE;
@@ -103,17 +97,17 @@ int main() {
     // are the load-bearing ones — they exercise the GPT-2 `\p{N}+`
     // path that the Qwen2 pretok (single-digit) would get wrong.
     const std::vector<Case> cases = {
-        { "hello 123 world",    { 675, 1913, 34466, 1002 } },
-        { "The year is 2024.",  { 2278, 1064, 307, 45237, 13 } },
-        { "cost: $99.99",       { 27718, 25, 1848, 8494, 13, 8494 } },
-        { "  multi  spaces",    { 220, 4825, 220, 7673 } },
-        { "I'm going",          { 40, 478, 516 } },
-        { "she isn't here",     { 9611, 1943, 380, 510 } },
-        { "hello world",        { 675, 1913, 1002 } },
-        { "hello  world",       { 675, 1913, 220, 1002 } },
-        { "   triple   space",  { 220, 220, 15508, 220, 220, 1901 } },
-        { "42",                 { 15628 } },
-        { "",                   {} },
+        { "hello 123 world",   { 675, 1913, 34466, 1002 }          },
+        { "The year is 2024.", { 2278, 1064, 307, 45237, 13 }      },
+        { "cost: $99.99",      { 27718, 25, 1848, 8494, 13, 8494 } },
+        { "  multi  spaces",   { 220, 4825, 220, 7673 }            },
+        { "I'm going",         { 40, 478, 516 }                    },
+        { "she isn't here",    { 9611, 1943, 380, 510 }            },
+        { "hello world",       { 675, 1913, 1002 }                 },
+        { "hello  world",      { 675, 1913, 220, 1002 }            },
+        { "   triple   space", { 220, 220, 15508, 220, 220, 1901 } },
+        { "42",                { 15628 }                           },
+        { "",                  {}                                  },
     };
     for (const Case & c : cases) {
         check_case(model, c);
@@ -123,15 +117,15 @@ int main() {
     // return negative-of-N (mirrors whisper.cpp), leaving the caller
     // free to reallocate.
     {
-        const char * text = "hello 123 world"; // needs 4 tokens
-        int32_t tokens[2];
-        const int n = transcribe_tokenize(model, text, tokens, 2);
+        const char * text = "hello 123 world";  // needs 4 tokens
+        int32_t      tokens[2];
+        const int    n = transcribe_tokenize(model, text, tokens, 2);
         CHECK(n == -4);
     }
 
     // Empty text with any n_max returns 0 (success, nothing written).
     {
-        int32_t tokens[1];
+        int32_t   tokens[1];
         const int n = transcribe_tokenize(model, "", tokens, 1);
         CHECK(n == 0);
     }
@@ -145,8 +139,7 @@ int main() {
     transcribe_model_free(model);
 
     if (g_failures > 0) {
-        std::fprintf(stderr,
-                     "whisper_tokenize_parity: %d failures\n", g_failures);
+        std::fprintf(stderr, "whisper_tokenize_parity: %d failures\n", g_failures);
         return EXIT_FAILURE;
     }
     std::fprintf(stdout, "whisper_tokenize_parity: ok\n");
diff --git a/tools/transcribe-bench/main.cpp b/tools/transcribe-bench/main.cpp
index bb007b1c..3543d40c 100644
--- a/tools/transcribe-bench/main.cpp
+++ b/tools/transcribe-bench/main.cpp
@@ -27,12 +27,12 @@ struct bench_args {
     std::string                model_path;
     std::string                sample_path;
     std::string                json_out;
-    int                        iters     = 2;
-    int                        warmup    = 1;
-    int                        n_threads = 0;
-    bool                       quiet     = false;
-    transcribe_backend_request backend   = TRANSCRIBE_BACKEND_AUTO;
-    int                        gpu_device = 0;  // --device N: 0 = auto, >0 = index
+    int                        iters         = 2;
+    int                        warmup        = 1;
+    int                        n_threads     = 0;
+    bool                       quiet         = false;
+    transcribe_backend_request backend       = TRANSCRIBE_BACKEND_AUTO;
+    int                        gpu_device    = 0;  // --device N: 0 = auto, >0 = index
     // Passed through to transcribe_run_params::spec_k_drafts. -1 = family
     // default, 0 = spec decode off, > 0 = explicit draft length. Silently
     // ignored by families without supports_spec_decode. Set by
@@ -42,44 +42,63 @@ struct bench_args {
 
 void print_usage(const char * argv0) {
     std::fprintf(stderr,
-        "usage: %s --model PATH --sample PATH [options]\n"
-        "options:\n"
-        "  --model PATH       GGUF model file (required)\n"
-        "  --sample PATH      WAV file, 16 kHz mono (required)\n"
-        "  --iters N          measured iterations (default 2)\n"
-        "  --warmup N         untimed warmup iterations (default 1)\n"
-        "  --json-out PATH    write result JSON here (default: stdout)\n"
-        "  --quiet            suppress progress lines on stderr\n"
-        "  --threads N        CPU threads (default 0 = library default)\n"
-        "  --backend KIND     request a specific backend:\n"
-        "                       auto|cpu|cpu_accel|metal|vulkan|cuda (default auto)\n"
-        "                     cpu is strict CPU (no GPU, no BLAS/AMX).\n"
-        "                     cpu_accel is CPU + host-memory accelerators\n"
-        "                       (BLAS/AMX) when the build includes them.\n"
-        "  --device N         GPU device index: 0 = auto (first of kind),\n"
-        "                       >0 selects that ggml registry index\n"
-        "  --spec-k-drafts N  speculative-decode draft length on the offline\n"
-        "                     path: -1 = family default, 0 = off, > 0 = K.\n"
-        "                     Ignored by families without spec support.\n"
-        "  -h, --help         show this help\n",
-        argv0);
+                 "usage: %s --model PATH --sample PATH [options]\n"
+                 "options:\n"
+                 "  --model PATH       GGUF model file (required)\n"
+                 "  --sample PATH      WAV file, 16 kHz mono (required)\n"
+                 "  --iters N          measured iterations (default 2)\n"
+                 "  --warmup N         untimed warmup iterations (default 1)\n"
+                 "  --json-out PATH    write result JSON here (default: stdout)\n"
+                 "  --quiet            suppress progress lines on stderr\n"
+                 "  --threads N        CPU threads (default 0 = library default)\n"
+                 "  --backend KIND     request a specific backend:\n"
+                 "                       auto|cpu|cpu_accel|metal|vulkan|cuda (default auto)\n"
+                 "                     cpu is strict CPU (no GPU, no BLAS/AMX).\n"
+                 "                     cpu_accel is CPU + host-memory accelerators\n"
+                 "                       (BLAS/AMX) when the build includes them.\n"
+                 "  --device N         GPU device index: 0 = auto (first of kind),\n"
+                 "                       >0 selects that ggml registry index\n"
+                 "  --spec-k-drafts N  speculative-decode draft length on the offline\n"
+                 "                     path: -1 = family default, 0 = off, > 0 = K.\n"
+                 "                     Ignored by families without spec support.\n"
+                 "  -h, --help         show this help\n",
+                 argv0);
 }
 
 // Parse --backend KIND into the public enum. Returns false and logs a
 // diagnostic on an unknown value.
-bool parse_backend_kind(const char *                   s,
-                        transcribe_backend_request &   out)
-{
-    if (s == nullptr) return false;
-    if (std::strcmp(s, "auto")      == 0) { out = TRANSCRIBE_BACKEND_AUTO;      return true; }
-    if (std::strcmp(s, "cpu")       == 0) { out = TRANSCRIBE_BACKEND_CPU;       return true; }
-    if (std::strcmp(s, "cpu_accel") == 0) { out = TRANSCRIBE_BACKEND_CPU_ACCEL; return true; }
-    if (std::strcmp(s, "metal")     == 0) { out = TRANSCRIBE_BACKEND_METAL;     return true; }
-    if (std::strcmp(s, "vulkan")    == 0) { out = TRANSCRIBE_BACKEND_VULKAN;    return true; }
-    if (std::strcmp(s, "cuda")      == 0) { out = TRANSCRIBE_BACKEND_CUDA;      return true; }
+bool parse_backend_kind(const char * s, transcribe_backend_request & out) {
+    if (s == nullptr) {
+        return false;
+    }
+    if (std::strcmp(s, "auto") == 0) {
+        out = TRANSCRIBE_BACKEND_AUTO;
+        return true;
+    }
+    if (std::strcmp(s, "cpu") == 0) {
+        out = TRANSCRIBE_BACKEND_CPU;
+        return true;
+    }
+    if (std::strcmp(s, "cpu_accel") == 0) {
+        out = TRANSCRIBE_BACKEND_CPU_ACCEL;
+        return true;
+    }
+    if (std::strcmp(s, "metal") == 0) {
+        out = TRANSCRIBE_BACKEND_METAL;
+        return true;
+    }
+    if (std::strcmp(s, "vulkan") == 0) {
+        out = TRANSCRIBE_BACKEND_VULKAN;
+        return true;
+    }
+    if (std::strcmp(s, "cuda") == 0) {
+        out = TRANSCRIBE_BACKEND_CUDA;
+        return true;
+    }
     std::fprintf(stderr,
-        "error: --backend value '%s' not recognized "
-        "(expected one of: auto, cpu, cpu_accel, metal, vulkan, cuda)\n", s);
+                 "error: --backend value '%s' not recognized "
+                 "(expected one of: auto, cpu, cpu_accel, metal, vulkan, cuda)\n",
+                 s);
     return false;
 }
 
@@ -94,25 +113,85 @@ bool parse_args(int argc, char ** argv, bench_args & out) {
 
     for (int i = 1; i < argc; ++i) {
         const std::string a = argv[i];
-        if (a == "-h" || a == "--help") { print_usage(argv[0]); std::exit(0); }
-        else if (a == "--model")    { auto v = need_val(i, "--model");    if (!v) return false; out.model_path  = v; }
-        else if (a == "--sample")   { auto v = need_val(i, "--sample");   if (!v) return false; out.sample_path = v; }
-        else if (a == "--json-out") { auto v = need_val(i, "--json-out"); if (!v) return false; out.json_out    = v; }
-        else if (a == "--iters")    { auto v = need_val(i, "--iters");    if (!v) return false; out.iters     = std::atoi(v); if (out.iters  < 1) out.iters  = 1; }
-        else if (a == "--warmup")   { auto v = need_val(i, "--warmup");   if (!v) return false; out.warmup    = std::atoi(v); if (out.warmup < 0) out.warmup = 0; }
-        else if (a == "--threads")  { auto v = need_val(i, "--threads");  if (!v) return false; out.n_threads = std::atoi(v); if (out.n_threads < 0) out.n_threads = 0; }
-        else if (a == "--spec-k-drafts") { auto v = need_val(i, "--spec-k-drafts"); if (!v) return false; out.spec_k_drafts = std::atoi(v); if (out.spec_k_drafts < -1) { std::fprintf(stderr, "error: --spec-k-drafts must be -1 (family default), 0 (off), or > 0\n"); return false; } }
-        else if (a == "--quiet")    { out.quiet = true; }
-        else if (a == "--backend")  {
-            auto v = need_val(i, "--backend"); if (!v) return false;
-            if (!parse_backend_kind(v, out.backend)) return false;
-        }
-        else if (a == "--device")   {
-            auto v = need_val(i, "--device"); if (!v) return false;
+        if (a == "-h" || a == "--help") {
+            print_usage(argv[0]);
+            std::exit(0);
+        } else if (a == "--model") {
+            auto v = need_val(i, "--model");
+            if (!v) {
+                return false;
+            }
+            out.model_path = v;
+        } else if (a == "--sample") {
+            auto v = need_val(i, "--sample");
+            if (!v) {
+                return false;
+            }
+            out.sample_path = v;
+        } else if (a == "--json-out") {
+            auto v = need_val(i, "--json-out");
+            if (!v) {
+                return false;
+            }
+            out.json_out = v;
+        } else if (a == "--iters") {
+            auto v = need_val(i, "--iters");
+            if (!v) {
+                return false;
+            }
+            out.iters = std::atoi(v);
+            if (out.iters < 1) {
+                out.iters = 1;
+            }
+        } else if (a == "--warmup") {
+            auto v = need_val(i, "--warmup");
+            if (!v) {
+                return false;
+            }
+            out.warmup = std::atoi(v);
+            if (out.warmup < 0) {
+                out.warmup = 0;
+            }
+        } else if (a == "--threads") {
+            auto v = need_val(i, "--threads");
+            if (!v) {
+                return false;
+            }
+            out.n_threads = std::atoi(v);
+            if (out.n_threads < 0) {
+                out.n_threads = 0;
+            }
+        } else if (a == "--spec-k-drafts") {
+            auto v = need_val(i, "--spec-k-drafts");
+            if (!v) {
+                return false;
+            }
+            out.spec_k_drafts = std::atoi(v);
+            if (out.spec_k_drafts < -1) {
+                std::fprintf(stderr, "error: --spec-k-drafts must be -1 (family default), 0 (off), or > 0\n");
+                return false;
+            }
+        } else if (a == "--quiet") {
+            out.quiet = true;
+        } else if (a == "--backend") {
+            auto v = need_val(i, "--backend");
+            if (!v) {
+                return false;
+            }
+            if (!parse_backend_kind(v, out.backend)) {
+                return false;
+            }
+        } else if (a == "--device") {
+            auto v = need_val(i, "--device");
+            if (!v) {
+                return false;
+            }
             out.gpu_device = std::atoi(v);
-            if (out.gpu_device < 0) { std::fprintf(stderr, "error: --device must be >= 0 (0 = auto)\n"); return false; }
-        }
-        else {
+            if (out.gpu_device < 0) {
+                std::fprintf(stderr, "error: --device must be >= 0 (0 = auto)\n");
+                return false;
+            }
+        } else {
             std::fprintf(stderr, "error: unknown option '%s'\n", a.c_str());
             return false;
         }
@@ -128,11 +207,17 @@ bool parse_args(int argc, char ** argv, bench_args & out) {
 // name, only backslash and double-quote need handling.
 std::string json_escape(const char * s) {
     std::string o;
-    if (!s) return o;
+    if (!s) {
+        return o;
+    }
     for (const char * p = s; *p; ++p) {
-        if      (*p == '"')  o += "\\\"";
-        else if (*p == '\\') o += "\\\\";
-        else                 o += *p;
+        if (*p == '"') {
+            o += "\\\"";
+        } else if (*p == '\\') {
+            o += "\\\\";
+        } else {
+            o += *p;
+        }
     }
     return o;
 }
@@ -141,7 +226,9 @@ struct iter_timings {
     double mel_ms, encode_ms, decode_ms, total_ms, wall_ms;
 };
 
-struct stat_summary { double min_v, max_v, mean_v; };
+struct stat_summary {
+    double min_v, max_v, mean_v;
+};
 
 #if defined(__GNUC__) || defined(__clang__)
 __attribute__((format(printf, 2, 3)))
@@ -151,10 +238,13 @@ void append_fmt(std::string & out, const char * fmt, ...) {
     va_start(ap, fmt);
     va_list ap2;
     va_copy(ap2, ap);
-    char buf[256];
+    char      buf[256];
     const int n = std::vsnprintf(buf, sizeof(buf), fmt, ap);
     va_end(ap);
-    if (n < 0) { va_end(ap2); return; }
+    if (n < 0) {
+        va_end(ap2);
+        return;
+    }
     if (static_cast<size_t>(n) < sizeof(buf)) {
         out.append(buf, static_cast<size_t>(n));
     } else {
@@ -168,32 +258,44 @@ void append_fmt(std::string & out, const char * fmt, ...) {
     va_end(ap2);
 }
 
-stat_summary compute_stats(const std::vector<iter_timings> & iters,
-                           double (*pick)(const iter_timings &)) {
-    stat_summary s{0.0, 0.0, 0.0};
-    if (iters.empty()) return s;
+stat_summary compute_stats(const std::vector<iter_timings> & iters, double (*pick)(const iter_timings &)) {
+    stat_summary s{ 0.0, 0.0, 0.0 };
+    if (iters.empty()) {
+        return s;
+    }
     s.min_v = s.max_v = pick(iters[0]);
-    double sum = 0.0;
+    double sum        = 0.0;
     for (const auto & it : iters) {
         const double v = pick(it);
-        if (v < s.min_v) s.min_v = v;
-        if (v > s.max_v) s.max_v = v;
+        if (v < s.min_v) {
+            s.min_v = v;
+        }
+        if (v > s.max_v) {
+            s.max_v = v;
+        }
         sum += v;
     }
     s.mean_v = sum / static_cast<double>(iters.size());
     return s;
 }
 
-} // namespace
+}  // namespace
 
 int main(int argc, char ** argv) {
     bench_args args;
-    if (!parse_args(argc, argv, args)) { print_usage(argv[0]); return EXIT_FAILURE; }
+    if (!parse_args(argc, argv, args)) {
+        print_usage(argv[0]);
+        return EXIT_FAILURE;
+    }
 
-    if (args.quiet) transcribe_log_set(nullptr, nullptr);
+    if (args.quiet) {
+        transcribe_log_set(nullptr, nullptr);
+    }
     const bool quiet = args.quiet;
 
-    if (!quiet) std::fprintf(stderr, "loading sample %s\n", args.sample_path.c_str());
+    if (!quiet) {
+        std::fprintf(stderr, "loading sample %s\n", args.sample_path.c_str());
+    }
     std::vector<float> pcm;
     std::string        wav_err;
     if (!transcribe_cli::load_wav_mono_16k(args.sample_path, pcm, wav_err)) {
@@ -205,25 +307,27 @@ int main(int argc, char ** argv) {
     // Load model. --backend propagates directly to
     // transcribe_model_load_params::backend, which the per-family loader
     // consumes via transcribe::load_common::init_backends.
-    if (!quiet) std::fprintf(stderr, "loading model %s\n", args.model_path.c_str());
-    struct transcribe_model_load_params mp; transcribe_model_load_params_init(&mp);
-    mp.backend = args.backend;
-    mp.gpu_device = args.gpu_device;
-    struct transcribe_model *      model = nullptr;
-    if (const transcribe_status st =
-            transcribe_model_load_file(args.model_path.c_str(), &mp, &model);
+    if (!quiet) {
+        std::fprintf(stderr, "loading model %s\n", args.model_path.c_str());
+    }
+    struct transcribe_model_load_params mp;
+    transcribe_model_load_params_init(&mp);
+    mp.backend                      = args.backend;
+    mp.gpu_device                   = args.gpu_device;
+    struct transcribe_model * model = nullptr;
+    if (const transcribe_status st = transcribe_model_load_file(args.model_path.c_str(), &mp, &model);
         st != TRANSCRIBE_OK) {
         std::fprintf(stderr, "error: model load: %s\n", transcribe_status_string(st));
         return EXIT_FAILURE;
     }
-    const char * backend_c = transcribe_model_backend(model);
-    const std::string backend = (backend_c && *backend_c) ? backend_c : "unknown";
+    const char *      backend_c = transcribe_model_backend(model);
+    const std::string backend   = (backend_c && *backend_c) ? backend_c : "unknown";
 
-    struct transcribe_session_params cp; transcribe_session_params_init(&cp);
-    cp.n_threads = args.n_threads;
+    struct transcribe_session_params cp;
+    transcribe_session_params_init(&cp);
+    cp.n_threads                    = args.n_threads;
     struct transcribe_session * ctx = nullptr;
-    if (const transcribe_status st = transcribe_session_init(model, &cp, &ctx);
-        st != TRANSCRIBE_OK) {
+    if (const transcribe_status st = transcribe_session_init(model, &cp, &ctx); st != TRANSCRIBE_OK) {
         std::fprintf(stderr, "error: context init: %s\n", transcribe_status_string(st));
         transcribe_model_free(model);
         return EXIT_FAILURE;
@@ -232,22 +336,24 @@ int main(int argc, char ** argv) {
     // load_ms is a model-scoped one-shot, captured before any run.
     double load_ms = 0.0;
     {
-        struct transcribe_timings load_tm; transcribe_timings_init(&load_tm);
-        (void)transcribe_get_timings(ctx, &load_tm);
+        struct transcribe_timings load_tm;
+        transcribe_timings_init(&load_tm);
+        (void) transcribe_get_timings(ctx, &load_tm);
         load_ms = static_cast<double>(load_tm.load_ms);
     }
 
-    struct transcribe_run_params rp; transcribe_run_params_init(&rp);
+    struct transcribe_run_params rp;
+    transcribe_run_params_init(&rp);
     rp.spec_k_drafts = args.spec_k_drafts;
 
     // Warmup (untimed).
     for (int w = 0; w < args.warmup; ++w) {
-        if (!quiet) std::fprintf(stderr, "warmup %d/%d\n", w + 1, args.warmup);
-        if (const transcribe_status st = transcribe_run(
-                ctx, pcm.data(), static_cast<int>(pcm.size()), &rp);
+        if (!quiet) {
+            std::fprintf(stderr, "warmup %d/%d\n", w + 1, args.warmup);
+        }
+        if (const transcribe_status st = transcribe_run(ctx, pcm.data(), static_cast<int>(pcm.size()), &rp);
             st != TRANSCRIBE_OK) {
-            std::fprintf(stderr, "error: warmup %d: %s\n",
-                         w + 1, transcribe_status_string(st));
+            std::fprintf(stderr, "error: warmup %d: %s\n", w + 1, transcribe_status_string(st));
             transcribe_session_free(ctx);
             transcribe_model_free(model);
             return EXIT_FAILURE;
@@ -261,21 +367,22 @@ int main(int argc, char ** argv) {
     std::vector<iter_timings> measured;
     measured.reserve(args.iters);
     for (int it = 0; it < args.iters; ++it) {
-        if (!quiet) std::fprintf(stderr, "iter %d/%d\n", it + 1, args.iters);
+        if (!quiet) {
+            std::fprintf(stderr, "iter %d/%d\n", it + 1, args.iters);
+        }
         transcribe_reset_timings(ctx);
-        const auto t0 = std::chrono::steady_clock::now();
-        const transcribe_status st = transcribe_run(
-            ctx, pcm.data(), static_cast<int>(pcm.size()), &rp);
-        const auto t1 = std::chrono::steady_clock::now();
+        const auto              t0 = std::chrono::steady_clock::now();
+        const transcribe_status st = transcribe_run(ctx, pcm.data(), static_cast<int>(pcm.size()), &rp);
+        const auto              t1 = std::chrono::steady_clock::now();
         if (st != TRANSCRIBE_OK) {
-            std::fprintf(stderr, "error: run %d: %s\n",
-                         it + 1, transcribe_status_string(st));
+            std::fprintf(stderr, "error: run %d: %s\n", it + 1, transcribe_status_string(st));
             transcribe_session_free(ctx);
             transcribe_model_free(model);
             return EXIT_FAILURE;
         }
-        struct transcribe_timings after; transcribe_timings_init(&after);
-        (void)transcribe_get_timings(ctx, &after);
+        struct transcribe_timings after;
+        transcribe_timings_init(&after);
+        (void) transcribe_get_timings(ctx, &after);
         iter_timings row;
         row.mel_ms    = static_cast<double>(after.mel_ms);
         row.encode_ms = static_cast<double>(after.encode_ms);
@@ -285,57 +392,60 @@ int main(int argc, char ** argv) {
         measured.push_back(row);
     }
 
-    const char * hyp_text = transcribe_full_text(ctx);
+    const char * hyp_text     = transcribe_full_text(ctx);
     const size_t hyp_text_len = hyp_text ? std::strlen(hyp_text) : 0;
 
     // Collect token IDs for the driver to hash. Emitting them here
     // (rather than hashing in C++) keeps this binary free of a SHA256
     // dependency; the driver is already Python, where hashlib is stdlib.
-    const int n_tokens = transcribe_n_tokens(ctx);
+    const int   n_tokens = transcribe_n_tokens(ctx);
     std::string token_ids_csv;
     token_ids_csv.reserve(static_cast<size_t>(n_tokens) * 6);
     for (int i = 0; i < n_tokens; ++i) {
-        if (i > 0) token_ids_csv.push_back(',');
-        struct transcribe_token tok; transcribe_token_init(&tok);
-        (void)transcribe_get_token(ctx, i, &tok);
+        if (i > 0) {
+            token_ids_csv.push_back(',');
+        }
+        struct transcribe_token tok;
+        transcribe_token_init(&tok);
+        (void) transcribe_get_token(ctx, i, &tok);
         char buf[16];
         std::snprintf(buf, sizeof(buf), "%d", tok.id);
         token_ids_csv.append(buf);
     }
 
-    if (!quiet) std::fprintf(stderr, "done\n");
+    if (!quiet) {
+        std::fprintf(stderr, "done\n");
+    }
 
     // Summary.
-    const stat_summary s_mel    = compute_stats(measured, [](const iter_timings & t) { return t.mel_ms;    });
-    const stat_summary s_encode = compute_stats(measured, [](const iter_timings & t) { return t.encode_ms; });
-    const stat_summary s_decode = compute_stats(measured, [](const iter_timings & t) { return t.decode_ms; });
-    const stat_summary s_total  = compute_stats(measured, [](const iter_timings & t) { return t.total_ms;  });
-    const stat_summary s_wall   = compute_stats(measured, [](const iter_timings & t) { return t.wall_ms;   });
+    const stat_summary s_mel            = compute_stats(measured, [](const iter_timings & t) { return t.mel_ms; });
+    const stat_summary s_encode         = compute_stats(measured, [](const iter_timings & t) { return t.encode_ms; });
+    const stat_summary s_decode         = compute_stats(measured, [](const iter_timings & t) { return t.decode_ms; });
+    const stat_summary s_total          = compute_stats(measured, [](const iter_timings & t) { return t.total_ms; });
+    const stat_summary s_wall           = compute_stats(measured, [](const iter_timings & t) { return t.wall_ms; });
     // RTF based on wall time (the user-visible number — includes
     // uninstrumented run overhead like scheduler alloc, tensor upload,
     // thread fan-out). rtf_compute is the phase-timer sum for backward
     // compat with v1 consumers, but wall is the number to use for
     // perf decisions.
-    const double rtf_wall_mean = (s_wall.mean_v > 0.0)
-        ? sample_duration_s / (s_wall.mean_v / 1000.0) : 0.0;
-    const double rtf_compute_mean = (s_total.mean_v > 0.0)
-        ? sample_duration_s / (s_total.mean_v / 1000.0) : 0.0;
+    const double       rtf_wall_mean    = (s_wall.mean_v > 0.0) ? sample_duration_s / (s_wall.mean_v / 1000.0) : 0.0;
+    const double       rtf_compute_mean = (s_total.mean_v > 0.0) ? sample_duration_s / (s_total.mean_v / 1000.0) : 0.0;
 
     // Hand-rolled JSON. Pretty-printed with 2-space indent; whitespace
     // is irrelevant to the driver but convenient for humans.
     std::string out;
     out.reserve(2048);
     auto stat = [&out](const char * key, const stat_summary & s, bool last) {
-        append_fmt(out, "    \"%s\": {\"min\": %.3f, \"max\": %.3f, \"mean\": %.3f}%s\n",
-                   key, s.min_v, s.max_v, s.mean_v, last ? "" : ",");
+        append_fmt(out, "    \"%s\": {\"min\": %.3f, \"max\": %.3f, \"mean\": %.3f}%s\n", key, s.min_v, s.max_v,
+                   s.mean_v, last ? "" : ",");
     };
 
     out += "{\n";
     append_fmt(out, "  \"schema\": \"transcribe-bench-v2\",\n");
-    append_fmt(out, "  \"model_path\": \"%s\",\n",  json_escape(args.model_path.c_str()).c_str());
+    append_fmt(out, "  \"model_path\": \"%s\",\n", json_escape(args.model_path.c_str()).c_str());
     append_fmt(out, "  \"sample_path\": \"%s\",\n", json_escape(args.sample_path.c_str()).c_str());
     append_fmt(out, "  \"sample_duration_s\": %.3f,\n", sample_duration_s);
-    append_fmt(out, "  \"iters\": %d,\n",  args.iters);
+    append_fmt(out, "  \"iters\": %d,\n", args.iters);
     append_fmt(out, "  \"warmup\": %d,\n", args.warmup);
     append_fmt(out, "  \"spec_k_drafts\": %d,\n", args.spec_k_drafts);
     append_fmt(out, "  \"backend\": \"%s\",\n", json_escape(backend.c_str()).c_str());
@@ -343,24 +453,23 @@ int main(int argc, char ** argv) {
     out += "  \"per_iter\": [\n";
     for (size_t i = 0; i < measured.size(); ++i) {
         const auto & r = measured[i];
-        append_fmt(out, "    {\"mel_ms\": %.3f, \"encode_ms\": %.3f, "
-                        "\"decode_ms\": %.3f, \"total_ms\": %.3f, \"wall_ms\": %.3f}%s\n",
-                   r.mel_ms, r.encode_ms, r.decode_ms, r.total_ms, r.wall_ms,
-                   (i + 1 < measured.size()) ? "," : "");
+        append_fmt(out,
+                   "    {\"mel_ms\": %.3f, \"encode_ms\": %.3f, "
+                   "\"decode_ms\": %.3f, \"total_ms\": %.3f, \"wall_ms\": %.3f}%s\n",
+                   r.mel_ms, r.encode_ms, r.decode_ms, r.total_ms, r.wall_ms, (i + 1 < measured.size()) ? "," : "");
     }
     out += "  ],\n";
     out += "  \"summary\": {\n";
-    stat("mel_ms",    s_mel,    false);
+    stat("mel_ms", s_mel, false);
     stat("encode_ms", s_encode, false);
     stat("decode_ms", s_decode, false);
-    stat("total_ms",  s_total,  false);
-    stat("wall_ms",   s_wall,   true);
+    stat("total_ms", s_total, false);
+    stat("wall_ms", s_wall, true);
     out += "  },\n";
     append_fmt(out, "  \"rtf_wall_mean\": %.3f,\n", rtf_wall_mean);
     append_fmt(out, "  \"rtf_compute_mean\": %.3f,\n", rtf_compute_mean);
     append_fmt(out, "  \"hyp_text_len\": %zu,\n", hyp_text_len);
-    append_fmt(out, "  \"hyp_text\": \"%s\",\n",
-               hyp_text ? json_escape(hyp_text).c_str() : "");
+    append_fmt(out, "  \"hyp_text\": \"%s\",\n", hyp_text ? json_escape(hyp_text).c_str() : "");
     append_fmt(out, "  \"n_tokens\": %d,\n", n_tokens);
     append_fmt(out, "  \"token_ids_csv\": \"%s\"\n", token_ids_csv.c_str());
     out += "}\n";
diff --git a/tools/transcribe-quantize/main.cpp b/tools/transcribe-quantize/main.cpp
index 5799686e..1097d197 100644
--- a/tools/transcribe-quantize/main.cpp
+++ b/tools/transcribe-quantize/main.cpp
@@ -20,11 +20,10 @@
 // is held inside that context, so the writer streams everything in one
 // pass without any external file handling.
 
-#include "policy.h"
-
-#include "ggml.h"
 #include "ggml-alloc.h"
+#include "ggml.h"
 #include "gguf.h"
+#include "policy.h"
 
 #include <algorithm>
 #include <cinttypes>
@@ -37,8 +36,8 @@
 #include <unordered_map>
 #include <vector>
 
-using transcribe::quantize::Preset;
 using transcribe::quantize::find_preset;
+using transcribe::quantize::Preset;
 using transcribe::quantize::preset_table;
 using transcribe::quantize::resolve_target_type;
 
@@ -55,20 +54,18 @@ namespace {
 bool dequantize_to_f32(const ggml_tensor * t, std::vector<float> & out) {
     const int64_t nelem = ggml_nelements(t);
     if (nelem <= 0) {
-        std::fprintf(stderr, "transcribe-quantize: tensor \"%s\" has nelem=%lld\n",
-                     t->name, (long long)nelem);
+        std::fprintf(stderr, "transcribe-quantize: tensor \"%s\" has nelem=%lld\n", t->name, (long long) nelem);
         return false;
     }
-    out.resize((size_t)nelem);
+    out.resize((size_t) nelem);
 
     if (t->type == GGML_TYPE_F32) {
-        std::memcpy(out.data(), t->data, (size_t)nelem * sizeof(float));
+        std::memcpy(out.data(), t->data, (size_t) nelem * sizeof(float));
         return true;
     }
     const auto * tt = ggml_get_type_traits(t->type);
     if (tt == nullptr || tt->to_float == nullptr) {
-        std::fprintf(stderr, "transcribe-quantize: type %s has no to_float\n",
-                     ggml_type_name(t->type));
+        std::fprintf(stderr, "transcribe-quantize: type %s has no to_float\n", ggml_type_name(t->type));
         return false;
     }
     tt->to_float(t->data, out.data(), nelem);
@@ -88,23 +85,17 @@ const char * type_label(ggml_type t) {
     return ggml_type_name(t);
 }
 
-void print_stats(const std::map<ggml_type, PerTypeStats> & stats,
-                 const char * label)
-{
+void print_stats(const std::map<ggml_type, PerTypeStats> & stats, const char * label) {
     int64_t total_bytes = 0;
     int64_t total_n     = 0;
     std::printf("  %-12s%-10s%s\n", "type", "tensors", "MB");
     for (const auto & kv : stats) {
-        std::printf("  %-12s%-10lld%.1f\n",
-                    type_label(kv.first),
-                    (long long)kv.second.n_tensors,
-                    (double)kv.second.bytes / (1024.0 * 1024.0));
+        std::printf("  %-12s%-10lld%.1f\n", type_label(kv.first), (long long) kv.second.n_tensors,
+                    (double) kv.second.bytes / (1024.0 * 1024.0));
         total_bytes += kv.second.bytes;
-        total_n     += kv.second.n_tensors;
+        total_n += kv.second.n_tensors;
     }
-    std::printf("  %-12s%-10lld%.1f total (%s)\n", "",
-                (long long)total_n,
-                (double)total_bytes / (1024.0 * 1024.0),
+    std::printf("  %-12s%-10lld%.1f total (%s)\n", "", (long long) total_n, (double) total_bytes / (1024.0 * 1024.0),
                 label);
 }
 
@@ -121,11 +112,8 @@ void print_stats(const std::map<ggml_type, PerTypeStats> & stats,
 // which would otherwise strand file_type — a tiny scalar a remote consumer
 // wants — *after* the tokenizer trailer.
 const char * const kBulkKvKeys[] = {
-    "tokenizer.ggml.tokens",
-    "tokenizer.ggml.scores",
-    "tokenizer.ggml.token_type",
-    "tokenizer.ggml.merges",
-    "tokenizer.chat_template",
+    "tokenizer.ggml.tokens", "tokenizer.ggml.scores",   "tokenizer.ggml.token_type",
+    "tokenizer.ggml.merges", "tokenizer.chat_template",
 };
 
 // Byte size of one element for the scalar element types that can appear inside
@@ -134,11 +122,23 @@ const char * const kBulkKvKeys[] = {
 // "unexpected type, leave the key where it is."
 size_t bulk_kv_elem_size(gguf_type t) {
     switch (t) {
-        case GGUF_TYPE_UINT8:  case GGUF_TYPE_INT8:  case GGUF_TYPE_BOOL:    return 1;
-        case GGUF_TYPE_UINT16: case GGUF_TYPE_INT16:                         return 2;
-        case GGUF_TYPE_UINT32: case GGUF_TYPE_INT32: case GGUF_TYPE_FLOAT32: return 4;
-        case GGUF_TYPE_UINT64: case GGUF_TYPE_INT64: case GGUF_TYPE_FLOAT64: return 8;
-        default: return 0;
+        case GGUF_TYPE_UINT8:
+        case GGUF_TYPE_INT8:
+        case GGUF_TYPE_BOOL:
+            return 1;
+        case GGUF_TYPE_UINT16:
+        case GGUF_TYPE_INT16:
+            return 2;
+        case GGUF_TYPE_UINT32:
+        case GGUF_TYPE_INT32:
+        case GGUF_TYPE_FLOAT32:
+            return 4;
+        case GGUF_TYPE_UINT64:
+        case GGUF_TYPE_INT64:
+        case GGUF_TYPE_FLOAT64:
+            return 8;
+        default:
+            return 0;
     }
 }
 
@@ -176,7 +176,7 @@ void move_bulk_kv_last(gguf_context * ctx) {
                     continue;  // unexpected element type — leave it in place
                 }
                 // Copy the raw element bytes out before the re-set frees them.
-                const void * data = gguf_get_arr_data(ctx, kid);
+                const void *        data = gguf_get_arr_data(ctx, kid);
                 std::vector<int8_t> tmp(n * esz);
                 if (!tmp.empty()) {
                     std::memcpy(tmp.data(), data, n * esz);
@@ -197,10 +197,11 @@ void move_bulk_kv_last(gguf_context * ctx) {
 
 void print_usage(const char * argv0) {
     std::fprintf(stderr,
-        "usage: %s INPUT.gguf OUTPUT.gguf --quant PRESET\n"
-        "\n"
-        "  --quant PRESET   one of:", argv0);
-    size_t n = 0;
+                 "usage: %s INPUT.gguf OUTPUT.gguf --quant PRESET\n"
+                 "\n"
+                 "  --quant PRESET   one of:",
+                 argv0);
+    size_t         n       = 0;
     const Preset * presets = preset_table(n);
     for (size_t i = 0; i < n; ++i) {
         std::fprintf(stderr, " %s", presets[i].name);
@@ -208,7 +209,7 @@ void print_usage(const char * argv0) {
     std::fprintf(stderr, "\n");
 }
 
-} // namespace
+}  // namespace
 
 int main(int argc, char ** argv) {
     const char * in_path  = nullptr;
@@ -218,10 +219,14 @@ int main(int argc, char ** argv) {
     for (int i = 1; i < argc; ++i) {
         const std::string a = argv[i];
         if (a == "--quant" || a == "-q") {
-            if (i + 1 >= argc) { print_usage(argv[0]); return 2; }
+            if (i + 1 >= argc) {
+                print_usage(argv[0]);
+                return 2;
+            }
             quant = argv[++i];
         } else if (a == "-h" || a == "--help") {
-            print_usage(argv[0]); return 0;
+            print_usage(argv[0]);
+            return 0;
         } else if (in_path == nullptr) {
             in_path = argv[i];
         } else if (out_path == nullptr) {
@@ -243,8 +248,7 @@ int main(int argc, char ** argv) {
         return 2;
     }
 
-    std::printf("transcribe-quantize: %s -> %s (preset %s)\n",
-                in_path, out_path, preset->name);
+    std::printf("transcribe-quantize: %s -> %s (preset %s)\n", in_path, out_path, preset->name);
 
     // Load input gguf with tensor data into a ggml_context.
     //
@@ -252,10 +256,10 @@ int main(int argc, char ** argv) {
     // and load every tensor's bytes into it. After this returns, every
     // ggml_tensor in ctx_in has a valid `data` pointer pointing into
     // that buffer. The data lives until ggml_free(ctx_in).
-    ggml_context * ctx_in = nullptr;
+    ggml_context *   ctx_in = nullptr;
     gguf_init_params in_params{};
-    in_params.no_alloc = false;
-    in_params.ctx      = &ctx_in;
+    in_params.no_alloc     = false;
+    in_params.ctx          = &ctx_in;
     gguf_context * gguf_in = gguf_init_from_file(in_path, in_params);
     if (gguf_in == nullptr) {
         std::fprintf(stderr, "transcribe-quantize: failed to read %s\n", in_path);
@@ -263,7 +267,7 @@ int main(int argc, char ** argv) {
     }
 
     const int64_t n_tensors = gguf_get_n_tensors(gguf_in);
-    std::printf("input: %lld tensors\n", (long long)n_tensors);
+    std::printf("input: %lld tensors\n", (long long) n_tensors);
 
     // Plan: per-tensor target type + total output buffer size.
     //
@@ -282,26 +286,25 @@ int main(int argc, char ** argv) {
     struct PlanEntry {
         ggml_tensor * src;
         ggml_type     dst_type;
-        size_t        dst_nbytes; // ggml_row_size(dst_type, ne0) * nrows
+        size_t        dst_nbytes;  // ggml_row_size(dst_type, ne0) * nrows
     };
+
     std::vector<PlanEntry> plan;
-    plan.reserve((size_t)n_tensors);
-    size_t total_data_bytes = 0;
+    plan.reserve((size_t) n_tensors);
+    size_t                            total_data_bytes = 0;
     std::map<ggml_type, PerTypeStats> in_stats, out_stats;
 
     for (int64_t i = 0; i < n_tensors; ++i) {
-        const char * tname = gguf_get_tensor_name(gguf_in, i);
-        ggml_tensor * t = ggml_get_tensor(ctx_in, tname);
+        const char *  tname = gguf_get_tensor_name(gguf_in, i);
+        ggml_tensor * t     = ggml_get_tensor(ctx_in, tname);
         if (t == nullptr) {
-            std::fprintf(stderr,
-                         "transcribe-quantize: tensor %s missing from ctx_in\n",
-                         tname);
+            std::fprintf(stderr, "transcribe-quantize: tensor %s missing from ctx_in\n", tname);
             ggml_free(ctx_in);
             gguf_free(gguf_in);
             return 1;
         }
         const std::string name(t->name);
-        const ggml_type dst_type = resolve_target_type(*preset, name, t->ne[0]);
+        const ggml_type   dst_type = resolve_target_type(*preset, name, t->ne[0]);
 
         // ggml_row_size handles both block-quant and dense layouts.
         // For multi-row tensors the total bytes is row_size * (nrows
@@ -312,43 +315,40 @@ int main(int argc, char ** argv) {
             nrows *= t->ne[d];
         }
         const size_t row_size = ggml_row_size(dst_type, t->ne[0]);
-        const size_t nb       = row_size * (size_t)nrows;
+        const size_t nb       = row_size * (size_t) nrows;
 
-        plan.push_back({t, dst_type, nb});
+        plan.push_back({ t, dst_type, nb });
         total_data_bytes += nb;
         // Round up to ggml's alignment so each tensor starts on a
         // 32-byte boundary inside the output context buffer.
-        total_data_bytes = (total_data_bytes + 31) & ~size_t{31};
+        total_data_bytes = (total_data_bytes + 31) & ~size_t{ 31 };
 
-        in_stats[t->type].n_tensors  += 1;
-        in_stats[t->type].bytes      += (int64_t)ggml_nbytes(t);
+        in_stats[t->type].n_tensors += 1;
+        in_stats[t->type].bytes += (int64_t) ggml_nbytes(t);
         out_stats[dst_type].n_tensors += 1;
-        out_stats[dst_type].bytes     += (int64_t)nb;
+        out_stats[dst_type].bytes += (int64_t) nb;
     }
 
     // Per-tensor metadata overhead (ggml_tensor struct + bookkeeping
     // inside the context). ggml_tensor_overhead() is the canonical
     // accessor; multiply by tensor count + slack.
     const size_t per_tensor_overhead = ggml_tensor_overhead();
-    const size_t mem_size =
-        total_data_bytes
-        + (size_t)n_tensors * per_tensor_overhead
-        + 16 * 1024 * 1024; // 16 MB safety pad for alignment + bookkeeping
-
-    std::printf("plan: %.1f MB tensor data, %.1f MB context buffer\n",
-                (double)total_data_bytes / (1024.0 * 1024.0),
-                (double)mem_size          / (1024.0 * 1024.0));
+    const size_t mem_size            = total_data_bytes + (size_t) n_tensors * per_tensor_overhead +
+                                       16 * 1024 * 1024;  // 16 MB safety pad for alignment + bookkeeping
+
+    std::printf("plan: %.1f MB tensor data, %.1f MB context buffer\n", (double) total_data_bytes / (1024.0 * 1024.0),
+                (double) mem_size / (1024.0 * 1024.0));
     std::printf("\ninput tensor types:\n");
-    print_stats(in_stats,  "input");
+    print_stats(in_stats, "input");
     std::printf("\noutput tensor types:\n");
     print_stats(out_stats, "output");
     std::printf("\n");
 
     // Allocate the output ggml_context + gguf_context.
     ggml_init_params out_init{};
-    out_init.mem_size   = mem_size;
-    out_init.mem_buffer = nullptr; // ggml will malloc internally
-    out_init.no_alloc   = false;
+    out_init.mem_size      = mem_size;
+    out_init.mem_buffer    = nullptr;  // ggml will malloc internally
+    out_init.no_alloc      = false;
     ggml_context * ctx_out = ggml_init(out_init);
     if (ctx_out == nullptr) {
         std::fprintf(stderr, "transcribe-quantize: ggml_init(out) failed\n");
@@ -384,8 +384,8 @@ int main(int argc, char ** argv) {
 
     // Per-tensor: dequant → fp32 → requant → add to ctx_out.
     std::vector<float> fp32_scratch;
-    int64_t requantized = 0;
-    int64_t copied      = 0;
+    int64_t            requantized = 0;
+    int64_t            copied      = 0;
 
     for (const PlanEntry & e : plan) {
         ggml_tensor * src = e.src;
@@ -393,12 +393,13 @@ int main(int argc, char ** argv) {
         // Allocate the destination tensor in ctx_out with the new
         // dtype and the same shape as the source. ggml_new_tensor
         // handles arbitrary rank up to GGML_MAX_DIMS.
-        const int n_dims = ggml_n_dims(src);
-        ggml_tensor * dst = ggml_new_tensor(ctx_out, e.dst_type, n_dims, src->ne);
+        const int     n_dims = ggml_n_dims(src);
+        ggml_tensor * dst    = ggml_new_tensor(ctx_out, e.dst_type, n_dims, src->ne);
         if (dst == nullptr) {
             std::fprintf(stderr,
                          "transcribe-quantize: ggml_new_tensor failed for %s "
-                         "(out of context memory?)\n", src->name);
+                         "(out of context memory?)\n",
+                         src->name);
             ggml_free(ctx_out);
             gguf_free(gguf_in);
             gguf_free(gguf_out);
@@ -443,12 +444,8 @@ int main(int argc, char ** argv) {
             for (int d = 1; d < GGML_MAX_DIMS; ++d) {
                 nrows *= src->ne[d];
             }
-            ggml_quantize_chunk(dst->type,
-                                fp32_scratch.data(),
-                                dst->data,
-                                /*start=*/0,
-                                nrows,
-                                n_per_row,
+            ggml_quantize_chunk(dst->type, fp32_scratch.data(), dst->data,
+                                /*start=*/0, nrows, n_per_row,
                                 /*imatrix=*/nullptr);
             ++requantized;
         }
@@ -456,8 +453,7 @@ int main(int argc, char ** argv) {
         gguf_add_tensor(gguf_out, dst);
     }
 
-    std::printf("processed: %lld requantized, %lld copied\n",
-                (long long)requantized, (long long)copied);
+    std::printf("processed: %lld requantized, %lld copied\n", (long long) requantized, (long long) copied);
 
     // Write the output gguf.
     if (!gguf_write_to_file(gguf_out, out_path, /*only_meta=*/false)) {
diff --git a/tools/transcribe-quantize/policy.cpp b/tools/transcribe-quantize/policy.cpp
index 30ab2338..d23aea2e 100644
--- a/tools/transcribe-quantize/policy.cpp
+++ b/tools/transcribe-quantize/policy.cpp
@@ -7,8 +7,8 @@
 
 #include "ggml.h"
 
-#include <cstring>
 #include <cctype>
+#include <cstring>
 
 namespace transcribe::quantize {
 
@@ -18,16 +18,16 @@ namespace {
 inline bool contains(const std::string & s, const char * needle) {
     return s.find(needle) != std::string::npos;
 }
+
 inline bool ends_with(const std::string & s, const char * suffix) {
     const size_t n = std::strlen(suffix);
-    return s.size() >= n &&
-           std::memcmp(s.data() + s.size() - n, suffix, n) == 0;
+    return s.size() >= n && std::memcmp(s.data() + s.size() - n, suffix, n) == 0;
 }
 
 // Case-insensitive C-string equality.
 bool iequals(const char * a, const char * b) {
     while (*a && *b) {
-        if (std::tolower((unsigned char)*a) != std::tolower((unsigned char)*b)) {
+        if (std::tolower((unsigned char) *a) != std::tolower((unsigned char) *b)) {
             return false;
         }
         ++a;
@@ -36,7 +36,7 @@ bool iequals(const char * a, const char * b) {
     return *a == '\0' && *b == '\0';
 }
 
-} // namespace
+}  // namespace
 
 // ---------------------------------------------------------------------------
 // Family overrides (scoped, not generalized)
@@ -55,9 +55,7 @@ Bucket classify_tensor(const std::string & name) {
     // Whisper use the llama.cpp-style dec.token_embd.weight. head.bias
     // stays in Norm (it's a 1D per-logit offset after the matmul; loader
     // requires F32).
-    if (name == "dec.embed.token.weight" ||
-        name == "dec.token_embd.weight")
-    {
+    if (name == "dec.embed.token.weight" || name == "dec.token_embd.weight") {
         return Bucket::Embed;
     }
 
@@ -72,11 +70,8 @@ Bucket classify_tensor(const std::string & name) {
     // matches granite/granite_nar where the conv module uses an
     // underscore separator. Also catch running stats (running_mean /
     // running_var) which need to stay F32 for the at-load BN-fusion math.
-    if (contains(name, ".bn.") ||
-        contains(name, "conv_bn.") ||
-        ends_with(name, ".running_mean") ||
-        ends_with(name, ".running_var"))
-    {
+    if (contains(name, ".bn.") || contains(name, "conv_bn.") || ends_with(name, ".running_mean") ||
+        ends_with(name, ".running_var")) {
         return Bucket::Norm;
     }
     // LayerNorm scale (norm_ff1.weight, norm_attn.weight, norm_conv.weight,
@@ -98,30 +93,22 @@ Bucket classify_tensor(const std::string & name) {
     }
     // Cohere: dec.embed.norm.weight and dec.final_norm.weight — layer
     // norm scale tensors that use "." instead of "_" as separator.
-    if (ends_with(name, ".final_norm.weight") ||
-        ends_with(name, ".embed.norm.weight"))
-    {
+    if (ends_with(name, ".final_norm.weight") || ends_with(name, ".embed.norm.weight")) {
         return Bucket::Norm;
     }
     // Qwen3-style norm weights that don't match the "norm_" prefix rule
     // (per-head q_norm/k_norm on attention, output RMSNorm before the
     // tied head, pre/post encoder layer norms).
-    if (ends_with(name, ".q_norm.weight") ||
-        ends_with(name, ".k_norm.weight") ||
-        ends_with(name, ".output_norm.weight") ||
-        ends_with(name, ".ln_post.weight") ||
-        ends_with(name, ".ln_pre.weight"))
-    {
+    if (ends_with(name, ".q_norm.weight") || ends_with(name, ".k_norm.weight") ||
+        ends_with(name, ".output_norm.weight") || ends_with(name, ".ln_post.weight") ||
+        ends_with(name, ".ln_pre.weight")) {
         return Bucket::Norm;
     }
     // Canary decoder layer norms: dec.layer.<N>.norm{1,2,3}.weight —
     // numbered (no underscore), so the generic "norm_" rule misses them.
     // Also dec.norm.weight (final post-decoder layer norm).
-    if (ends_with(name, ".norm1.weight") ||
-        ends_with(name, ".norm2.weight") ||
-        ends_with(name, ".norm3.weight") ||
-        name == "dec.norm.weight")
-    {
+    if (ends_with(name, ".norm1.weight") || ends_with(name, ".norm2.weight") || ends_with(name, ".norm3.weight") ||
+        name == "dec.norm.weight") {
         return Bucket::Norm;
     }
     // Per-head positional biases — added directly to fp32 q via ggml_add
@@ -171,9 +158,7 @@ Bucket classify_tensor(const std::string & name) {
     // SenseVoice: trailing LayerNorms after the encoder stack and after
     // the tp_encoder stack. Don't carry the `norm_` prefix the generic
     // rule looks for, and the loader requires F32.
-    if (ends_with(name, ".after_norm.weight") ||
-        ends_with(name, ".tp_norm.weight"))
-    {
+    if (ends_with(name, ".after_norm.weight") || ends_with(name, ".tp_norm.weight")) {
         return Bucket::Norm;
     }
     // Moonshine Streaming: learned scalar inside the asinh frontend
@@ -197,16 +182,12 @@ Bucket classify_tensor(const std::string & name) {
     // enc.pre_encode.conv.0.weight). granite_nar uses the underscore
     // form `conv_pointwise{1,2}` (single-token names without a `.conv.`
     // separator) — route those to ConvPw as well.
-    if ((ends_with(name, ".conv.pointwise1.weight") ||
-         ends_with(name, ".conv.pointwise2.weight")) &&
-        contains(name, "enc.blocks."))
-    {
+    if ((ends_with(name, ".conv.pointwise1.weight") || ends_with(name, ".conv.pointwise2.weight")) &&
+        contains(name, "enc.blocks.")) {
         return Bucket::ConvPw;
     }
-    if ((ends_with(name, ".conv_pointwise1.weight") ||
-         ends_with(name, ".conv_pointwise2.weight")) &&
-        contains(name, "enc.blocks."))
-    {
+    if ((ends_with(name, ".conv_pointwise1.weight") || ends_with(name, ".conv_pointwise2.weight")) &&
+        contains(name, "enc.blocks.")) {
         return Bucket::ConvPw;
     }
     // Conv kernels: enc.pre_encode.conv.{0,2,3,5,6}.weight and
@@ -259,15 +240,21 @@ namespace {
 
 const Preset kPresets[] = {
     // Uniform fp tiers.
-    {"F16",    GGML_TYPE_F16,  GGML_TYPE_F16, GGML_TYPE_F16,  GGML_TYPE_COUNT, GGML_TYPE_F32, GGML_TYPE_F16, GGML_TYPE_F32, /*MOSTLY_F16*/    1 },
+    { "F16",    GGML_TYPE_F16,  GGML_TYPE_F16,  GGML_TYPE_F16,  GGML_TYPE_COUNT, GGML_TYPE_F32, GGML_TYPE_F16, GGML_TYPE_F32,
+     /*MOSTLY_F16*/ 1                                                                                                                              },
 
     // Legacy blockwise quants. Block size 32 — any sensible inner dim
     // divides cleanly, so linear_fallback is a formality.
-    {"Q4_0",   GGML_TYPE_Q4_0, GGML_TYPE_F16, GGML_TYPE_Q4_0, GGML_TYPE_COUNT, GGML_TYPE_F32, GGML_TYPE_F16, GGML_TYPE_F32, /*MOSTLY_Q4_0*/   2 },
-    {"Q4_1",   GGML_TYPE_Q4_1, GGML_TYPE_F16, GGML_TYPE_Q4_1, GGML_TYPE_COUNT, GGML_TYPE_F32, GGML_TYPE_F16, GGML_TYPE_F32, /*MOSTLY_Q4_1*/   3 },
-    {"Q5_0",   GGML_TYPE_Q5_0, GGML_TYPE_F16, GGML_TYPE_Q5_0, GGML_TYPE_COUNT, GGML_TYPE_F32, GGML_TYPE_F16, GGML_TYPE_F32, /*MOSTLY_Q5_0*/   8 },
-    {"Q5_1",   GGML_TYPE_Q5_1, GGML_TYPE_F16, GGML_TYPE_Q5_1, GGML_TYPE_COUNT, GGML_TYPE_F32, GGML_TYPE_F16, GGML_TYPE_F32, /*MOSTLY_Q5_1*/   9 },
-    {"Q8_0",   GGML_TYPE_Q8_0, GGML_TYPE_F16, GGML_TYPE_Q8_0, GGML_TYPE_COUNT, GGML_TYPE_F32, GGML_TYPE_F16, GGML_TYPE_F32, /*MOSTLY_Q8_0*/   7 },
+    { "Q4_0",   GGML_TYPE_Q4_0, GGML_TYPE_F16,  GGML_TYPE_Q4_0, GGML_TYPE_COUNT, GGML_TYPE_F32, GGML_TYPE_F16,
+     GGML_TYPE_F32,                                                                                                           /*MOSTLY_Q4_0*/ 2    },
+    { "Q4_1",   GGML_TYPE_Q4_1, GGML_TYPE_F16,  GGML_TYPE_Q4_1, GGML_TYPE_COUNT, GGML_TYPE_F32, GGML_TYPE_F16,
+     GGML_TYPE_F32,                                                                                                           /*MOSTLY_Q4_1*/ 3    },
+    { "Q5_0",   GGML_TYPE_Q5_0, GGML_TYPE_F16,  GGML_TYPE_Q5_0, GGML_TYPE_COUNT, GGML_TYPE_F32, GGML_TYPE_F16,
+     GGML_TYPE_F32,                                                                                                           /*MOSTLY_Q5_0*/ 8    },
+    { "Q5_1",   GGML_TYPE_Q5_1, GGML_TYPE_F16,  GGML_TYPE_Q5_1, GGML_TYPE_COUNT, GGML_TYPE_F32, GGML_TYPE_F16,
+     GGML_TYPE_F32,                                                                                                           /*MOSTLY_Q5_1*/ 9    },
+    { "Q8_0",   GGML_TYPE_Q8_0, GGML_TYPE_F16,  GGML_TYPE_Q8_0, GGML_TYPE_COUNT, GGML_TYPE_F32, GGML_TYPE_F16,
+     GGML_TYPE_F32,                                                                                                           /*MOSTLY_Q8_0*/ 7    },
 
     // K-quants. Block size 256; linear_fallback is Q8_0 for every K
     // preset, not a scaled-down legacy quant, because fallback triggers
@@ -282,14 +269,17 @@ const Preset kPresets[] = {
     //      vs F16 and keeps fallback quality monotonically above main.
     // The tradeoff vs Q4_1/Q5_1 fallback is a few percent on file size,
     // paid on tensors that couldn't be K-quantized anyway.
-    {"Q6_K",   GGML_TYPE_Q6_K, GGML_TYPE_Q8_0, GGML_TYPE_Q6_K, GGML_TYPE_COUNT, GGML_TYPE_F32, GGML_TYPE_F16, GGML_TYPE_F32, /*MOSTLY_Q6_K*/  18 },
-    {"Q5_K_M", GGML_TYPE_Q5_K, GGML_TYPE_Q8_0, GGML_TYPE_Q8_0, GGML_TYPE_Q6_K,  GGML_TYPE_F32, GGML_TYPE_F16, GGML_TYPE_F32, /*MOSTLY_Q5_K_M*/ 17 },
-    {"Q4_K_M", GGML_TYPE_Q4_K, GGML_TYPE_Q8_0, GGML_TYPE_Q8_0, GGML_TYPE_Q6_K,  GGML_TYPE_F32, GGML_TYPE_F16, GGML_TYPE_F32, /*MOSTLY_Q4_K_M*/ 15 },
+    { "Q6_K",   GGML_TYPE_Q6_K, GGML_TYPE_Q8_0, GGML_TYPE_Q6_K, GGML_TYPE_COUNT, GGML_TYPE_F32, GGML_TYPE_F16,
+     GGML_TYPE_F32,                                                                                                           /*MOSTLY_Q6_K*/ 18   },
+    { "Q5_K_M", GGML_TYPE_Q5_K, GGML_TYPE_Q8_0, GGML_TYPE_Q8_0, GGML_TYPE_Q6_K,  GGML_TYPE_F32, GGML_TYPE_F16,
+     GGML_TYPE_F32,                                                                                                           /*MOSTLY_Q5_K_M*/ 17 },
+    { "Q4_K_M", GGML_TYPE_Q4_K, GGML_TYPE_Q8_0, GGML_TYPE_Q8_0, GGML_TYPE_Q6_K,  GGML_TYPE_F32, GGML_TYPE_F16,
+     GGML_TYPE_F32,                                                                                                           /*MOSTLY_Q4_K_M*/ 15 },
 };
 
 constexpr size_t kPresetCount = sizeof(kPresets) / sizeof(kPresets[0]);
 
-} // namespace
+}  // namespace
 
 const Preset * find_preset(const char * name) {
     for (size_t i = 0; i < kPresetCount; ++i) {
@@ -305,70 +295,66 @@ const Preset * preset_table(size_t & n_out) {
     return kPresets;
 }
 
-ggml_type resolve_target_type(const Preset & preset,
-                              const std::string & name,
-                              int64_t ne0)
-{
+ggml_type resolve_target_type(const Preset & preset, const std::string & name, int64_t ne0) {
     const Bucket b = classify_tensor(name);
     switch (b) {
-        case Bucket::Norm:   return preset.norm;
-        case Bucket::Conv:   return preset.conv;
-        case Bucket::ConvPw: return preset.conv_pw;
-        case Bucket::Embed: {
-            // If the preset has no explicit embed override, fall back
-            // to linear_main. Shape-misaligned embeddings route through
-            // the same linear_fallback as everything else — for K
-            // presets that's Q8_0, which is strictly higher quality than
-            // the Q6_K bump we'd have applied, so there's no special
-            // case to make here.
-            ggml_type target = (preset.linear_embed != GGML_TYPE_COUNT)
-                ? preset.linear_embed
-                : preset.linear_main;
-            if (const int64_t blk = ggml_blck_size(target); blk > 1 && (ne0 % blk) != 0) {
-                target = preset.linear_fallback;
+        case Bucket::Norm:
+            return preset.norm;
+        case Bucket::Conv:
+            return preset.conv;
+        case Bucket::ConvPw:
+            return preset.conv_pw;
+        case Bucket::Embed:
+            {
+                // If the preset has no explicit embed override, fall back
+                // to linear_main. Shape-misaligned embeddings route through
+                // the same linear_fallback as everything else — for K
+                // presets that's Q8_0, which is strictly higher quality than
+                // the Q6_K bump we'd have applied, so there's no special
+                // case to make here.
+                ggml_type target = (preset.linear_embed != GGML_TYPE_COUNT) ? preset.linear_embed : preset.linear_main;
+                if (const int64_t blk = ggml_blck_size(target); blk > 1 && (ne0 % blk) != 0) {
+                    target = preset.linear_fallback;
+                }
+                // If even the fallback's block size doesn't divide ne0
+                // (e.g. moonshine-streaming's frame_len=80 hitting a Q8_0
+                // fallback with block 32), drop to F16 — the universal
+                // floor. F16 has block size 1 so it always fits.
+                if (const int64_t blk = ggml_blck_size(target); blk > 1 && (ne0 % blk) != 0) {
+                    target = GGML_TYPE_F16;
+                }
+                return target;
             }
-            // If even the fallback's block size doesn't divide ne0
-            // (e.g. moonshine-streaming's frame_len=80 hitting a Q8_0
-            // fallback with block 32), drop to F16 — the universal
-            // floor. F16 has block size 1 so it always fits.
-            if (const int64_t blk = ggml_blck_size(target); blk > 1 && (ne0 % blk) != 0) {
-                target = GGML_TYPE_F16;
+        case Bucket::Linear:
+            {
+                // Attention output projection bumped per _M recipe. Cohere
+                // and Parakeet name it "attn.linear_out.weight"; Qwen3-ASR
+                // and Whisper name it "attn.out.weight" (encoder); Qwen3-ASR
+                // also uses "attn.o.weight" (decoder). All land in the same
+                // bump. Whisper additionally has self_attn / cross_attn
+                // out projections in the decoder under those exact names.
+                const bool is_attn_out = ends_with(name, "attn.linear_out.weight") ||
+                                         ends_with(name, "attn.out.weight") || ends_with(name, "attn.o.weight");
+                ggml_type  target      = is_attn_out ? preset.linear_attn_out : preset.linear_main;
+                // Fall back when inner dim doesn't divide the chosen
+                // quant's block size. Same rule for both linear_main and
+                // linear_attn_out — without it, e.g. whisper-tiny's
+                // d_model=384 attn.out.weight under Q6_K would land at
+                // Q6_K (block size 256) and the GGUF would refuse to load.
+                if (const int64_t blk = ggml_blck_size(target); blk > 1 && (ne0 % blk) != 0) {
+                    target = preset.linear_fallback;
+                }
+                // F16 floor: if linear_fallback's block size also doesn't
+                // divide ne0 (e.g. moonshine-streaming's enc.embedder.linear
+                // with ne0=frame_len=80 → Q8_0 fallback block 32), drop to
+                // F16. F16 has block size 1 so it is the universal floor.
+                if (const int64_t blk = ggml_blck_size(target); blk > 1 && (ne0 % blk) != 0) {
+                    target = GGML_TYPE_F16;
+                }
+                return target;
             }
-            return target;
-        }
-        case Bucket::Linear: {
-            // Attention output projection bumped per _M recipe. Cohere
-            // and Parakeet name it "attn.linear_out.weight"; Qwen3-ASR
-            // and Whisper name it "attn.out.weight" (encoder); Qwen3-ASR
-            // also uses "attn.o.weight" (decoder). All land in the same
-            // bump. Whisper additionally has self_attn / cross_attn
-            // out projections in the decoder under those exact names.
-            const bool is_attn_out =
-                ends_with(name, "attn.linear_out.weight") ||
-                ends_with(name, "attn.out.weight") ||
-                ends_with(name, "attn.o.weight");
-            ggml_type target = is_attn_out
-                ? preset.linear_attn_out
-                : preset.linear_main;
-            // Fall back when inner dim doesn't divide the chosen
-            // quant's block size. Same rule for both linear_main and
-            // linear_attn_out — without it, e.g. whisper-tiny's
-            // d_model=384 attn.out.weight under Q6_K would land at
-            // Q6_K (block size 256) and the GGUF would refuse to load.
-            if (const int64_t blk = ggml_blck_size(target); blk > 1 && (ne0 % blk) != 0) {
-                target = preset.linear_fallback;
-            }
-            // F16 floor: if linear_fallback's block size also doesn't
-            // divide ne0 (e.g. moonshine-streaming's enc.embedder.linear
-            // with ne0=frame_len=80 → Q8_0 fallback block 32), drop to
-            // F16. F16 has block size 1 so it is the universal floor.
-            if (const int64_t blk = ggml_blck_size(target); blk > 1 && (ne0 % blk) != 0) {
-                target = GGML_TYPE_F16;
-            }
-            return target;
-        }
     }
-    return preset.norm; // unreachable
+    return preset.norm;  // unreachable
 }
 
-} // namespace transcribe::quantize
+}  // namespace transcribe::quantize
diff --git a/tools/transcribe-quantize/policy.h b/tools/transcribe-quantize/policy.h
index d9bc04df..868c0caa 100644
--- a/tools/transcribe-quantize/policy.h
+++ b/tools/transcribe-quantize/policy.h
@@ -22,13 +22,13 @@ namespace transcribe::quantize {
 // Tensor role. classify_tensor() maps a canonical GGUF tensor name to
 // exactly one bucket; each preset maps each bucket to one ggml_type.
 enum class Bucket {
-    Linear, // ggml_mul_mat operands — full linear allowlist.
-    Embed,  // Decoder token embedding. Mixed _M presets bump to Q6_K
-            // where shape-compatible; otherwise the preset's
-            // linear_fallback (Q8_0 for all K presets).
-    ConvPw, // 1×1 pointwise convs in conformer blocks (F16 on im2col + mul_mat).
-    Conv,   // Non-pointwise conv kernels (F32 / F16 — no quant im2col).
-    Norm,   // Biases, LayerNorm/BN, pos_bias, pos_enc, frontend buffers (F32).
+    Linear,  // ggml_mul_mat operands — full linear allowlist.
+    Embed,   // Decoder token embedding. Mixed _M presets bump to Q6_K
+             // where shape-compatible; otherwise the preset's
+             // linear_fallback (Q8_0 for all K presets).
+    ConvPw,  // 1×1 pointwise convs in conformer blocks (F16 on im2col + mul_mat).
+    Conv,    // Non-pointwise conv kernels (F32 / F16 — no quant im2col).
+    Norm,    // Biases, LayerNorm/BN, pos_bias, pos_enc, frontend buffers (F32).
 };
 
 // Map a canonical tensor name to its bucket. Substring-based; family-
@@ -44,28 +44,28 @@ struct Preset {
     const char * name;
     // Common case: linear operand, inner dim divides the K-quant block
     // size, not the attention output projection.
-    ggml_type linear_main;
+    ggml_type    linear_main;
     // Fallback when the inner dim doesn't divide linear_main's block
     // size (e.g. Parakeet predictor/joint at ne0=640 vs K-quant block
     // 256). Q8_0 for every K preset — see policy.cpp for the rationale.
     // Legacy block quants (block 32) set this to F16 as a tripwire;
     // it should never trigger in practice.
-    ggml_type linear_fallback;
+    ggml_type    linear_fallback;
     // Attention output projection (attn.linear_out.weight). _M recipes
     // bump this to Q8_0 for quality; uniform presets leave it at
     // linear_main.
-    ggml_type linear_attn_out;
+    ggml_type    linear_attn_out;
     // Decoder token embedding (Embed bucket). GGML_TYPE_COUNT means "no
     // override" — resolve to linear_main.
-    ggml_type linear_embed;
+    ggml_type    linear_embed;
     // Non-pointwise conv kernels.
-    ggml_type conv;
+    ggml_type    conv;
     // 1×1 pointwise conv kernels.
-    ggml_type conv_pw;
+    ggml_type    conv_pw;
     // Norm-bucket tensors (always F32 today; field exists for symmetry).
-    ggml_type norm;
+    ggml_type    norm;
     // llama-style file_type tag written to general.file_type.
-    uint32_t file_type;
+    uint32_t     file_type;
 };
 
 // Look up a preset by name. Case-insensitive so "Q4_K_M", "q4_k_m",
@@ -81,8 +81,6 @@ const Preset * preset_table(size_t & n_out);
 // Resolve the per-tensor target ggml_type. Takes the source tensor's
 // ne[0] so the linear_fallback path can trip when the inner dim
 // doesn't divide the target block size.
-ggml_type resolve_target_type(const Preset & preset,
-                              const std::string & name,
-                              int64_t ne0);
+ggml_type resolve_target_type(const Preset & preset, const std::string & name, int64_t ne0);
 
-} // namespace transcribe::quantize
+}  // namespace transcribe::quantize