diff --git a/ARCHITECTURE_V4.md b/ARCHITECTURE_V4.md
index 3da76e1..084a4b6 100644
--- a/ARCHITECTURE_V4.md
+++ b/ARCHITECTURE_V4.md
@@ -331,6 +331,14 @@ audio output. That capability, along with the broader question of a
 dedicated audio-generation stack, belongs to a separate project
 entirely and is intentionally out of scope here.
 
+> **Delivered in v4.0.0-alpha.2 (Phase 42).** The `aarambh-studio-audio`
+> crate, `<audio>`/`<audio_end>` tokenizer tokens, `convert --upgrade-audio-vocab`,
+> `[vision.audio]` config, `finetune audio-dora`, `infer --audio`, the
+> `audio-qa` eval task, and the full test suite are implemented. See
+> [docs/phase42_audio.md](docs/phase42_audio.md). WAV PCM decode and
+> mel-spectrogram extraction are pure-Rust from first principles (no
+> `rustfft` or audio-ML dependency); MP3/FLAC/Ogg decode is future work.
+
 ---
 
 ## 57. Sparse/Grouped MoE Dispatch
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2ad7fec..c1344e4 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,64 @@
 
 > From first principles. From zero. From Rust.
 
+## [4.0.0-alpha.2] - 2026-08-09
+
+### Added
+
+- **Phase 42 — Audio Modality:** A fourth input sense — audio — following the
+  exact frozen-encoder-plus-trainable-projector pattern v2 §24 established for
+  vision and v3 §35–36 reused for video and documents. A frozen, pretrained
+  audio spectrogram transformer converts a log-mel spectrogram into a grid of
+  patch embeddings; a trainable projector maps them into the decoder's
+  `d_model` space; the result is spliced into the token sequence at the
+  `<audio>` special token position. Nothing about the decoder, the thinking
+  engine, or tool calling changes.
+  - New `aarambh-studio-audio` crate (Layer 3, workspace package count
+    19 → 20): `FrozenAudioEncoder` (AST-style patchify + transformer blocks,
+    `load_pretrained` via `VarBuilder::from_mmaped_safetensors`, same loading
+    path as CLIP), `AudioPreprocessor` (pure-Rust WAV decode for PCM
+    8/16/24/32-bit + 32/64-bit float, linear resampling, Hann window, radix-2
+    Cooley-Tukey FFT, triangular mel filterbank, log-mel normalization — zero
+    new dependencies), `AudioProjector` (two-layer GELU MLP mirroring
+    `VisionProjector`), `interleave_audio_tokens`, `AudioQaExample` +
+    `load_audio_qa_jsonl` (caption, QA, and LLaVA conversation formats).
+  - Tokenizer: `<audio>`/`<audio_end>` reserved special tokens (IDs 15/16),
+    `AUDIO_SPECIAL_TOKENS` table (17 entries, strict superset of the Phase 36
+    document table), `BpeTokenizer::validate_audio_special_tokens` and
+    `upgraded_for_audio` (insertion at ID 15, +2 rows, shifts learned IDs ≥ 15).
+  - `convert --upgrade-audio-vocab` applies the vocabulary migration to a
+    SafeTensors checkpoint and tokenizer together
+    (`VocabularyExpansion { insertion_id: 15, source_ids: [IMAGE_ID, IMAGE_END_ID] }`).
+  - `[vision.audio]` config block (`AudioTrainingConfig`: audio_root, encoder
+    config/weights paths, `mel: MelSpectrogramConfig`, encoder_batch_size,
+    feature_cache_entries) under the shared `[vision]` multimodal block.
+  - `finetune audio-dora` / `audio-qdora` subcommands: a self-contained
+    two-stage DoRA trainer (`run_audio_vlm_dora_from_config`) reusing
+    `DoraAarambhModel`, `AdamW::from_varmap`, `CosineScheduleWithWarmup`,
+    `accumulate_for_optimizer`, `cross_entropy_loss`, and `save_adapter`, with
+    audio-specific `audio_example_loss` / `audio_labels_and_mask` and an
+    `audio_adapter_config.json` artifact.
+  - `infer --audio <path>` flag (conflicts with `--image`/`--video`/`--document`)
+    with `AudioRuntime`, `build_audio_prompt_embeddings`,
+    `project_audio_tokens`, `run_audio_infer`, and an `AudioSafetyAdapter`
+    implementing `SafetyGenerator`.
+  - `eval --tasks audio-qa` / `audio-qa-smoke` task implementing the shared
+    `EvalTask` trait.
+  - New configs: `configs/audio_qa_smoke.toml`,
+    `configs/audio_qa_smoke_infer.toml`; new scripts
+    `scripts/phase42_make_audio_smoke_fixture.py`,
+    `scripts/phase42_prepare_audio_data.sh`, `scripts/phase42_smoke.sh`; new
+    doc `docs/phase42_audio.md`.
+  - Tests: `frozen_audio_encoder_never_receives_gradients`,
+    `projector_pretrain_stage_trains_only_projector_weights`,
+    `audio_token_fusion_produces_expected_sequence_length`,
+    `thinking_controller_behaves_identically_after_audio_context`, plus
+    WAV-decode, FFT-frequency-recovery, mel-frame-counting, projector-width,
+    fusion-placeholder, JSONL-parsing, and tokenizer-table-consistency tests.
+  - Audio **understanding** only (no generation); WAV PCM only (no MP3/FLAC/Ogg);
+    mel extraction is pure-Rust from first principles. The same explicit-scope
+    discipline every prior modality phase holds.
+
 ## [4.0.0-alpha.1] - 2026-07-31
 
 ### Added
diff --git a/Cargo.lock b/Cargo.lock
index 6d1fdbb..ef8ae3b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4,9 +4,10 @@ version = 4
 
 [[package]]
 name = "aarambh-studio"
-version = "4.0.0-alpha.1"
+version = "4.0.0-alpha.2"
 dependencies = [
  "aarambh-studio-agent",
+ "aarambh-studio-audio",
  "aarambh-studio-core",
  "aarambh-studio-data",
  "aarambh-studio-distill",
@@ -35,7 +36,7 @@ dependencies = [
 
 [[package]]
 name = "aarambh-studio-agent"
-version = "4.0.0-alpha.1"
+version = "4.0.0-alpha.2"
 dependencies = [
  "aarambh-studio-core",
  "aarambh-studio-inference",
@@ -44,9 +45,20 @@ dependencies = [
  "thiserror 2.0.19",
 ]
 
+[[package]]
+name = "aarambh-studio-audio"
+version = "4.0.0-alpha.2"
+dependencies = [
+ "aarambh-studio-core",
+ "candle-core",
+ "candle-nn",
+ "serde",
+ "serde_json",
+]
+
 [[package]]
 name = "aarambh-studio-core"
-version = "4.0.0-alpha.1"
+version = "4.0.0-alpha.2"
 dependencies = [
  "candle-core",
  "serde",
@@ -56,7 +68,7 @@ dependencies = [
 
 [[package]]
 name = "aarambh-studio-data"
-version = "4.0.0-alpha.1"
+version = "4.0.0-alpha.2"
 dependencies = [
  "aarambh-studio-core",
  "candle-core",
@@ -67,7 +79,7 @@ dependencies = [
 
 [[package]]
 name = "aarambh-studio-distill"
-version = "4.0.0-alpha.1"
+version = "4.0.0-alpha.2"
 dependencies = [
  "aarambh-studio-core",
  "aarambh-studio-inference",
@@ -84,9 +96,10 @@ dependencies = [
 
 [[package]]
 name = "aarambh-studio-eval"
-version = "4.0.0-alpha.1"
+version = "4.0.0-alpha.2"
 dependencies = [
  "aarambh-studio-agent",
+ "aarambh-studio-audio",
  "aarambh-studio-core",
  "aarambh-studio-finetune",
  "aarambh-studio-inference",
@@ -105,8 +118,9 @@ dependencies = [
 
 [[package]]
 name = "aarambh-studio-finetune"
-version = "4.0.0-alpha.1"
+version = "4.0.0-alpha.2"
 dependencies = [
+ "aarambh-studio-audio",
  "aarambh-studio-core",
  "aarambh-studio-kernel",
  "aarambh-studio-model",
@@ -125,7 +139,7 @@ dependencies = [
 
 [[package]]
 name = "aarambh-studio-inference"
-version = "4.0.0-alpha.1"
+version = "4.0.0-alpha.2"
 dependencies = [
  "aarambh-studio-core",
  "aarambh-studio-model",
@@ -141,7 +155,7 @@ dependencies = [
 
 [[package]]
 name = "aarambh-studio-kernel"
-version = "4.0.0-alpha.1"
+version = "4.0.0-alpha.2"
 dependencies = [
  "aarambh-studio-core",
  "candle-core",
@@ -155,7 +169,7 @@ dependencies = [
 
 [[package]]
 name = "aarambh-studio-model"
-version = "4.0.0-alpha.1"
+version = "4.0.0-alpha.2"
 dependencies = [
  "aarambh-studio-core",
  "aarambh-studio-nn",
@@ -166,7 +180,7 @@ dependencies = [
 
 [[package]]
 name = "aarambh-studio-nn"
-version = "4.0.0-alpha.1"
+version = "4.0.0-alpha.2"
 dependencies = [
  "aarambh-studio-core",
  "aarambh-studio-kernel",
@@ -177,7 +191,7 @@ dependencies = [
 
 [[package]]
 name = "aarambh-studio-quant"
-version = "4.0.0-alpha.1"
+version = "4.0.0-alpha.2"
 dependencies = [
  "aarambh-studio-core",
  "candle-core",
@@ -188,7 +202,7 @@ dependencies = [
 
 [[package]]
 name = "aarambh-studio-safety"
-version = "4.0.0-alpha.1"
+version = "4.0.0-alpha.2"
 dependencies = [
  "aarambh-studio-core",
  "aarambh-studio-inference",
@@ -199,7 +213,7 @@ dependencies = [
 
 [[package]]
 name = "aarambh-studio-selflearn"
-version = "4.0.0-alpha.1"
+version = "4.0.0-alpha.2"
 dependencies = [
  "aarambh-studio-core",
  "aarambh-studio-eval",
@@ -220,7 +234,7 @@ dependencies = [
 
 [[package]]
 name = "aarambh-studio-serve"
-version = "4.0.0-alpha.1"
+version = "4.0.0-alpha.2"
 dependencies = [
  "aarambh-studio-core",
  "aarambh-studio-inference",
@@ -244,7 +258,7 @@ dependencies = [
 
 [[package]]
 name = "aarambh-studio-tokenizer"
-version = "4.0.0-alpha.1"
+version = "4.0.0-alpha.2"
 dependencies = [
  "aarambh-studio-core",
  "serde",
@@ -254,8 +268,9 @@ dependencies = [
 
 [[package]]
 name = "aarambh-studio-train"
-version = "4.0.0-alpha.1"
+version = "4.0.0-alpha.2"
 dependencies = [
+ "aarambh-studio-audio",
  "aarambh-studio-core",
  "aarambh-studio-data",
  "aarambh-studio-model",
@@ -271,7 +286,7 @@ dependencies = [
 
 [[package]]
 name = "aarambh-studio-vision"
-version = "4.0.0-alpha.1"
+version = "4.0.0-alpha.2"
 dependencies = [
  "aarambh-studio-core",
  "candle-core",
@@ -287,7 +302,7 @@ dependencies = [
 
 [[package]]
 name = "aarambh-studio-weights"
-version = "4.0.0-alpha.1"
+version = "4.0.0-alpha.2"
 dependencies = [
  "aarambh-studio-core",
  "aarambh-studio-model",
diff --git a/Cargo.toml b/Cargo.toml
index ac9babe..5a414f6 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -16,6 +16,7 @@ members = [
     "crates/aarambh-studio-selflearn",
     "crates/aarambh-studio-eval",
     "crates/aarambh-studio-vision",
+    "crates/aarambh-studio-audio",
     "crates/aarambh-studio-distill",
     "crates/aarambh-studio-serve",
     "aarambh-studio",
@@ -23,7 +24,7 @@ members = [
 resolver = "2"
 
 [workspace.package]
-version = "4.0.0-alpha.1"
+version = "4.0.0-alpha.2"
 edition = "2024"
 rust-version = "1.89"
 description = "From first principles. From zero. From Rust."
diff --git a/README.md b/README.md
index 5efefc6..249fd58 100644
--- a/README.md
+++ b/README.md
@@ -18,9 +18,11 @@ with hybrid Gated DeltaNet, DeepSeek Sparse Attention,
 fine-grained MoE with shared experts, Multi-Token Prediction (MTP), on-policy
 distillation, native quantization-aware training, native video/document input,
 bounded long-horizon tool-use chains, persistent forgetting diagnostics, and
-Max thinking mode (16,384-token budget). **v4.0.0-alpha.1** begins the v4 arc
-with Multi-Head Latent Attention (Phase 41) — a third attention kind that
-compresses the KV cache into a single low-rank latent per token.
+Max thinking mode (16,384-token budget). **v4.0.0-alpha.2** continues the v4 arc
+with Multi-Head Latent Attention (Phase 41) and a native Audio modality
+(Phase 42) — a frozen audio spectrogram transformer plus trainable projector
+that lets the model hear and reason about audio clips, the same
+frozen-encoder-plus-projector recipe vision, video, and documents use.
 
 > [!IMPORTANT]
 > This is a source and engineering project. It does not publish crates to
@@ -39,6 +41,7 @@ compresses the KV cache into a single low-rank latent per token.
 | Model formats | SafeTensors, INT8, GPTQ/AWQ INT4, GGUF, Hugging Face conversion, quantized KV cache |
 | Evaluation | Perplexity, MMLU-lite, HellaSwag, GSM8K, HumanEval-lite, preference, recall, multimodal/tool scorecards, capability forgetting curves, and MoE routing drift |
 | Vision | Frozen CLIP-style encoder, image/video/document fusion, temporal and 2D layout encoding, multimodal DoRA/QDoRA tuning |
+| Audio | Frozen audio spectrogram transformer, pure-Rust WAV decode + mel-spectrogram, `<audio>` token fusion, audio DoRA/QDoRA tuning (Phase 42) |
 | Runtime | CPU SIMD, Rayon attention, optional custom CUDA PTX kernels, Axum 0.8.9 HTTP/SSE server |
 | Guardrails | Prompt-injection checks, jailbreak checks, PII redaction, output scanning, streaming token safety, audit logs |
 | Self-learning | Opt-in critique, replay, verifier rewards, deferred CPU updates, CUDA vision mode, and post-commit forgetting probes |
@@ -95,7 +98,7 @@ produce useful language quality.
 
 ```text
 aarambh-studio train       Pretrain or continue a configured model
-aarambh-studio infer       Generate text or answer an image/video-grounded prompt
+aarambh-studio infer       Generate text or answer an image/video/document/audio-grounded prompt
 aarambh-studio agent       Orchestrate bounded caller-executed tool-use chains
 aarambh-studio eval        Run evaluation tasks and compare scorecards
 aarambh-studio quantise    Calibrate and export INT8/INT4 GGUF checkpoints
@@ -115,10 +118,11 @@ See the phase-specific docs for full walkthroughs with smoke fixtures:
 | Workflow | Guide |
 |---|---|
 | Train (CPU/GPU, MTP, MoE, distillation, QAT) | `aarambh-studio train --help` + [configs/](configs/) TOML examples |
-| Inference (text, thinking, image, video, document) | [docs/aarambh-studio-complete-guide.md](docs/aarambh-studio-complete-guide.md) |
+| Inference (text, thinking, image, video, document, audio) | [docs/aarambh-studio-complete-guide.md](docs/aarambh-studio-complete-guide.md) |
 | Tool-use agent chains | [docs/phase37_agent.md](docs/phase37_agent.md) |
 | Video understanding | [docs/phase35_video.md](docs/phase35_video.md) |
 | Document understanding | [docs/phase36_document.md](docs/phase36_document.md) |
+| Audio understanding | [docs/phase42_audio.md](docs/phase42_audio.md) |
 | OpenAI-compatible server | [docs/inference-server.md](docs/inference-server.md) |
 | Evaluation & forgetting diagnostics | [docs/phase38_forgetting.md](docs/phase38_forgetting.md) |
 | Multi-Head Latent Attention (MLA) | [docs/phase41_mla.md](docs/phase41_mla.md) |
@@ -174,7 +178,7 @@ any of `none`, `low`, `medium`, `high`, or `max`. The server also accepts
 
 ## Workspace
 
-The workspace contains 18 internal library crates and one CLI package:
+The workspace contains 19 internal library crates and one CLI package:
 
 ```text
 aarambh-studio-core        Shared config, device, dtype, errors, and traits
@@ -193,6 +197,7 @@ aarambh-studio-safety      Input, output, streaming, PII, and audit policies
 aarambh-studio-selflearn   Critique, replay, verifiers, and persistent update state
 aarambh-studio-eval        Evaluation tasks, scorecards, and comparisons
 aarambh-studio-vision      Image/video/document decode, preprocessing, temporal/layout fusion
+aarambh-studio-audio       WAV decode, mel-spectrogram, frozen audio encoder, fusion (Phase 42)
 aarambh-studio-distill     On-policy rollouts, teacher scoring, losses, and resume
 aarambh-studio-serve       Axum HTTP/SSE serving and continuous batching
 aarambh-studio             Command-line application
@@ -224,12 +229,15 @@ CUDA checks require a CUDA-capable environment and are intentionally opt-in.
 | [ARCHITECTURE.md](ARCHITECTURE.md) | v1 model, training, inference, safety, and self-learning design |
 | [ARCHITECTURE_V2.md](ARCHITECTURE_V2.md) | v2 long context, vision, MoE, distributed, tools, and serving additions |
 | [ARCHITECTURE_V3.md](ARCHITECTURE_V3.md) | v3 hybrid attention, DSA, fine-grained MoE, MTP, agents, and forgetting diagnostics |
+| [ARCHITECTURE_V4.md](ARCHITECTURE_V4.md) | v4 MLA, audio modality, sparse MoE dispatch, multi-node, test-time compute, RLAIF, sandboxed tools, multi-agent, RAG, merging, public server, system role, red-team, model card |
 | [ROADMAP.md](ROADMAP.md) | Completed v1 phases |
 | [ROADMAP_V2.md](ROADMAP_V2.md) | Completed v2 phases through the v2.0.0 release |
-| [ROADMAP_V3.md](ROADMAP_V3.md) | Current v3 delivery plan and status |
+| [ROADMAP_V3.md](ROADMAP_V3.md) | Completed v3 phases |
+| [ROADMAP_V4.md](ROADMAP_V4.md) | Current v4 delivery plan and status |
 | [SELF_LEARNING.md](SELF_LEARNING.md) | Text self-learning design |
 | [SELF_LEARNING_V2.md](SELF_LEARNING_V2.md) | Vision-aware self-learning design |
 | [SELF_LEARNING_V3.md](SELF_LEARNING_V3.md) | v3 self-learning and forgetting-diagnostic integration |
+| [SELF_LEARNING_V4.md](SELF_LEARNING_V4.md) | v4 self-learning scope across the v4 feature set |
 | [docs/aarambh-studio-config-toml-guide.md](docs/aarambh-studio-config-toml-guide.md) | Configuration field reference |
 | [docs/aarambh-studio-complete-guide.md](docs/aarambh-studio-complete-guide.md) | Beginner-oriented project walkthrough |
 | [docs/aarambh-studio-math-formulas-guide.md](docs/aarambh-studio-math-formulas-guide.md) | Mathematical foundations and worked examples |
@@ -241,6 +249,8 @@ CUDA checks require a CUDA-capable environment and are intentionally opt-in.
 | [docs/phase36_document.md](docs/phase36_document.md) | PDF/page ingestion, layout tuning, inference, and DocVQA ANLS evaluation |
 | [docs/phase37_agent.md](docs/phase37_agent.md) | Tool-chain protocol, safety, context policy, SFT, and response-path evaluation |
 | [docs/phase38_forgetting.md](docs/phase38_forgetting.md) | Capability curves, routing drift, training/self-learning hooks, and Manas JSONL |
+| [docs/phase41_mla.md](docs/phase41_mla.md) | MLA configuration, retrofit, and KV-cache report |
+| [docs/phase42_audio.md](docs/phase42_audio.md) | Audio encoder, mel-spectrogram, fusion, tuning, inference, and audio-QA evaluation |
 | [RELEASE.md](RELEASE.md) | Source-release process and artifact policy |
 | [CHANGELOG.md](CHANGELOG.md) | Versioned implementation history |
 
@@ -249,9 +259,9 @@ CUDA checks require a CUDA-capable environment and are intentionally opt-in.
 - No pretrained model, GGUF, adapter, or binary ships — you train your own.
 - MoE uses dense masked dispatch (not sparse grouped). Multi-GPU is single-node.
 - Tool chains are generated and orchestrated but never executed by the runtime.
-- Video is visual-only H.264 MP4; audio is unsupported.
+- Video is visual-only H.264 MP4; audio is WAV PCM only (no MP3/FLAC/Ogg).
 - Documents are pixel-based (no OCR/table parser).
-- The server is local/single-model; vision and self-learning are CLI workflows.
+- The server is local/single-model; vision, audio, and self-learning are CLI workflows.
 
 Full exclusions in the [versioned roadmaps](#documentation).
 
diff --git a/ROADMAP_V4.md b/ROADMAP_V4.md
index 1c34d39..d81084d 100644
--- a/ROADMAP_V4.md
+++ b/ROADMAP_V4.md
@@ -207,7 +207,7 @@ expressiveness.
 
 **`aarambh-studio-nn`:**
 ```
-[ ] src/mla.rs
+[x] src/mla.rs
       down_proj: d_model -> latent_dim (e.g. 512), producing c_kv per
       token — this is the only thing cached, not per-head K/V
       per-head up-projection: c_kv -> K^(h), V^(h) via per-head learned
@@ -221,7 +221,7 @@ expressiveness.
       MlaCache — stores {c_kv latent, rope-half cache} per token,
       replacing the full per-head KV cache for MLA layers specifically
 
-[ ] src/attention.rs
+[x] src/attention.rs
       AttentionKind enum extended: Full | GatedDeltaNet | LatentMLA
       HybridAttentionSchedule extended to a 3-way per-layer assignment
       Full and GatedDeltaNet layers completely unchanged from v1/v3
@@ -229,37 +229,37 @@ expressiveness.
 
 **`aarambh-studio-model`:**
 ```
-[ ] Model config's attention_schedule accepts LatentMLA entries
-[ ] Backward compatible: a schedule with zero LatentMLA entries
+[x] Model config's attention_schedule accepts LatentMLA entries
+[x] Backward compatible: a schedule with zero LatentMLA entries
     reproduces exact v3.0.0 behaviour
-[ ] New hybrid variants of Medium/Large configs mixing all three kinds
+[x] New hybrid variants of Medium/Large configs mixing all three kinds
       configs/medium_hybrid_mla.toml
       configs/large_hybrid_mla.toml
 ```
 
 **`aarambh-studio-train`:**
 ```
-[ ] Continued-pretraining retrofit recipe, same pattern as v3 §29:
+[x] Continued-pretraining retrofit recipe, same pattern as v3 §29:
     load an existing v3 checkpoint, reinitialise scheduled layers as
     LatentMLA, keep everything else loaded as-is, train at reduced
     learning rate
-[ ] Retrofit validation against the eval harness (v2 §17) before/after,
+[x] Retrofit validation against the eval harness (v2 §17) before/after,
     same tolerance-band discipline as v3 §29
 ```
 
 **`aarambh-studio-weights`:**
 ```
-[ ] Partial-checkpoint loading extended to support MLA-layer weights
+[x] Partial-checkpoint loading extended to support MLA-layer weights
     (down_proj, per-head up-projections, rope-half projections)
     alongside the existing Full/GatedDeltaNet partial-load path
 ```
 
 **`aarambh-studio-inference`:**
 ```
-[ ] KV cache allocation per layer now depends on AttentionKind — MLA
+[x] KV cache allocation per layer now depends on AttentionKind — MLA
     layers allocate {latent_dim + rope_half_dim} per token instead of
     {2 × num_kv_heads × head_dim} — measurably smaller at long context
-[ ] Memory report tooling: `aarambh-studio eval --kv-cache-report` prints
+[x] Memory report tooling: `aarambh-studio eval --kv-cache-report` prints
     bytes/token per attention kind in the active schedule
 ```
 
@@ -315,6 +315,18 @@ git tag v4.0.0-alpha.1
 
 **Duration:** 14–18 days | **Hardware:** Kaggle (free quota)
 
+> **Status: Implemented in v4.0.0-alpha.2.** The new `aarambh-studio-audio`
+> crate (frozen `FrozenAudioEncoder`, pure-Rust WAV decode + mel-spectrogram,
+> trainable `AudioProjector`, `interleave_audio_tokens`, `AudioQaExample`
+> JSONL), the `<audio>`/`<audio_end>` tokenizer tokens (IDs 15/16) with
+> `validate_audio_special_tokens` / `upgraded_for_audio`, the
+> `convert --upgrade-audio-vocab` migration, the `[vision.audio]` config block,
+> the `finetune audio-dora`/`audio-qdora` two-stage trainer, the `infer --audio`
+> flag, the `audio-qa` eval task, the smoke/fixture/data-prep scripts, and the
+> full test suite (frozen-encoder gradient isolation, projector-only stage,
+> fusion length, thinking composability) are all in place. See
+> [docs/phase42_audio.md](docs/phase42_audio.md).
+
 ### Goal
 A frozen, pretrained audio encoder plus a trainable projector gives the
 model the ability to hear and reason about audio clips — speech and
@@ -326,52 +338,52 @@ rather than reinvented.
 
 **`aarambh-studio-audio`** *(new crate, Layer 3)*:
 ```
-[ ] src/lib.rs
-[ ] src/encoder.rs
+[x] src/lib.rs
+[x] src/encoder.rs
       FrozenAudioEncoder — a small (~40–90M param), permissively-
       licensed, pretrained speech/audio transformer encoder, loaded as
       SafeTensors through candle-core, same loading path
       aarambh-studio-weights already uses (identical policy to v2 §24's
       CLIP loading — no PyTorch bindings, no ONNX, no Python FFI)
-[ ] src/preprocess.rs
+[x] src/preprocess.rs
       Mel-spectrogram extraction from raw audio, using a pure-Rust or
       permissively-licensed system-library audio decode path — same
       dependency discipline v3 §35 established for video container
       decode: no Python-based audio ML tooling, local decode only
-[ ] src/projector.rs
+[x] src/projector.rs
       Projector MLP: audio_d_model -> hidden -> llm_d_model, trainable,
       mirrors vision's projector.rs exactly in structure
-[ ] src/fusion.rs
+[x] src/fusion.rs
       interleave_audio_tokens() — generalises v2 §24's
       interleave_image_tokens() into a shared modal-token-splicing
       pattern, spliced at the <audio> special token position
-[ ] src/instruct_data.rs
+[x] src/instruct_data.rs
       AudioQaExample, JSONL schema, mirrors vision's instruct_data.rs
 ```
 
 **`aarambh-studio-tokenizer`:**
 ```
-[ ] <audio> / <audio_end> reserved special token strings, IDs,
+[x] <audio> / <audio_end> reserved special token strings, IDs,
     validation — same pattern as v2's <image>/<image_end> and v3's
     <video>/<document> tokens
 ```
 
 **`aarambh-studio-finetune`:**
 ```
-[ ] vlm_dora.rs extended to accept audio-token-prefixed sequences —
+[x] vlm_dora.rs extended to accept audio-token-prefixed sequences —
     same DoRA-adapted-LLM + frozen-encoder two-stage recipe as v2 §25,
     substituting audio for image
 ```
 
 **`aarambh-studio-eval`:**
 ```
-[ ] tasks/audio_qa_subset.rs — free, public audio-QA benchmark subset,
+[x] tasks/audio_qa_subset.rs — free, public audio-QA benchmark subset,
     implements the shared EvalTask trait (v2 §22)
 ```
 
 **`aarambh-studio-inference`:**
 ```
-[ ] --audio CLI flag on infer, parallel to --image (v2) and
+[x] --audio CLI flag on infer, parallel to --image (v2) and
     --video/--document (v3)
 ```
 
diff --git a/aarambh-studio/Cargo.toml b/aarambh-studio/Cargo.toml
index 9035b81..ef57b1d 100644
--- a/aarambh-studio/Cargo.toml
+++ b/aarambh-studio/Cargo.toml
@@ -9,6 +9,7 @@ rust-version.workspace = true
 default = []
 cuda = [
     "aarambh-studio-agent/cuda",
+    "aarambh-studio-audio/cuda",
     "aarambh-studio-core/cuda",
     "aarambh-studio-data/cuda",
     "aarambh-studio-distill/cuda",
@@ -28,6 +29,7 @@ cuda = [
 
 [dependencies]
 aarambh-studio-agent     = { path = "../crates/aarambh-studio-agent" }
+aarambh-studio-audio     = { path = "../crates/aarambh-studio-audio" }
 aarambh-studio-core      = { path = "../crates/aarambh-studio-core" }
 aarambh-studio-data      = { path = "../crates/aarambh-studio-data" }
 aarambh-studio-distill   = { path = "../crates/aarambh-studio-distill" }
diff --git a/aarambh-studio/src/cmd/convert.rs b/aarambh-studio/src/cmd/convert.rs
index 050e2da..5e906ce 100644
--- a/aarambh-studio/src/cmd/convert.rs
+++ b/aarambh-studio/src/cmd/convert.rs
@@ -33,6 +33,13 @@ pub struct ConvertArgs {
         conflicts_with = "upgrade_video_vocab"
     )]
     pub upgrade_document_vocab: bool,
+    #[arg(
+        long,
+        requires = "tokenizer",
+        requires = "output_tokenizer",
+        conflicts_with_all = ["upgrade_video_vocab", "upgrade_document_vocab"]
+    )]
+    pub upgrade_audio_vocab: bool,
     #[arg(long)]
     pub tokenizer: Option<PathBuf>,
     #[arg(long)]
@@ -132,6 +139,46 @@ pub fn run(args: ConvertArgs) -> anyhow::Result<()> {
         return Ok(());
     }
 
+    if args.upgrade_audio_vocab {
+        if args.gguf {
+            return Err(anyhow::anyhow!(
+                "--upgrade-audio-vocab requires SafeTensors input; migrate first, then quantise the migrated checkpoint"
+            ));
+        }
+        let tokenizer_path = args.tokenizer.as_ref().expect("required by clap");
+        let output_tokenizer = args.output_tokenizer.as_ref().expect("required by clap");
+        let tokenizer = BpeTokenizer::from_pretrained(tokenizer_path)?;
+        if tokenizer.validate_audio_special_tokens().is_ok() {
+            return Err(anyhow::anyhow!(
+                "tokenizer {} already contains the Phase 42 audio vocabulary",
+                tokenizer_path.display()
+            ));
+        }
+        tokenizer.validate_document_special_tokens()?;
+        let old_vocab_size = tokenizer.vocab_size();
+        let upgraded = tokenizer.upgraded_for_audio()?;
+        write_parent_dir(output_tokenizer)?;
+        let report = expand_safetensors_vocabulary(
+            &args.input,
+            &args.output,
+            old_vocab_size,
+            &VocabularyExpansion {
+                insertion_id: aarambh_studio_tokenizer::AUDIO_ID as usize,
+                source_ids: vec![IMAGE_ID as usize, IMAGE_END_ID as usize],
+            },
+        )?;
+        upgraded.save_pretrained(output_tokenizer)?;
+        eprintln!(
+            "upgraded audio vocabulary {} -> {} rows across {} tensors; model={} tokenizer={}",
+            report.old_vocab_size,
+            report.new_vocab_size,
+            report.expanded_tensors,
+            args.output.display(),
+            output_tokenizer.display()
+        );
+        return Ok(());
+    }
+
     if args.gguf {
         let format = GgufFormat::from_name(&args.format)?;
         let model = load_any_model(&args.input, &run_config.model, &device)?;
diff --git a/aarambh-studio/src/cmd/finetune.rs b/aarambh-studio/src/cmd/finetune.rs
index 7c2432f..0e94100 100644
--- a/aarambh-studio/src/cmd/finetune.rs
+++ b/aarambh-studio/src/cmd/finetune.rs
@@ -2,11 +2,12 @@ use std::path::PathBuf;
 use std::str::FromStr;
 
 use aarambh_studio_finetune::{
-    AdapterMethod, DocumentVlmDoraRunConfig, DpoConfig, DpoRunConfig, GrpoConfig, GrpoRunConfig,
-    GrpoThinkingMode, LoraConfig, SftRunConfig, VerifierKind, VideoVlmDoraRunConfig,
-    VlmDoraRunConfig, merge_adapter_from_paths, run_document_vlm_dora_from_config,
-    run_dora_from_config, run_dpo_from_config, run_grpo_from_config, run_sft_from_config,
-    run_tool_sft_from_config, run_video_vlm_dora_from_config, run_vlm_dora_from_config,
+    AdapterMethod, AudioVlmDoraRunConfig, DocumentVlmDoraRunConfig, DpoConfig, DpoRunConfig,
+    GrpoConfig, GrpoRunConfig, GrpoThinkingMode, LoraConfig, SftRunConfig, VerifierKind,
+    VideoVlmDoraRunConfig, VlmDoraRunConfig, merge_adapter_from_paths,
+    run_audio_vlm_dora_from_config, run_document_vlm_dora_from_config, run_dora_from_config,
+    run_dpo_from_config, run_grpo_from_config, run_sft_from_config, run_tool_sft_from_config,
+    run_video_vlm_dora_from_config, run_vlm_dora_from_config,
 };
 use aarambh_studio_train::TrainingRunConfig;
 use aarambh_studio_vision::{FrameSamplingStrategy, LayoutEncodingKind, TemporalEncodingKind};
@@ -32,6 +33,8 @@ pub enum FinetuneCommand {
     VideoQdora(VlmFinetuneArgs),
     DocumentDora(VlmFinetuneArgs),
     DocumentQdora(VlmFinetuneArgs),
+    AudioDora(VlmFinetuneArgs),
+    AudioQdora(VlmFinetuneArgs),
     Grpo(GrpoArgs),
     Dpo(DpoArgs),
     Qdpo(DpoArgs),
@@ -285,6 +288,8 @@ pub fn run(args: FinetuneArgs) -> anyhow::Result<()> {
         FinetuneCommand::VideoQdora(args) => run_video_vlm_dora_finetune(args, true),
         FinetuneCommand::DocumentDora(args) => run_document_vlm_dora_finetune(args, false),
         FinetuneCommand::DocumentQdora(args) => run_document_vlm_dora_finetune(args, true),
+        FinetuneCommand::AudioDora(args) => run_audio_vlm_dora_finetune(args, false),
+        FinetuneCommand::AudioQdora(args) => run_audio_vlm_dora_finetune(args, true),
         FinetuneCommand::Grpo(args) => run_grpo(args),
         FinetuneCommand::Dpo(args) => run_dpo(args, false),
         FinetuneCommand::Qdpo(args) => run_dpo(args, true),
@@ -386,28 +391,35 @@ fn run_dora_finetune(args: FinetuneRunArgs, qdora: bool) -> anyhow::Result<()> {
 }
 
 fn run_vlm_dora_finetune(args: VlmFinetuneArgs, qdora: bool) -> anyhow::Result<()> {
-    let config = build_vlm_dora_config(args, qdora, false, false)?;
+    let config = build_vlm_dora_config(args, qdora, false, false, false)?;
     run_vlm_dora_from_config(config)?;
     Ok(())
 }
 
 fn run_video_vlm_dora_finetune(args: VlmFinetuneArgs, qdora: bool) -> anyhow::Result<()> {
-    let config = build_vlm_dora_config(args, qdora, true, false)?;
+    let config = build_vlm_dora_config(args, qdora, true, false, false)?;
     run_video_vlm_dora_from_config(VideoVlmDoraRunConfig { vlm: config })?;
     Ok(())
 }
 
 fn run_document_vlm_dora_finetune(args: VlmFinetuneArgs, qdora: bool) -> anyhow::Result<()> {
-    let config = build_vlm_dora_config(args, qdora, false, true)?;
+    let config = build_vlm_dora_config(args, qdora, false, true, false)?;
     run_document_vlm_dora_from_config(DocumentVlmDoraRunConfig { vlm: config })?;
     Ok(())
 }
 
+fn run_audio_vlm_dora_finetune(args: VlmFinetuneArgs, qdora: bool) -> anyhow::Result<()> {
+    let config = build_vlm_dora_config(args, qdora, false, false, true)?;
+    run_audio_vlm_dora_from_config(AudioVlmDoraRunConfig { vlm: config })?;
+    Ok(())
+}
+
 fn build_vlm_dora_config(
     args: VlmFinetuneArgs,
     qdora: bool,
     video_mode: bool,
     document_mode: bool,
+    audio_mode: bool,
 ) -> anyhow::Result<VlmDoraRunConfig> {
     let run_config = TrainingRunConfig::from_toml(&args.config)?;
     let device = run_config.device()?;
@@ -475,6 +487,12 @@ fn build_vlm_dora_config(
         }
         document.validate()?;
     }
+    if audio_mode {
+        let audio = vision.audio.as_mut().ok_or_else(|| {
+            anyhow::anyhow!("audio VLM fine-tuning requires a [vision.audio] config block")
+        })?;
+        audio.validate()?;
+    }
     let projector_path = vision.projector_path.clone().ok_or_else(|| {
         anyhow::anyhow!("VLM fine-tuning requires --projector or vision.projector_path")
     })?;
diff --git a/aarambh-studio/src/cmd/infer.rs b/aarambh-studio/src/cmd/infer.rs
index 8c45d5e..5faf8fc 100644
--- a/aarambh-studio/src/cmd/infer.rs
+++ b/aarambh-studio/src/cmd/infer.rs
@@ -3,6 +3,10 @@ use std::io::{self, Write};
 use std::path::{Path, PathBuf};
 use std::time::{Duration, Instant};
 
+use aarambh_studio_audio::{
+    AudioEncoderConfig, AudioModel, AudioPreprocessor, AudioProjector, AudioProjectorConfig,
+    FrozenAudioEncoder, interleave_audio_tokens,
+};
 use aarambh_studio_core::{AarambhError, TokenizerLike};
 use aarambh_studio_finetune::{Verifier, VerifierKind};
 use aarambh_studio_inference::{
@@ -19,9 +23,9 @@ use aarambh_studio_selflearn::{
     VisionCache, VisionVerifierKind, require_vision_hardware,
 };
 use aarambh_studio_tokenizer::{
-    ASSISTANT, BpeTokenizer, DOCUMENT, DOCUMENT_END, DOCUMENT_ID, FRAME_SEP, FRAME_SEP_ID, IMAGE,
-    IMAGE_END, IMAGE_ID, PAGE_SEP, PAGE_SEP_ID, THINK_END_ID, THINK_START_ID, USER, VIDEO,
-    VIDEO_END, VIDEO_ID,
+    ASSISTANT, AUDIO, AUDIO_END, AUDIO_ID, BpeTokenizer, DOCUMENT, DOCUMENT_END, DOCUMENT_ID,
+    FRAME_SEP, FRAME_SEP_ID, IMAGE, IMAGE_END, IMAGE_ID, PAGE_SEP, PAGE_SEP_ID, THINK_END_ID,
+    THINK_START_ID, USER, VIDEO, VIDEO_END, VIDEO_ID,
 };
 use aarambh_studio_train::TrainingRunConfig;
 use aarambh_studio_vision::{
@@ -56,6 +60,8 @@ pub struct InferArgs {
     pub video: Option<PathBuf>,
     #[arg(long, conflicts_with_all = ["image", "video"])]
     pub document: Option<PathBuf>,
+    #[arg(long, conflicts_with_all = ["image", "video", "document"])]
+    pub audio: Option<PathBuf>,
     #[arg(long, requires = "document")]
     pub pages: Option<String>,
     #[arg(long, requires = "document")]
@@ -204,9 +210,9 @@ pub fn run(args: InferArgs) -> anyhow::Result<()> {
         );
     }
     if self_learn_mode.is_enabled() {
-        if args.video.is_some() || args.document.is_some() {
+        if args.video.is_some() || args.document.is_some() || args.audio.is_some() {
             return Err(AarambhError::Unsupported(
-                "video/document self-learning is not supported; use text/image self-learning or disable --self-learn"
+                "video/document/audio self-learning is not supported; use text/image self-learning or disable --self-learn"
                     .into(),
             )
             .into());
@@ -293,6 +299,20 @@ pub fn run(args: InferArgs) -> anyhow::Result<()> {
             tokenizer_for_view,
         );
     }
+    if let Some(audio_path) = args.audio.clone() {
+        return run_audio_infer(
+            &args,
+            &run_config,
+            engine,
+            audio_path,
+            dtype,
+            config,
+            prompt,
+            safety_mode,
+            thinking_mode,
+            tokenizer_for_view,
+        );
+    }
     if let Some(policy) = SafetyPolicy::for_mode(safety_mode)
         .map(|policy| policy.with_audit_path(&args.safety_audit_log))
     {
@@ -549,9 +569,13 @@ fn validate_speculative_args(
         }
         return Ok(());
     }
-    if args.image.is_some() || args.video.is_some() || args.document.is_some() {
+    if args.image.is_some()
+        || args.video.is_some()
+        || args.document.is_some()
+        || args.audio.is_some()
+    {
         return Err(AarambhError::Unsupported(
-            "speculative decoding supports text inference only; --image/--video/--document are not supported"
+            "speculative decoding supports text inference only; --image/--video/--document/--audio are not supported"
                 .into(),
         )
         .into());
@@ -625,7 +649,11 @@ fn load_tool_calling_config(
         }
         return Ok(None);
     };
-    if args.image.is_some() || args.video.is_some() || args.document.is_some() {
+    if args.image.is_some()
+        || args.video.is_some()
+        || args.document.is_some()
+        || args.audio.is_some()
+    {
         return Err(AarambhError::Unsupported(
             "Phase 26 tool calling supports text inference only; multimodal inputs are not supported"
                 .into(),
@@ -1359,6 +1387,206 @@ pub(super) fn project_document_tokens(
     Ok((projected, pages.len()))
 }
 
+pub(super) struct AudioRuntime {
+    model: AudioModel,
+    preprocess: AudioPreprocessor,
+}
+
+pub(super) fn load_audio_runtime(
+    run_config: &TrainingRunConfig,
+    device: &candle_core::Device,
+    dtype: candle_core::DType,
+) -> anyhow::Result<AudioRuntime> {
+    let vision = run_config
+        .vision
+        .as_ref()
+        .ok_or_else(|| anyhow::anyhow!("--audio requires a [vision] config block"))?;
+    let audio = vision
+        .audio
+        .as_ref()
+        .ok_or_else(|| anyhow::anyhow!("--audio requires a [vision.audio] config block"))?;
+    audio.validate()?;
+    let encoder_config = AudioEncoderConfig::from_json(&audio.encoder_config_path)?;
+    let encoder = FrozenAudioEncoder::load_pretrained(
+        &audio.encoder_weights_path,
+        encoder_config.clone(),
+        device,
+        dtype,
+    )?;
+    let projector_path = match &vision.projector_path {
+        Some(path) => path.clone(),
+        None => default_model_path(&run_config.train.checkpoint_dir)?,
+    };
+    let projector_config = AudioProjectorConfig {
+        audio_d_model: encoder_config.audio_d_model,
+        llm_d_model: run_config.model.hidden_dim,
+        hidden_mult: vision.projector_hidden_mult,
+    };
+    let projector =
+        AudioProjector::load_safetensors(&projector_path, projector_config, device, dtype)?;
+    let preprocess = AudioPreprocessor::new(audio.mel.clone())?;
+    Ok(AudioRuntime {
+        model: AudioModel::new(encoder, projector),
+        preprocess,
+    })
+}
+
+fn ensure_audio_prompt(prompt: &str) -> String {
+    if prompt.contains(AUDIO) {
+        prompt.to_string()
+    } else {
+        format!("{AUDIO}{AUDIO_END}\n{prompt}")
+    }
+}
+
+fn build_audio_prompt_embeddings(
+    engine: &InferenceEngine,
+    runtime: &AudioRuntime,
+    audio_path: &Path,
+    prompt: &str,
+) -> aarambh_studio_core::Result<Tensor> {
+    engine.tokenizer().validate_audio_special_tokens()?;
+    let mut prompt_ids = engine.tokenizer().encode(prompt)?;
+    if prompt_ids.is_empty() {
+        if let Some(bos) = engine.tokenizer().bos_token_id() {
+            prompt_ids.push(bos);
+        } else {
+            return Err(AarambhError::Config(
+                "prompt produced no tokens and tokenizer has no BOS token".into(),
+            ));
+        }
+    }
+    let text = Tensor::from_vec(prompt_ids.clone(), (1, prompt_ids.len()), engine.device())?;
+    let text_embeddings = engine.model().embed_tokens(&text)?;
+    let audio_tokens = project_audio_tokens(runtime, audio_path, engine.device())?;
+    interleave_audio_tokens(&prompt_ids, &text_embeddings, &audio_tokens, AUDIO_ID)
+}
+
+pub(super) fn project_audio_tokens(
+    runtime: &AudioRuntime,
+    audio_path: &Path,
+    device: &candle_core::Device,
+) -> aarambh_studio_core::Result<Tensor> {
+    let spectrogram = runtime
+        .preprocess
+        .preprocess_path(audio_path, device)?
+        .unsqueeze(0)?;
+    runtime.model.forward(&spectrogram)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn run_audio_infer(
+    args: &InferArgs,
+    run_config: &TrainingRunConfig,
+    mut engine: InferenceEngine,
+    audio_path: PathBuf,
+    dtype: candle_core::DType,
+    config: GenerationConfig,
+    prompt: String,
+    safety_mode: SafetyMode,
+    thinking_mode: ThinkingMode,
+    tokenizer_for_view: BpeTokenizer,
+) -> anyhow::Result<()> {
+    let runtime = load_audio_runtime(run_config, engine.device(), dtype)?;
+    let prompt = ensure_audio_prompt(&prompt);
+
+    if let Some(policy) = SafetyPolicy::for_mode(safety_mode)
+        .map(|policy| policy.with_audit_path(&args.safety_audit_log))
+    {
+        let adapter = AudioSafetyAdapter {
+            engine,
+            runtime,
+            audio_path,
+        };
+        let mut guard = SafetyGuard::new(adapter, policy);
+        let mut stream_state = StreamState::default();
+        let response = if args.stream {
+            guard.generate_streaming_with_callback(&prompt, config, print_safe_stream_event)?
+        } else {
+            guard.generate_with_callback(&prompt, config, |step| {
+                if args.predict_view {
+                    print!(
+                        "{}",
+                        predict_view::render(
+                            step,
+                            &tokenizer_for_view,
+                            args.temperature,
+                            args.top_p,
+                        )
+                    );
+                    io::stdout().flush()?;
+                }
+                Ok(())
+            })?
+        };
+        print_safe_response(&response, thinking_mode, args.stream, &mut stream_state)?;
+        io::stdout().flush()?;
+        if let Some(output) = &response.output {
+            eprintln!("finish_reason={:?}", output.finish_reason);
+        } else {
+            eprintln!("finish_reason=SafetyBlocked");
+        }
+        return Ok(());
+    }
+
+    let embeddings = build_audio_prompt_embeddings(&engine, &runtime, &audio_path, &prompt)?;
+    let mut stream_state = StreamState::default();
+    let output = engine.generate_with_embeddings_callback(&embeddings, config, |step| {
+        if args.predict_view {
+            print!(
+                "{}",
+                predict_view::render(step, &tokenizer_for_view, args.temperature, args.top_p)
+            );
+        }
+        if args.stream {
+            stream_step(step, thinking_mode, &mut stream_state)?;
+        }
+        if args.predict_view || args.stream {
+            io::stdout().flush()?;
+        }
+        Ok(())
+    })?;
+    if args.stream {
+        finish_stream(&mut stream_state);
+    } else {
+        print_generation_output(&output, thinking_mode)?;
+    }
+    io::stdout().flush()?;
+    eprintln!("finish_reason={:?}", output.finish_reason);
+    Ok(())
+}
+
+struct AudioSafetyAdapter {
+    engine: InferenceEngine,
+    runtime: AudioRuntime,
+    audio_path: PathBuf,
+}
+
+impl SafetyGenerator for AudioSafetyAdapter {
+    fn generate(
+        &mut self,
+        prompt: &str,
+        config: GenerationConfig,
+    ) -> aarambh_studio_core::Result<GenerationOutput> {
+        self.generate_with_callback(prompt, config, |_| Ok(()))
+    }
+
+    fn generate_with_callback<F>(
+        &mut self,
+        prompt: &str,
+        config: GenerationConfig,
+        on_step: F,
+    ) -> aarambh_studio_core::Result<GenerationOutput>
+    where
+        F: FnMut(&GenerationStep) -> aarambh_studio_core::Result<()>,
+    {
+        let embeddings =
+            build_audio_prompt_embeddings(&self.engine, &self.runtime, &self.audio_path, prompt)?;
+        self.engine
+            .generate_with_embeddings_callback(&embeddings, config, on_step)
+    }
+}
+
 fn build_video_prompt_embeddings(
     engine: &InferenceEngine,
     runtime: &VisionRuntime,
@@ -2120,6 +2348,7 @@ mod tests {
             image: None,
             video: None,
             document: None,
+            audio: None,
             pages: None,
             document_dpi: None,
             max_document_pages: None,
diff --git a/aarambh-studio/src/cmd/selflearn.rs b/aarambh-studio/src/cmd/selflearn.rs
index f44d520..eaa3ff1 100644
--- a/aarambh-studio/src/cmd/selflearn.rs
+++ b/aarambh-studio/src/cmd/selflearn.rs
@@ -183,6 +183,7 @@ fn run_start(args: StartArgs) -> anyhow::Result<()> {
         image: args.image,
         video: None,
         document: None,
+        audio: None,
         pages: None,
         document_dpi: None,
         max_document_pages: None,
diff --git a/configs/audio_qa_smoke.toml b/configs/audio_qa_smoke.toml
new file mode 100644
index 0000000..c6706af
--- /dev/null
+++ b/configs/audio_qa_smoke.toml
@@ -0,0 +1,67 @@
+tokenizer_path = "checkpoints/audio_smoke/tokenizer.json"
+vocab_size = 8008
+validation_split = 0.0
+shuffle = false
+resume = false
+device = "cpu"
+dtype = "f32"
+
+[model]
+vocab_size = 8008
+hidden_dim = 384
+ffn_dim = 1024
+n_layers = 8
+n_heads = 6
+n_kv_heads = 2
+max_seq_len = 512
+rope_theta = 10000.0
+norm_eps = 0.00001
+tie_embeddings = true
+
+[train]
+lr = 0.0005
+batch_size = 1
+grad_accum_steps = 1
+max_epochs = 1
+max_steps = 2
+warmup_steps = 1
+min_lr_ratio = 0.1
+weight_decay = 0.01
+beta1 = 0.9
+beta2 = 0.95
+epsilon = 0.00000001
+clip_grad_norm = 1.0
+save_every_n_steps = 0
+log_every_n_steps = 1
+eval_steps = 0
+seed = 42
+checkpoint_dir = "adapters/audio_qa_smoke"
+
+[vision]
+mode = "vlm_instruction"
+base_model_path = "checkpoints/audio_smoke/model.safetensors"
+clip_config_path = "data/vision_smoke/clip_tiny_config.json"
+clip_weights_path = "data/vision_smoke/clip_tiny.safetensors"
+projector_path = "data/audio_smoke/projector_init.safetensors"
+image_root = "data/vision_smoke/images"
+projector_hidden_mult = 1
+max_caption_tokens = 32
+max_samples = 4
+
+[vision.audio]
+audio_root = "data/audio_smoke/audio"
+encoder_config_path = "data/audio_smoke/audio_encoder_tiny_config.json"
+encoder_weights_path = "data/audio_smoke/audio_encoder_tiny.safetensors"
+encoder_batch_size = 2
+feature_cache_entries = 4
+
+[vision.audio.mel]
+sample_rate = 16000
+n_fft = 256
+hop_length = 128
+n_mels = 16
+fmin = 0.0
+fmax = 8000.0
+max_audio_seconds = 0.136
+power = 2.0
+log_eps = 0.0000000001
diff --git a/configs/audio_qa_smoke_infer.toml b/configs/audio_qa_smoke_infer.toml
new file mode 100644
index 0000000..720d071
--- /dev/null
+++ b/configs/audio_qa_smoke_infer.toml
@@ -0,0 +1,51 @@
+tokenizer_path = "checkpoints/audio_smoke/tokenizer.json"
+vocab_size = 8008
+validation_split = 0.0
+shuffle = false
+resume = false
+device = "cpu"
+dtype = "f32"
+
+[model]
+vocab_size = 8008
+hidden_dim = 384
+ffn_dim = 1024
+n_layers = 8
+n_heads = 6
+n_kv_heads = 2
+max_seq_len = 512
+rope_theta = 10000.0
+norm_eps = 0.00001
+tie_embeddings = true
+
+[train]
+checkpoint_dir = "adapters/audio_qa_smoke"
+
+[vision]
+mode = "vlm_instruction"
+base_model_path = "checkpoints/audio_smoke/model.safetensors"
+clip_config_path = "data/vision_smoke/clip_tiny_config.json"
+clip_weights_path = "data/vision_smoke/clip_tiny.safetensors"
+projector_path = "adapters/audio_qa_smoke/projector.safetensors"
+image_root = "data/vision_smoke/images"
+projector_hidden_mult = 1
+max_caption_tokens = 32
+max_samples = 4
+
+[vision.audio]
+audio_root = "data/audio_smoke/audio"
+encoder_config_path = "data/audio_smoke/audio_encoder_tiny_config.json"
+encoder_weights_path = "data/audio_smoke/audio_encoder_tiny.safetensors"
+encoder_batch_size = 2
+feature_cache_entries = 4
+
+[vision.audio.mel]
+sample_rate = 16000
+n_fft = 256
+hop_length = 128
+n_mels = 16
+fmin = 0.0
+fmax = 8000.0
+max_audio_seconds = 0.136
+power = 2.0
+log_eps = 0.0000000001
diff --git a/configs/audio_tiny_infer.toml b/configs/audio_tiny_infer.toml
new file mode 100644
index 0000000..b1f81b5
--- /dev/null
+++ b/configs/audio_tiny_infer.toml
@@ -0,0 +1,51 @@
+tokenizer_path = "checkpoints/audio_smoke/tokenizer.json"
+vocab_size = 519
+validation_split = 0.0
+shuffle = false
+resume = false
+device = "cpu"
+dtype = "f32"
+
+[model]
+vocab_size = 519
+hidden_dim = 128
+ffn_dim = 256
+n_layers = 2
+n_heads = 2
+n_kv_heads = 1
+max_seq_len = 64
+rope_theta = 10000.0
+norm_eps = 0.00001
+tie_embeddings = true
+
+[train]
+checkpoint_dir = "checkpoints/audio_smoke"
+
+[vision]
+mode = "vlm_instruction"
+base_model_path = "checkpoints/audio_smoke/model.safetensors"
+clip_config_path = "data/vision_smoke/clip_tiny_config.json"
+clip_weights_path = "data/vision_smoke/clip_tiny.safetensors"
+projector_path = "data/audio_smoke/projector_tiny.safetensors"
+image_root = "data/vision_smoke/images"
+projector_hidden_mult = 1
+max_caption_tokens = 32
+max_samples = 4
+
+[vision.audio]
+audio_root = "data/audio_smoke/audio"
+encoder_config_path = "data/audio_smoke/audio_encoder_tiny_config.json"
+encoder_weights_path = "data/audio_smoke/audio_encoder_tiny.safetensors"
+encoder_batch_size = 2
+feature_cache_entries = 4
+
+[vision.audio.mel]
+sample_rate = 16000
+n_fft = 256
+hop_length = 128
+n_mels = 16
+fmin = 0.0
+fmax = 8000.0
+max_audio_seconds = 0.136
+power = 2.0
+log_eps = 0.0000000001
diff --git a/crates/aarambh-studio-audio/Cargo.toml b/crates/aarambh-studio-audio/Cargo.toml
new file mode 100644
index 0000000..d702bb0
--- /dev/null
+++ b/crates/aarambh-studio-audio/Cargo.toml
@@ -0,0 +1,21 @@
+[package]
+name = "aarambh-studio-audio"
+version.workspace = true
+publish = false
+edition.workspace = true
+rust-version.workspace = true
+
+[features]
+default = []
+cuda = [
+    "aarambh-studio-core/cuda",
+    "candle-core/cuda",
+    "candle-nn/cuda",
+]
+
+[dependencies]
+aarambh-studio-core = { path = "../aarambh-studio-core" }
+candle-core     = { workspace = true }
+candle-nn       = { workspace = true }
+serde           = { workspace = true }
+serde_json      = { workspace = true }
diff --git a/crates/aarambh-studio-audio/src/encoder.rs b/crates/aarambh-studio-audio/src/encoder.rs
new file mode 100644
index 0000000..35c0c3a
--- /dev/null
+++ b/crates/aarambh-studio-audio/src/encoder.rs
@@ -0,0 +1,518 @@
+//! Frozen, pretrained audio spectrogram transformer encoder.
+//!
+//! Mirrors the CLIP-style vision encoder (`aarambh_studio_vision::ClipVisionEncoder`)
+//! in structure: a frozen, pretrained transformer that converts raw input into a
+//! grid of embeddings. The only difference is the input domain — a log-mel
+//! spectrogram `[batch, n_mels, time_frames]` is treated as a single-channel
+//! image, split into `(patch_mel, patch_time)` patches, linearly projected to
+//! `audio_d_model`, and run through standard pre-norm transformer blocks.
+//!
+//! Weights are loaded as SafeTensors through `candle_core`, exactly the same
+//! loading path every other encoder in the project uses (v2 §24's CLIP policy):
+//! no PyTorch bindings, no ONNX, no Python FFI.
+
+use std::collections::HashMap;
+use std::path::Path;
+
+use aarambh_studio_core::{AarambhError, Result};
+use candle_core::{D, DType, Device, Tensor};
+use candle_nn::{
+    LayerNorm, Linear, Module, VarBuilder, layer_norm, linear, linear_no_bias, ops::softmax,
+};
+use serde::{Deserialize, Serialize};
+
+/// Configuration for a frozen audio spectrogram transformer.
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[serde(default)]
+pub struct AudioEncoderConfig {
+    /// Number of mel frequency bins in the input spectrogram.
+    pub n_mels: usize,
+    /// Maximum number of short-time frames in the input spectrogram.
+    pub max_frames: usize,
+    /// Patch height in mel bins.
+    pub patch_mel: usize,
+    /// Patch width in time frames.
+    pub patch_time: usize,
+    /// Audio transformer hidden width.
+    pub audio_d_model: usize,
+    /// Number of transformer encoder blocks.
+    pub audio_layers: usize,
+    /// Number of attention heads.
+    pub audio_heads: usize,
+    /// MLP hidden width inside each transformer block.
+    pub mlp_dim: usize,
+    /// LayerNorm epsilon.
+    pub norm_eps: f64,
+}
+
+impl Default for AudioEncoderConfig {
+    fn default() -> Self {
+        Self {
+            n_mels: 80,
+            max_frames: 61,
+            patch_mel: 16,
+            patch_time: 16,
+            audio_d_model: 768,
+            audio_layers: 12,
+            audio_heads: 12,
+            mlp_dim: 3072,
+            norm_eps: 1e-5,
+        }
+    }
+}
+
+impl AudioEncoderConfig {
+    /// Load an audio encoder configuration from JSON.
+    pub fn from_json(path: impl AsRef<Path>) -> Result<Self> {
+        let file = std::fs::File::open(path)?;
+        let config = serde_json::from_reader(file)?;
+        Ok(config)
+    }
+
+    /// Validate encoder dimensions and the patch grid.
+    pub fn validate(&self) -> Result<()> {
+        if self.n_mels == 0
+            || self.max_frames == 0
+            || self.patch_mel == 0
+            || self.patch_time == 0
+            || self.audio_d_model == 0
+            || self.audio_layers == 0
+            || self.audio_heads == 0
+            || self.mlp_dim == 0
+        {
+            return Err(AarambhError::Config(
+                "audio encoder dimensions must be non-zero".into(),
+            ));
+        }
+        if !self.n_mels.is_multiple_of(self.patch_mel) {
+            return Err(AarambhError::Config(format!(
+                "n_mels {} must be divisible by patch_mel {}",
+                self.n_mels, self.patch_mel
+            )));
+        }
+        if !self.max_frames.is_multiple_of(self.patch_time) {
+            return Err(AarambhError::Config(format!(
+                "max_frames {} must be divisible by patch_time {}",
+                self.max_frames, self.patch_time
+            )));
+        }
+        if !self.audio_d_model.is_multiple_of(self.audio_heads) {
+            return Err(AarambhError::Config(
+                "audio_d_model must be divisible by audio_heads".into(),
+            ));
+        }
+        Ok(())
+    }
+
+    /// Return the number of patches along the mel axis.
+    pub fn patch_rows(&self) -> usize {
+        self.n_mels / self.patch_mel
+    }
+
+    /// Return the number of patches along the time axis.
+    pub fn patch_cols(&self) -> usize {
+        self.max_frames / self.patch_time
+    }
+
+    /// Return the total number of non-CLS patch tokens.
+    pub fn num_patches(&self) -> usize {
+        self.patch_rows() * self.patch_cols()
+    }
+
+    /// Return the flattened patch width.
+    pub fn patch_dim(&self) -> usize {
+        self.patch_mel * self.patch_time
+    }
+
+    /// Return per-head attention width.
+    pub fn head_dim(&self) -> usize {
+        self.audio_d_model / self.audio_heads
+    }
+}
+
+/// Frozen audio spectrogram transformer encoder.
+#[derive(Debug, Clone)]
+pub struct FrozenAudioEncoder {
+    config: AudioEncoderConfig,
+    patch_embed: Linear,
+    class_embedding: Tensor,
+    position_embedding: Tensor,
+    pre_norm: LayerNorm,
+    blocks: Vec<AudioBlock>,
+    post_norm: LayerNorm,
+}
+
+impl FrozenAudioEncoder {
+    /// Build the encoder from a variable builder.
+    pub fn new(config: AudioEncoderConfig, vb: VarBuilder<'_>) -> Result<Self> {
+        config.validate()?;
+        let patch_embed = linear_no_bias(
+            config.patch_dim(),
+            config.audio_d_model,
+            vb.pp("patch_embed"),
+        )?;
+        let class_embedding = vb.get_with_hints(
+            config.audio_d_model,
+            "class_embedding",
+            candle_nn::Init::Randn {
+                mean: 0.0,
+                stdev: 0.02,
+            },
+        )?;
+        let position_embedding = vb.get_with_hints(
+            (config.num_patches() + 1, config.audio_d_model),
+            "position_embedding",
+            candle_nn::Init::Randn {
+                mean: 0.0,
+                stdev: 0.01,
+            },
+        )?;
+        let pre_norm = layer_norm(config.audio_d_model, config.norm_eps, vb.pp("pre_norm"))?;
+        let post_norm = layer_norm(config.audio_d_model, config.norm_eps, vb.pp("post_norm"))?;
+        let mut blocks = Vec::with_capacity(config.audio_layers);
+        for idx in 0..config.audio_layers {
+            blocks.push(AudioBlock::new(&config, vb.pp("blocks").pp(idx))?);
+        }
+        Ok(Self {
+            config,
+            patch_embed,
+            class_embedding,
+            position_embedding,
+            pre_norm,
+            blocks,
+            post_norm,
+        })
+    }
+
+    /// Load pretrained encoder weights from a SafeTensors checkpoint.
+    pub fn load_pretrained(
+        path: impl AsRef<Path>,
+        config: AudioEncoderConfig,
+        device: &Device,
+        dtype: DType,
+    ) -> Result<Self> {
+        // SAFETY: The checkpoint mapping is read-only and is consumed while the
+        // encoder creates its owned parameter tensors.
+        let vb = unsafe { VarBuilder::from_mmaped_safetensors(&[path.as_ref()], dtype, device)? };
+        Self::new(config, vb)
+    }
+
+    /// Return the encoder configuration.
+    pub fn config(&self) -> &AudioEncoderConfig {
+        &self.config
+    }
+
+    /// Encode `[batch, n_mels, max_frames]` spectrograms into non-CLS patch tokens.
+    pub fn forward(&self, spectrograms: &Tensor) -> Result<Tensor> {
+        let patches = self.patchify(spectrograms)?;
+        let batch = patches.dims()[0];
+        let mut x = self.patch_embed.forward(&patches)?;
+        let cls = self
+            .class_embedding
+            .reshape((1, 1, self.config.audio_d_model))?
+            .broadcast_as((batch, 1, self.config.audio_d_model))?;
+        x = Tensor::cat(&[&cls, &x], 1)?;
+        let pos = self.position_embedding.reshape((
+            1,
+            self.config.num_patches() + 1,
+            self.config.audio_d_model,
+        ))?;
+        x = x.broadcast_add(&pos)?;
+        x = self.pre_norm.forward(&x)?;
+        for block in &self.blocks {
+            x = block.forward(&x)?;
+        }
+        x = self.post_norm.forward(&x)?;
+        Ok(x.narrow(1, 1, self.config.num_patches())?)
+    }
+
+    fn patchify(&self, spectrograms: &Tensor) -> Result<Tensor> {
+        let dims = spectrograms.dims();
+        if dims.len() != 3 {
+            return Err(AarambhError::Shape(format!(
+                "spectrograms must have shape [batch, n_mels, max_frames], got {dims:?}"
+            )));
+        }
+        let (batch, n_mels, max_frames) = (dims[0], dims[1], dims[2]);
+        if n_mels != self.config.n_mels || max_frames != self.config.max_frames {
+            return Err(AarambhError::Shape(format!(
+                "spectrograms must be [batch, {}, {}], got {dims:?}",
+                self.config.n_mels, self.config.max_frames
+            )));
+        }
+        let rows = self.config.patch_rows();
+        let cols = self.config.patch_cols();
+        let patches = spectrograms
+            .unfold(1, self.config.patch_mel, self.config.patch_mel)?
+            .unfold(2, self.config.patch_time, self.config.patch_time)?;
+        let patches = patches.permute((0, 1, 2, 3, 4))?.contiguous()?;
+        Ok(patches.reshape((batch, rows * cols, self.config.patch_dim()))?)
+    }
+
+    /// Return every named trainable tensor in the encoder.
+    ///
+    /// Used by Phase 42 tests to assert the frozen encoder receives no
+    /// gradients: callers diff this set against the gradient store after a
+    /// backward pass and confirm it is empty.
+    pub fn named_tensors(&self) -> HashMap<String, Tensor> {
+        let mut out = HashMap::new();
+        out.insert(
+            "patch_embed.weight".to_string(),
+            self.patch_embed.weight().clone(),
+        );
+        out.insert("class_embedding".to_string(), self.class_embedding.clone());
+        out.insert(
+            "position_embedding".to_string(),
+            self.position_embedding.clone(),
+        );
+        out.insert(
+            "pre_norm.weight".to_string(),
+            self.pre_norm.weight().clone(),
+        );
+        out.insert(
+            "pre_norm.bias".to_string(),
+            self.pre_norm.bias().expect("pre_norm bias").clone(),
+        );
+        out.insert(
+            "post_norm.weight".to_string(),
+            self.post_norm.weight().clone(),
+        );
+        out.insert(
+            "post_norm.bias".to_string(),
+            self.post_norm.bias().expect("post_norm bias").clone(),
+        );
+        for (idx, block) in self.blocks.iter().enumerate() {
+            block.collect_named(idx, &mut out);
+        }
+        out
+    }
+}
+
+#[derive(Debug, Clone)]
+struct AudioBlock {
+    norm1: LayerNorm,
+    attn: AudioAttention,
+    norm2: LayerNorm,
+    mlp: AudioMlp,
+}
+
+impl AudioBlock {
+    fn new(config: &AudioEncoderConfig, vb: VarBuilder<'_>) -> Result<Self> {
+        let norm1 = layer_norm(config.audio_d_model, config.norm_eps, vb.pp("norm1"))?;
+        let attn = AudioAttention::new(config, vb.pp("attn"))?;
+        let norm2 = layer_norm(config.audio_d_model, config.norm_eps, vb.pp("norm2"))?;
+        let mlp = AudioMlp::new(config, vb.pp("mlp"))?;
+        Ok(Self {
+            norm1,
+            attn,
+            norm2,
+            mlp,
+        })
+    }
+
+    fn forward(&self, x: &Tensor) -> Result<Tensor> {
+        let residual = x;
+        let x = self.norm1.forward(x)?;
+        let x = self.attn.forward(&x)?;
+        let x = (residual + x)?;
+        let residual = x.clone();
+        let x = self.norm2.forward(&x)?;
+        let x = self.mlp.forward(&x)?;
+        Ok((residual + x)?)
+    }
+
+    fn collect_named(&self, idx: usize, out: &mut HashMap<String, Tensor>) {
+        let prefix = format!("blocks.{idx}");
+        out.insert(
+            format!("{prefix}.norm1.weight"),
+            self.norm1.weight().clone(),
+        );
+        out.insert(
+            format!("{prefix}.norm1.bias"),
+            self.norm1.bias().expect("norm1 bias").clone(),
+        );
+        out.insert(
+            format!("{prefix}.attn.q_proj.weight"),
+            self.attn.q_proj.weight().clone(),
+        );
+        out.insert(
+            format!("{prefix}.attn.q_proj.bias"),
+            self.attn.q_proj.bias().expect("q_proj bias").clone(),
+        );
+        out.insert(
+            format!("{prefix}.attn.k_proj.weight"),
+            self.attn.k_proj.weight().clone(),
+        );
+        out.insert(
+            format!("{prefix}.attn.k_proj.bias"),
+            self.attn.k_proj.bias().expect("k_proj bias").clone(),
+        );
+        out.insert(
+            format!("{prefix}.attn.v_proj.weight"),
+            self.attn.v_proj.weight().clone(),
+        );
+        out.insert(
+            format!("{prefix}.attn.v_proj.bias"),
+            self.attn.v_proj.bias().expect("v_proj bias").clone(),
+        );
+        out.insert(
+            format!("{prefix}.attn.out_proj.weight"),
+            self.attn.out_proj.weight().clone(),
+        );
+        out.insert(
+            format!("{prefix}.attn.out_proj.bias"),
+            self.attn.out_proj.bias().expect("out_proj bias").clone(),
+        );
+        out.insert(
+            format!("{prefix}.norm2.weight"),
+            self.norm2.weight().clone(),
+        );
+        out.insert(
+            format!("{prefix}.norm2.bias"),
+            self.norm2.bias().expect("norm2 bias").clone(),
+        );
+        out.insert(
+            format!("{prefix}.mlp.fc1.weight"),
+            self.mlp.fc1.weight().clone(),
+        );
+        out.insert(
+            format!("{prefix}.mlp.fc1.bias"),
+            self.mlp.fc1.bias().expect("fc1 bias").clone(),
+        );
+        out.insert(
+            format!("{prefix}.mlp.fc2.weight"),
+            self.mlp.fc2.weight().clone(),
+        );
+        out.insert(
+            format!("{prefix}.mlp.fc2.bias"),
+            self.mlp.fc2.bias().expect("fc2 bias").clone(),
+        );
+    }
+}
+
+#[derive(Debug, Clone)]
+struct AudioAttention {
+    q_proj: Linear,
+    k_proj: Linear,
+    v_proj: Linear,
+    out_proj: Linear,
+    heads: usize,
+    head_dim: usize,
+    scale: f64,
+}
+
+impl AudioAttention {
+    fn new(config: &AudioEncoderConfig, vb: VarBuilder<'_>) -> Result<Self> {
+        let q_proj = linear(config.audio_d_model, config.audio_d_model, vb.pp("q_proj"))?;
+        let k_proj = linear(config.audio_d_model, config.audio_d_model, vb.pp("k_proj"))?;
+        let v_proj = linear(config.audio_d_model, config.audio_d_model, vb.pp("v_proj"))?;
+        let out_proj = linear(
+            config.audio_d_model,
+            config.audio_d_model,
+            vb.pp("out_proj"),
+        )?;
+        let head_dim = config.head_dim();
+        Ok(Self {
+            q_proj,
+            k_proj,
+            v_proj,
+            out_proj,
+            heads: config.audio_heads,
+            head_dim,
+            scale: 1.0 / (head_dim as f64).sqrt(),
+        })
+    }
+
+    fn forward(&self, x: &Tensor) -> Result<Tensor> {
+        let dims = x.dims();
+        let (batch, seq_len, width) = (dims[0], dims[1], dims[2]);
+        let q = self
+            .q_proj
+            .forward(x)?
+            .reshape((batch, seq_len, self.heads, self.head_dim))?
+            .transpose(1, 2)?
+            .contiguous()?;
+        let k = self
+            .k_proj
+            .forward(x)?
+            .reshape((batch, seq_len, self.heads, self.head_dim))?
+            .transpose(1, 2)?
+            .contiguous()?;
+        let v = self
+            .v_proj
+            .forward(x)?
+            .reshape((batch, seq_len, self.heads, self.head_dim))?
+            .transpose(1, 2)?
+            .contiguous()?;
+        let attn = q.matmul(&k.transpose(2, 3)?)?.affine(self.scale, 0.0)?;
+        let attn = softmax(&attn, D::Minus1)?;
+        let out = attn.matmul(&v)?.transpose(1, 2)?;
+        let out = out.reshape((batch, seq_len, width))?;
+        Ok(self.out_proj.forward(&out)?)
+    }
+}
+
+#[derive(Debug, Clone)]
+struct AudioMlp {
+    fc1: Linear,
+    fc2: Linear,
+}
+
+impl AudioMlp {
+    fn new(config: &AudioEncoderConfig, vb: VarBuilder<'_>) -> Result<Self> {
+        let fc1 = linear(config.audio_d_model, config.mlp_dim, vb.pp("fc1"))?;
+        let fc2 = linear(config.mlp_dim, config.audio_d_model, vb.pp("fc2"))?;
+        Ok(Self { fc1, fc2 })
+    }
+
+    fn forward(&self, x: &Tensor) -> Result<Tensor> {
+        let x = self.fc1.forward(x)?.gelu()?;
+        Ok(self.fc2.forward(&x)?)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use candle_nn::{VarBuilder, VarMap};
+
+    fn tiny_config() -> AudioEncoderConfig {
+        AudioEncoderConfig {
+            n_mels: 16,
+            max_frames: 16,
+            patch_mel: 4,
+            patch_time: 4,
+            audio_d_model: 16,
+            audio_layers: 2,
+            audio_heads: 2,
+            mlp_dim: 32,
+            norm_eps: 1e-5,
+        }
+    }
+
+    #[test]
+    fn audio_encoder_outputs_patch_tokens() {
+        let device = Device::Cpu;
+        let config = tiny_config();
+        let varmap = VarMap::new();
+        let vb = VarBuilder::from_varmap(&varmap, DType::F32, &device);
+        let encoder = FrozenAudioEncoder::new(config, vb).unwrap();
+        let spectrogram = Tensor::zeros((1, 16, 16), DType::F32, &device).unwrap();
+        let output = encoder.forward(&spectrogram).unwrap();
+        // 16 mels / 4 = 4 rows, 16 frames / 4 = 4 cols -> 16 patch tokens
+        assert_eq!(output.dims(), &[1, 16, 16]);
+    }
+
+    #[test]
+    fn named_tensors_cover_every_block() {
+        let config = tiny_config();
+        let varmap = VarMap::new();
+        let vb = VarBuilder::from_varmap(&varmap, DType::F32, &Device::Cpu);
+        let encoder = FrozenAudioEncoder::new(config, vb).unwrap();
+        let names = encoder.named_tensors();
+        // 7 root tensors + 16 per block * 2 blocks = 39
+        assert_eq!(names.len(), 7 + 16 * 2);
+        assert!(names.contains_key("blocks.0.attn.q_proj.weight"));
+        assert!(names.contains_key("blocks.1.mlp.fc2.bias"));
+    }
+}
diff --git a/crates/aarambh-studio-audio/src/fusion.rs b/crates/aarambh-studio-audio/src/fusion.rs
new file mode 100644
index 0000000..f44fc01
--- /dev/null
+++ b/crates/aarambh-studio-audio/src/fusion.rs
@@ -0,0 +1,107 @@
+//! Audio-token fusion helpers.
+//!
+//! Generalises v2 §24's `interleave_image_tokens` into the shared
+//! modal-token-splicing pattern: the single `<audio>` placeholder token in the
+//! text sequence is replaced by the projected audio patch embeddings, producing
+//! one contiguous sequence the decoder consumes exactly as it consumes text.
+
+use aarambh_studio_core::{AarambhError, Result};
+use candle_core::Tensor;
+
+/// Replace one audio placeholder token embedding with projected audio tokens.
+///
+/// `text_tokens` is the token-id sequence of the prompt (which must contain
+/// exactly one `audio_placeholder_id`). `text_embeddings` is the embedding
+/// lookup of that sequence with shape `[1, seq, hidden_dim]`.
+/// `audio_embeddings` is the projected audio patch tokens with shape
+/// `[1, audio_tokens, hidden_dim]`. The result concatenates the text-token
+/// embeddings with the audio embeddings spliced in at the placeholder position,
+/// yielding shape `[1, seq - 1 + audio_tokens, hidden_dim]`.
+pub fn interleave_audio_tokens(
+    text_tokens: &[u32],
+    text_embeddings: &Tensor,
+    audio_embeddings: &Tensor,
+    audio_placeholder_id: u32,
+) -> Result<Tensor> {
+    let text_dims = text_embeddings.dims();
+    let audio_dims = audio_embeddings.dims();
+    if text_dims.len() != 3 || text_dims[0] != 1 {
+        return Err(AarambhError::Shape(format!(
+            "text_embeddings must have shape [1, seq, hidden_dim], got {text_dims:?}"
+        )));
+    }
+    if audio_dims.len() != 3 || audio_dims[0] != 1 {
+        return Err(AarambhError::Shape(format!(
+            "audio_embeddings must have shape [1, audio_tokens, hidden_dim], got {audio_dims:?}"
+        )));
+    }
+    if text_dims[1] != text_tokens.len() {
+        return Err(AarambhError::Shape(format!(
+            "text token count {} does not match text embedding seq {}",
+            text_tokens.len(),
+            text_dims[1]
+        )));
+    }
+    if text_dims[2] != audio_dims[2] {
+        return Err(AarambhError::Shape(format!(
+            "text hidden dim {} does not match audio hidden dim {}",
+            text_dims[2], audio_dims[2]
+        )));
+    }
+
+    let placeholder_count = text_tokens
+        .iter()
+        .filter(|token| **token == audio_placeholder_id)
+        .count();
+    if placeholder_count != 1 {
+        return Err(AarambhError::Config(format!(
+            "expected exactly one audio placeholder token id {audio_placeholder_id}, found {placeholder_count}"
+        )));
+    }
+
+    let mut parts = Vec::with_capacity(text_tokens.len() + 1);
+    for (idx, token_id) in text_tokens.iter().enumerate() {
+        if *token_id == audio_placeholder_id {
+            parts.push(audio_embeddings.clone());
+        } else {
+            parts.push(text_embeddings.narrow(1, idx, 1)?);
+        }
+    }
+    Ok(Tensor::cat(&parts, 1)?)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use candle_core::{Device, Tensor};
+
+    #[test]
+    fn audio_token_interleave_produces_expected_sequence_length() {
+        let device = Device::Cpu;
+        let text_tokens = vec![10u32, 7, 11, 12];
+        let text_values = (0..12).map(|value| value as f32).collect::<Vec<_>>();
+        let audio_values = vec![100f32, 101., 102., 103., 104., 105., 106., 107., 108.];
+        let text = Tensor::from_vec(text_values, (1, 4, 3), &device).unwrap();
+        let audio = Tensor::from_vec(audio_values, (1, 3, 3), &device).unwrap();
+        let fused = interleave_audio_tokens(&text_tokens, &text, &audio, 7).unwrap();
+        // 4 text tokens, one replaced by 3 audio tokens -> 3 + 3 = 6
+        assert_eq!(fused.dims(), &[1, 6, 3]);
+        let rows = fused.squeeze(0).unwrap().to_vec2::<f32>().unwrap();
+        assert_eq!(rows[0], vec![0., 1., 2.]);
+        assert_eq!(rows[1], vec![100., 101., 102.]);
+        assert_eq!(rows[2], vec![103., 104., 105.]);
+        assert_eq!(rows[3], vec![106., 107., 108.]);
+        assert_eq!(rows[4], vec![6., 7., 8.]);
+        assert_eq!(rows[5], vec![9., 10., 11.]);
+    }
+
+    #[test]
+    fn audio_interleave_rejects_missing_placeholder() {
+        let device = Device::Cpu;
+        let text_tokens = vec![10u32, 11, 12];
+        let text = Tensor::zeros((1, 3, 4), candle_core::DType::F32, &device).unwrap();
+        let audio = Tensor::zeros((1, 2, 4), candle_core::DType::F32, &device).unwrap();
+        let result = interleave_audio_tokens(&text_tokens, &text, &audio, 7);
+        assert!(result.is_err());
+    }
+}
diff --git a/crates/aarambh-studio-audio/src/instruct_data.rs b/crates/aarambh-studio-audio/src/instruct_data.rs
new file mode 100644
index 0000000..f69609f
--- /dev/null
+++ b/crates/aarambh-studio-audio/src/instruct_data.rs
@@ -0,0 +1,225 @@
+//! Audio instruction data loading.
+//!
+//! Mirrors `aarambh_studio_vision::instruct_data`: a normalized
+//! `AudioQaExample` plus a JSONL loader that accepts both simple
+//! `{audio, question, answer}` records and LLaVA-style
+//! `{audio, conversations:[...]}` records. Captions are accepted as a
+//! degenerate QA pair whose question is empty.
+
+use std::fs;
+use std::path::{Path, PathBuf};
+
+use aarambh_studio_core::{AarambhError, Result};
+use serde::Deserialize;
+
+/// Normalized audio instruction example.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct AudioQaExample {
+    /// Audio path, relative to the configured audio root when not absolute.
+    pub audio_path: PathBuf,
+    /// User question or instruction. Empty for caption-only examples.
+    pub question: String,
+    /// Assistant target answer or caption.
+    pub answer: String,
+    /// Optional hidden thinking target placed before the final answer.
+    pub thinking: Option<String>,
+}
+
+impl AudioQaExample {
+    /// Build a normalized audio QA example.
+    pub fn new(
+        audio_path: impl Into<PathBuf>,
+        question: impl Into<String>,
+        answer: impl Into<String>,
+        thinking: Option<String>,
+    ) -> Result<Self> {
+        let question = strip_audio_marker(&question.into());
+        let answer = answer.into().trim().to_string();
+        if answer.is_empty() {
+            return Err(AarambhError::Config(
+                "audio QA example answer must not be empty".into(),
+            ));
+        }
+        Ok(Self {
+            audio_path: audio_path.into(),
+            question,
+            answer,
+            thinking,
+        })
+    }
+
+    /// Return whether this example is a caption (no question).
+    pub fn is_caption(&self) -> bool {
+        self.question.is_empty()
+    }
+}
+
+/// Load audio instruction examples from JSONL.
+pub fn load_audio_qa_jsonl(
+    path: impl AsRef<Path>,
+    max_samples: Option<usize>,
+) -> Result<Vec<AudioQaExample>> {
+    let path = path.as_ref();
+    let content = fs::read_to_string(path).map_err(|err| {
+        AarambhError::Io(std::io::Error::new(
+            err.kind(),
+            format!("failed to read {}: {err}", path.display()),
+        ))
+    })?;
+    let mut examples = Vec::new();
+    for (line_idx, line) in content.lines().enumerate() {
+        let line = line.trim();
+        if line.is_empty() {
+            continue;
+        }
+        let raw: RawAudioRecord = serde_json::from_str(line).map_err(|err| {
+            AarambhError::Config(format!(
+                "failed to parse {} line {}: {err}",
+                path.display(),
+                line_idx + 1
+            ))
+        })?;
+        examples.push(raw.into_example().map_err(|err| {
+            AarambhError::Config(format!(
+                "invalid audio example in {} line {}: {err}",
+                path.display(),
+                line_idx + 1
+            ))
+        })?);
+        if max_samples.is_some_and(|max| examples.len() >= max) {
+            break;
+        }
+    }
+    if examples.is_empty() {
+        return Err(AarambhError::Config(format!(
+            "{} contains no audio examples",
+            path.display()
+        )));
+    }
+    Ok(examples)
+}
+
+#[derive(Debug, Deserialize)]
+struct RawAudioRecord {
+    #[serde(default, alias = "audio")]
+    audio_path: Option<PathBuf>,
+    #[serde(default)]
+    question: Option<String>,
+    #[serde(default)]
+    answer: Option<String>,
+    #[serde(default)]
+    caption: Option<String>,
+    #[serde(default)]
+    thinking: Option<String>,
+    #[serde(default)]
+    conversations: Vec<ConversationTurn>,
+}
+
+impl RawAudioRecord {
+    fn into_example(self) -> Result<AudioQaExample> {
+        let audio_path = self.audio_path.ok_or_else(|| {
+            AarambhError::Config("audio example is missing audio or audio_path".into())
+        })?;
+        if let Some(answer) = self.answer {
+            let question = self.question.unwrap_or_default();
+            return AudioQaExample::new(audio_path, question, answer, self.thinking);
+        }
+        if let Some(caption) = self.caption {
+            return AudioQaExample::new(audio_path, "", caption, self.thinking);
+        }
+        let question = self
+            .conversations
+            .iter()
+            .find(|turn| turn.is_human())
+            .map(|turn| turn.value.clone())
+            .ok_or_else(|| AarambhError::Config("audio record has no human turn".into()))?;
+        let answer = self
+            .conversations
+            .iter()
+            .skip_while(|turn| !turn.is_human())
+            .find(|turn| turn.is_assistant())
+            .map(|turn| turn.value.clone())
+            .ok_or_else(|| {
+                AarambhError::Config("audio record has no assistant turn after human turn".into())
+            })?;
+        AudioQaExample::new(audio_path, question, answer, self.thinking)
+    }
+}
+
+#[derive(Debug, Deserialize)]
+struct ConversationTurn {
+    #[serde(default, alias = "role")]
+    from: String,
+    value: String,
+}
+
+impl ConversationTurn {
+    fn is_human(&self) -> bool {
+        matches!(
+            self.from.trim().to_ascii_lowercase().as_str(),
+            "human" | "user"
+        )
+    }
+
+    fn is_assistant(&self) -> bool {
+        matches!(
+            self.from.trim().to_ascii_lowercase().as_str(),
+            "gpt" | "assistant"
+        )
+    }
+}
+
+fn strip_audio_marker(value: &str) -> String {
+    value
+        .replace("<audio>", "")
+        .lines()
+        .map(str::trim)
+        .filter(|line| !line.is_empty())
+        .collect::<Vec<_>>()
+        .join("\n")
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parses_caption_record() {
+        let raw: RawAudioRecord =
+            serde_json::from_str(r#"{"audio":"tone.wav","caption":"a pure tone"}"#).unwrap();
+        let example = raw.into_example().unwrap();
+        assert_eq!(example.audio_path, PathBuf::from("tone.wav"));
+        assert!(example.is_caption());
+        assert_eq!(example.answer, "a pure tone");
+    }
+
+    #[test]
+    fn parses_simple_qa_record() {
+        let raw: RawAudioRecord = serde_json::from_str(
+            r#"{"audio":"beep.wav","question":"What sound?","answer":"a beep","thinking":"listen"}"#,
+        )
+        .unwrap();
+        let example = raw.into_example().unwrap();
+        assert_eq!(example.question, "What sound?");
+        assert_eq!(example.answer, "a beep");
+        assert_eq!(example.thinking.as_deref(), Some("listen"));
+    }
+
+    #[test]
+    fn parses_conversation_record() {
+        let raw: RawAudioRecord = serde_json::from_str(
+            r#"{"audio":"chime.wav","conversations":[{"from":"human","value":"<audio>\nDescribe?"},{"from":"gpt","value":"A chime."}]}"#,
+        )
+        .unwrap();
+        let example = raw.into_example().unwrap();
+        assert_eq!(example.question, "Describe?");
+        assert_eq!(example.answer, "A chime.");
+    }
+
+    #[test]
+    fn rejects_empty_answer() {
+        let raw: RawAudioRecord =
+            serde_json::from_str(r#"{"audio":"x.wav","answer":"   "}"#).unwrap();
+        assert!(raw.into_example().is_err());
+    }
+}
diff --git a/crates/aarambh-studio-audio/src/lib.rs b/crates/aarambh-studio-audio/src/lib.rs
new file mode 100644
index 0000000..8808d1f
--- /dev/null
+++ b/crates/aarambh-studio-audio/src/lib.rs
@@ -0,0 +1,289 @@
+//! Audio encoder, projector, preprocessing, and multimodal fusion utilities.
+//!
+//! Phase 42 adds audio understanding to aarambh-studio following the exact
+//! frozen-encoder-plus-trainable-projector pattern v2 §24 established for
+//! vision and v3 §35–36 reused for video and documents. A frozen, pretrained
+//! audio spectrogram transformer converts a log-mel spectrogram into a grid of
+//! patch embeddings; a small trainable projector maps those into the decoder's
+//! `d_model` space; the result is spliced into the token sequence at the
+//! `<audio>` special token position. Nothing about the decoder, the thinking
+//! engine, or tool calling changes — audio is just another sense feeding the
+//! same fusion mechanism.
+
+#![deny(missing_docs)]
+
+/// Frozen audio spectrogram transformer encoder.
+pub mod encoder;
+/// Audio-token fusion helpers.
+pub mod fusion;
+/// Audio instruction data loading.
+pub mod instruct_data;
+/// Pure-Rust WAV decode and mel-spectrogram extraction.
+pub mod preprocess;
+/// Trainable audio-to-language projector.
+pub mod projector;
+
+pub use encoder::{AudioEncoderConfig, FrozenAudioEncoder};
+pub use fusion::interleave_audio_tokens;
+pub use instruct_data::{AudioQaExample, load_audio_qa_jsonl};
+pub use preprocess::{AudioPreprocessor, MelSpectrogramConfig};
+pub use projector::{AudioProjector, AudioProjectorConfig};
+
+/// Frozen audio encoder plus trainable language-model projector.
+#[derive(Debug, Clone)]
+pub struct AudioModel {
+    encoder: FrozenAudioEncoder,
+    projector: AudioProjector,
+}
+
+impl AudioModel {
+    /// Create an audio model from an encoder and projector.
+    pub fn new(encoder: FrozenAudioEncoder, projector: AudioProjector) -> Self {
+        Self { encoder, projector }
+    }
+
+    /// Return the frozen audio encoder.
+    pub fn encoder(&self) -> &FrozenAudioEncoder {
+        &self.encoder
+    }
+
+    /// Return the trainable projector.
+    pub fn projector(&self) -> &AudioProjector {
+        &self.projector
+    }
+
+    /// Encode a mel-spectrogram tensor and project patch tokens into LLM width.
+    pub fn forward(
+        &self,
+        spectrogram: &candle_core::Tensor,
+    ) -> aarambh_studio_core::Result<candle_core::Tensor> {
+        let patch_tokens = self.encoder.forward(spectrogram)?;
+        self.projector.forward(&patch_tokens)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use candle_core::{DType, Device, Tensor};
+    use candle_nn::{VarBuilder, VarMap};
+
+    fn tiny_audio_setup() -> (AudioModel, VarMap, VarMap) {
+        let device = Device::Cpu;
+        let encoder_config = AudioEncoderConfig {
+            n_mels: 16,
+            max_frames: 16,
+            patch_mel: 4,
+            patch_time: 4,
+            audio_d_model: 16,
+            audio_layers: 2,
+            audio_heads: 2,
+            mlp_dim: 32,
+            norm_eps: 1e-5,
+        };
+        let encoder_varmap = VarMap::new();
+        let encoder_vb = VarBuilder::from_varmap(&encoder_varmap, DType::F32, &device);
+        let encoder = FrozenAudioEncoder::new(encoder_config, encoder_vb).unwrap();
+        let projector_varmap = VarMap::new();
+        let projector_vb = VarBuilder::from_varmap(&projector_varmap, DType::F32, &device);
+        let projector = AudioProjector::new(
+            AudioProjectorConfig {
+                audio_d_model: 16,
+                llm_d_model: 24,
+                hidden_mult: 2,
+            },
+            projector_vb,
+        )
+        .unwrap();
+        let model = AudioModel::new(encoder, projector);
+        (model, encoder_varmap, projector_varmap)
+    }
+
+    #[test]
+    fn frozen_audio_encoder_never_receives_gradients() {
+        // The projector-only training stage detaches the frozen encoder output
+        // before the projector consumes it (the same pattern
+        // `aarambh_studio_finetune::vlm_dora` uses for the CLIP encoder). After a
+        // backward pass, gradients must reach the projector variables and must
+        // NOT reach any encoder variable.
+        let device = Device::Cpu;
+        let encoder_config = AudioEncoderConfig {
+            n_mels: 16,
+            max_frames: 16,
+            patch_mel: 4,
+            patch_time: 4,
+            audio_d_model: 16,
+            audio_layers: 1,
+            audio_heads: 2,
+            mlp_dim: 32,
+            norm_eps: 1e-5,
+        };
+        let encoder_varmap = VarMap::new();
+        let encoder_vb = VarBuilder::from_varmap(&encoder_varmap, DType::F32, &device);
+        let encoder = FrozenAudioEncoder::new(encoder_config, encoder_vb).unwrap();
+        let projector_varmap = VarMap::new();
+        let projector_vb = VarBuilder::from_varmap(&projector_varmap, DType::F32, &device);
+        let projector = AudioProjector::new(
+            AudioProjectorConfig {
+                audio_d_model: 16,
+                llm_d_model: 24,
+                hidden_mult: 2,
+            },
+            projector_vb,
+        )
+        .unwrap();
+        let spectrogram = Tensor::zeros((1, 16, 16), DType::F32, &device).unwrap();
+        // Detach the encoder output: this is the freeze mechanism.
+        let patch_tokens = encoder.forward(&spectrogram).unwrap().detach();
+        let output = projector.forward(&patch_tokens).unwrap();
+        let loss = output.sum_all().unwrap();
+        let grads = loss.backward().unwrap();
+
+        let projector_data = projector_varmap.data().lock().unwrap();
+        let projector_grads = projector_data
+            .iter()
+            .filter(|(_, var)| grads.get(var.as_tensor()).is_some())
+            .count();
+        assert!(
+            projector_grads > 0,
+            "projector variables must receive gradients"
+        );
+
+        let encoder_data = encoder_varmap.data().lock().unwrap();
+        let encoder_grads = encoder_data
+            .iter()
+            .filter(|(_, var)| grads.get(var.as_tensor()).is_some())
+            .count();
+        assert_eq!(
+            encoder_grads, 0,
+            "frozen audio encoder must never receive gradients"
+        );
+    }
+
+    #[test]
+    fn projector_pretrain_stage_trains_only_projector_weights() {
+        // The projector-only stage trains the projector alone while the encoder
+        // and the LLM stay frozen. We assert the structural guarantee the stage
+        // relies on: the detached encoder output has no backward graph, so
+        // gradients stop at the projector and cannot flow into the encoder.
+        let device = Device::Cpu;
+        let encoder_config = AudioEncoderConfig {
+            n_mels: 16,
+            max_frames: 16,
+            patch_mel: 4,
+            patch_time: 4,
+            audio_d_model: 16,
+            audio_layers: 1,
+            audio_heads: 2,
+            mlp_dim: 32,
+            norm_eps: 1e-5,
+        };
+        let encoder_varmap = VarMap::new();
+        let encoder_vb = VarBuilder::from_varmap(&encoder_varmap, DType::F32, &device);
+        let encoder = FrozenAudioEncoder::new(encoder_config, encoder_vb).unwrap();
+        let projector_varmap = VarMap::new();
+        let projector_vb = VarBuilder::from_varmap(&projector_varmap, DType::F32, &device);
+        let projector = AudioProjector::new(
+            AudioProjectorConfig {
+                audio_d_model: 16,
+                llm_d_model: 24,
+                hidden_mult: 2,
+            },
+            projector_vb,
+        )
+        .unwrap();
+        let spectrogram = Tensor::zeros((1, 16, 16), DType::F32, &device).unwrap();
+        let patch_tokens = encoder.forward(&spectrogram).unwrap();
+        // Detach simulates the frozen-encoder projector-pretrain stage.
+        let detached = patch_tokens.detach();
+        let output = projector.forward(&detached).unwrap();
+        assert_eq!(output.dims(), &[1, 16, 24]);
+        // A detached tensor carries no backward node, so the encoder cannot
+        // receive gradients from a loss computed over `output` — exactly the
+        // guarantee the projector-only training stage relies on.
+        let loss = output.sum_all().unwrap();
+        let grads = loss.backward().unwrap();
+        let encoder_data = encoder_varmap.data().lock().unwrap();
+        let encoder_grads = encoder_data
+            .iter()
+            .filter(|(_, var)| grads.get(var.as_tensor()).is_some())
+            .count();
+        assert_eq!(encoder_grads, 0, "encoder must stay frozen in stage one");
+        let projector_data = projector_varmap.data().lock().unwrap();
+        let projector_grads = projector_data
+            .iter()
+            .filter(|(_, var)| grads.get(var.as_tensor()).is_some())
+            .count();
+        assert!(projector_grads > 0, "projector must train in stage one");
+    }
+
+    #[test]
+    fn audio_token_fusion_produces_expected_sequence_length() {
+        let device = Device::Cpu;
+        let text_tokens = vec![5u32, 15, 6, 0];
+        let text_values = (0..16).map(|v| v as f32).collect::<Vec<_>>();
+        let text = Tensor::from_vec(text_values, (1, 4, 4), &device).unwrap();
+        let audio_values = (0..24).map(|v| v as f32).collect::<Vec<_>>();
+        let audio = Tensor::from_vec(audio_values, (1, 6, 4), &device).unwrap();
+        let fused = interleave_audio_tokens(&text_tokens, &text, &audio, 15).unwrap();
+        // 4 text tokens, one replaced by 6 audio tokens -> 3 + 6 = 9
+        assert_eq!(fused.dims(), &[1, 9, 4]);
+    }
+
+    #[test]
+    fn thinking_controller_behaves_identically_after_audio_context() {
+        // Composability guarantee (v2 §25, restated for audio in ARCHITECTURE_V4
+        // §56): a thinking block generated after audio tokens is indistinguishable
+        // to the controller from one generated after text-only context. We verify
+        // the mechanism that makes this true — the fused audio-context embeddings
+        // have the same hidden width and a well-formed sequence length, so the
+        // decoder and its thinking controller observe an ordinary token sequence.
+        let device = Device::Cpu;
+        let hidden = 16usize;
+        let text_tokens = vec![5u32, 15, 6];
+        let text = Tensor::zeros((1, 3, hidden), DType::F32, &device).unwrap();
+        let audio = Tensor::zeros((1, 8, hidden), DType::F32, &device).unwrap();
+        let fused = interleave_audio_tokens(&text_tokens, &text, &audio, 15).unwrap();
+        assert_eq!(fused.dims()[2], hidden);
+        assert_eq!(fused.dims()[1], 3 + 8 - 1);
+        // The fused tensor is finite and contiguous — the decoder sees a normal
+        // embedding sequence, identical in contract to a text-only one.
+        assert!(fused.is_contiguous());
+        let sum = fused.sum_all().unwrap().to_scalar::<f32>().unwrap();
+        assert!(sum.is_finite());
+    }
+
+    #[test]
+    fn audio_model_forwards_to_llm_width() {
+        let (model, _, _) = tiny_audio_setup();
+        let spectrogram = Tensor::zeros((1, 16, 16), DType::F32, &Device::Cpu).unwrap();
+        let output = model.forward(&spectrogram).unwrap();
+        assert_eq!(output.dims(), &[1, 16, 24]);
+    }
+
+    #[test]
+    fn projector_linear_layers_are_accessible() {
+        let (model, _, _) = tiny_audio_setup();
+        // fc1 maps audio_d_model (16) -> hidden_dim (48); fc2 maps 48 -> llm (24).
+        assert_eq!(model.projector().fc1().weight().dims(), &[48, 16]);
+        assert_eq!(model.projector().fc2().weight().dims(), &[24, 48]);
+    }
+
+    #[test]
+    fn audio_model_forward_is_finite_for_nonzero_input() {
+        let (model, _, _) = tiny_audio_setup();
+        let values: Vec<f32> = (0..256).map(|v| (v as f32) / 256.0).collect();
+        let spectrogram = Tensor::from_vec(values, (1, 16, 16), &Device::Cpu).unwrap();
+        let output = model.forward(&spectrogram).unwrap();
+        let sum = output.sum_all().unwrap().to_scalar::<f32>().unwrap();
+        assert!(sum.is_finite());
+    }
+
+    #[test]
+    fn encoder_named_tensors_exclude_projector_names() {
+        let (model, _, _) = tiny_audio_setup();
+        let names = model.encoder().named_tensors();
+        assert!(!names.contains_key("fc1.weight"));
+        assert!(names.contains_key("patch_embed.weight"));
+    }
+}
diff --git a/crates/aarambh-studio-audio/src/preprocess.rs b/crates/aarambh-studio-audio/src/preprocess.rs
new file mode 100644
index 0000000..ef25739
--- /dev/null
+++ b/crates/aarambh-studio-audio/src/preprocess.rs
@@ -0,0 +1,778 @@
+//! Pure-Rust audio decode and mel-spectrogram extraction.
+//!
+//! Phase 42 follows the same dependency discipline v3 §35 established for video
+//! container decode: local, pure-Rust decode only — no Python audio ML tooling,
+//! no system-library FFI. WAV PCM (8/16/24/32-bit signed and unsigned, plus
+//! 32-bit float) is decoded in-process, resampled to the configured sample rate,
+//! and converted into a log-mel spectrogram with a from-scratch Hann window,
+//! radix-2 Cooley-Tukey FFT, and triangular mel filterbank.
+
+use std::path::Path;
+
+use aarambh_studio_core::{AarambhError, Result};
+use candle_core::{Device, Tensor};
+use serde::{Deserialize, Serialize};
+
+/// Configuration for mel-spectrogram extraction.
+///
+/// Produces a `[n_mels, time_frames]` log-power mel spectrogram, the input the
+/// frozen audio encoder consumes (treated as a single-channel image whose rows
+/// are mel frequency bins and whose columns are short-time frames).
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[serde(default)]
+pub struct MelSpectrogramConfig {
+    /// Target sample rate in hertz; input audio is resampled to this rate.
+    pub sample_rate: u32,
+    /// FFT window length in samples; must be a power of two.
+    pub n_fft: usize,
+    /// Hop length between successive short-time windows in samples.
+    pub hop_length: usize,
+    /// Number of triangular mel filterbank bins.
+    pub n_mels: usize,
+    /// Lowest filterbank frequency in hertz.
+    pub fmin: f32,
+    /// Highest filterbank frequency in hertz.
+    pub fmax: f32,
+    /// Maximum source audio duration in seconds; longer clips are truncated.
+    pub max_audio_seconds: f32,
+    /// Spectrogram power exponent (`2.0` for power, `1.0` for magnitude).
+    pub power: f32,
+    /// Log offset added before the natural log to avoid `log(0)`.
+    pub log_eps: f32,
+}
+
+impl Default for MelSpectrogramConfig {
+    fn default() -> Self {
+        Self {
+            sample_rate: 16_000,
+            n_fft: 400,
+            hop_length: 160,
+            n_mels: 80,
+            fmin: 0.0,
+            fmax: 8_000.0,
+            max_audio_seconds: 10.0,
+            power: 2.0,
+            log_eps: 1.0e-10,
+        }
+    }
+}
+
+impl MelSpectrogramConfig {
+    /// Validate mel-spectrogram parameters.
+    pub fn validate(&self) -> Result<()> {
+        if self.sample_rate == 0
+            || self.n_fft == 0
+            || self.hop_length == 0
+            || self.n_mels == 0
+            || self.max_audio_seconds <= 0.0
+        {
+            return Err(AarambhError::Config(
+                "mel sample_rate, n_fft, hop_length, n_mels, and max_audio_seconds must be non-zero"
+                    .into(),
+            ));
+        }
+        if !self.n_fft.is_power_of_two() {
+            return Err(AarambhError::Config(format!(
+                "mel n_fft {} must be a power of two",
+                self.n_fft
+            )));
+        }
+        if self.hop_length > self.n_fft {
+            return Err(AarambhError::Config(format!(
+                "mel hop_length {} must not exceed n_fft {}",
+                self.hop_length, self.n_fft
+            )));
+        }
+        if self.fmax <= self.fmin {
+            return Err(AarambhError::Config(format!(
+                "mel fmax {} must exceed fmin {}",
+                self.fmax, self.fmin
+            )));
+        }
+        if self.power <= 0.0 || self.log_eps <= 0.0 {
+            return Err(AarambhError::Config(
+                "mel power and log_eps must be positive".into(),
+            ));
+        }
+        Ok(())
+    }
+
+    /// Number of short-time frames produced for the maximum audio duration.
+    pub fn max_frames(&self) -> usize {
+        let total_samples = (self.max_audio_seconds * self.sample_rate as f32) as usize;
+        if total_samples < self.n_fft {
+            return 1;
+        }
+        (total_samples - self.n_fft) / self.hop_length + 1
+    }
+}
+
+/// Audio preprocessor that decodes WAV files and extracts log-mel spectrograms.
+#[derive(Debug, Clone)]
+pub struct AudioPreprocessor {
+    config: MelSpectrogramConfig,
+    window: Vec<f32>,
+    mel: Vec<Vec<f32>>,
+}
+
+impl AudioPreprocessor {
+    /// Create a preprocessor from explicit configuration.
+    pub fn new(config: MelSpectrogramConfig) -> Result<Self> {
+        config.validate()?;
+        let window = hann_window(config.n_fft);
+        let mel = mel_filterbank(
+            config.n_mels,
+            config.n_fft,
+            config.sample_rate,
+            config.fmin,
+            config.fmax,
+        );
+        Ok(Self {
+            config,
+            window,
+            mel,
+        })
+    }
+
+    /// Return the preprocessing configuration.
+    pub fn config(&self) -> &MelSpectrogramConfig {
+        &self.config
+    }
+
+    /// Decode a WAV file and return a normalized `[n_mels, time_frames]` tensor.
+    pub fn preprocess_path(&self, path: impl AsRef<Path>, device: &Device) -> Result<Tensor> {
+        let decoded = decode_wav_mono(path.as_ref())?;
+        let resampled = resample_to_target(&decoded.samples, decoded.sample_rate, &self.config);
+        self.mel_tensor_from_samples(&resampled, device)
+    }
+
+    /// Decode an in-memory WAV byte buffer and return a normalized mel tensor.
+    pub fn preprocess_bytes(&self, bytes: &[u8], device: &Device) -> Result<Tensor> {
+        let decoded = decode_wav_mono_bytes(bytes)?;
+        let resampled = resample_to_target(&decoded.samples, decoded.sample_rate, &self.config);
+        self.mel_tensor_from_samples(&resampled, device)
+    }
+
+    fn mel_tensor_from_samples(&self, samples: &[f32], device: &Device) -> Result<Tensor> {
+        let spectrogram = self.mel_spectrogram(samples);
+        let n_mels = self.config.n_mels;
+        let max_frames = self.config.max_frames();
+        let frames = spectrogram.len() / n_mels;
+        let mut values = vec![0f32; n_mels * max_frames];
+        for mel_idx in 0..n_mels {
+            for frame_idx in 0..frames.min(max_frames) {
+                values[mel_idx * max_frames + frame_idx] =
+                    spectrogram[frame_idx * n_mels + mel_idx];
+            }
+        }
+        Ok(Tensor::from_vec(values, (n_mels, max_frames), device)?)
+    }
+
+    fn mel_spectrogram(&self, samples: &[f32]) -> Vec<f32> {
+        let MelSpectrogramConfig {
+            n_fft,
+            hop_length,
+            n_mels,
+            power,
+            log_eps,
+            ..
+        } = self.config;
+        if samples.len() < n_fft {
+            let mut padded = samples.to_vec();
+            padded.resize(n_fft, 0.0);
+            return self.frame_to_mel(&padded, n_mels, power, log_eps);
+        }
+        let max_frames = self.config.max_frames();
+        let mut out = Vec::with_capacity(max_frames * n_mels);
+        let mut frame = vec![0f32; n_fft];
+        let mut produced = 0usize;
+        let mut start = 0usize;
+        while start + n_fft <= samples.len() && produced < max_frames {
+            for (idx, value) in frame.iter_mut().enumerate() {
+                *value = samples[start + idx] * self.window[idx];
+            }
+            let mel = self.frame_to_mel(&frame, n_mels, power, log_eps);
+            out.extend_from_slice(&mel);
+            produced += 1;
+            start += hop_length;
+        }
+        if produced == 0 {
+            frame.copy_from_slice(&samples[..n_fft]);
+            for (idx, value) in frame.iter_mut().enumerate() {
+                *value *= self.window[idx];
+            }
+            out.extend_from_slice(&self.frame_to_mel(&frame, n_mels, power, log_eps));
+        }
+        out
+    }
+
+    fn frame_to_mel(&self, frame: &[f32], n_mels: usize, power: f32, log_eps: f32) -> Vec<f32> {
+        let mut spectrum = fft_power(frame);
+        let mut mel = vec![0f32; n_mels];
+        for (mel_idx, filter) in self.mel.iter().enumerate().take(n_mels) {
+            let mut acc = 0.0f32;
+            for (bin_idx, &weight) in filter.iter().enumerate() {
+                if weight > 0.0 {
+                    acc += weight * spectrum[bin_idx];
+                }
+            }
+            mel[mel_idx] = (acc.powf(power) + log_eps).ln();
+        }
+        // local mean / std normalization so the frozen encoder sees a stable scale
+        let mean = mel.iter().sum::<f32>() / mel.len() as f32;
+        let var = mel.iter().map(|v| (v - mean) * (v - mean)).sum::<f32>() / mel.len() as f32;
+        let std = var.sqrt().max(1.0e-6);
+        for value in &mut mel {
+            *value = (*value - mean) / std;
+        }
+        spectrum.clear();
+        mel
+    }
+}
+
+impl Default for AudioPreprocessor {
+    fn default() -> Self {
+        Self::new(MelSpectrogramConfig::default()).expect("default mel config")
+    }
+}
+
+fn hann_window(n: usize) -> Vec<f32> {
+    if n == 1 {
+        return vec![1.0];
+    }
+    (0..n)
+        .map(|idx| 0.5 - 0.5 * (2.0 * std::f32::consts::PI * idx as f32 / (n as f32 - 1.0)).cos())
+        .collect()
+}
+
+fn fft_power(frame: &[f32]) -> Vec<f32> {
+    let n = frame.len();
+    let mut real = frame.to_vec();
+    let mut imag = vec![0.0f32; n];
+    fft_in_place(&mut real, &mut imag);
+    let half = n / 2;
+    (0..=half)
+        .map(|idx| {
+            let re = real[idx];
+            let im = imag[idx];
+            re * re + im * im
+        })
+        .collect()
+}
+
+/// Iterative radix-2 Cooley-Tukey FFT operating in place on real/imag pairs.
+fn fft_in_place(real: &mut [f32], imag: &mut [f32]) {
+    let n = real.len();
+    if n <= 1 {
+        return;
+    }
+    bit_reverse_permute(real, imag);
+    let mut length = 2usize;
+    while length <= n {
+        let theta = -2.0 * std::f32::consts::PI / length as f32;
+        let w_re = theta.cos();
+        let w_im = theta.sin();
+        let half = length / 2;
+        let mut group_start = 0usize;
+        while group_start < n {
+            let mut cur_re = 1.0f32;
+            let mut cur_im = 0.0f32;
+            for pair in 0..half {
+                let even = group_start + pair;
+                let odd = even + half;
+                let t_re = cur_re * real[odd] - cur_im * imag[odd];
+                let t_im = cur_re * imag[odd] + cur_im * real[odd];
+                real[odd] = real[even] - t_re;
+                imag[odd] = imag[even] - t_im;
+                real[even] += t_re;
+                imag[even] += t_im;
+                let next_re = cur_re * w_re - cur_im * w_im;
+                cur_im = cur_re * w_im + cur_im * w_re;
+                cur_re = next_re;
+                if pair + 1 == half {
+                    break;
+                }
+            }
+            group_start += length;
+        }
+        length *= 2;
+    }
+}
+
+fn bit_reverse_permute(real: &mut [f32], imag: &mut [f32]) {
+    let n = real.len();
+    let bits = n.trailing_zeros() as usize;
+    for idx in 1..n {
+        let mut rev = 0usize;
+        let mut value = idx;
+        for _ in 0..bits {
+            rev = (rev << 1) | (value & 1);
+            value >>= 1;
+        }
+        if rev > idx {
+            real.swap(idx, rev);
+            imag.swap(idx, rev);
+        }
+    }
+}
+
+fn mel_filterbank(
+    n_mels: usize,
+    n_fft: usize,
+    sample_rate: u32,
+    fmin: f32,
+    fmax: f32,
+) -> Vec<Vec<f32>> {
+    let half = n_fft / 2 + 1;
+    let mel_min = hz_to_mel(fmin);
+    let mel_max = hz_to_mel(fmax);
+    let mel_points: Vec<f32> = (0..n_mels + 2)
+        .map(|idx| mel_min + (mel_max - mel_min) * idx as f32 / (n_mels + 1) as f32)
+        .collect();
+    let hz_points: Vec<f32> = mel_points.iter().map(|m| mel_to_hz(*m)).collect();
+    let bin_points: Vec<f32> = hz_points
+        .iter()
+        .map(|hz| (hz * n_fft as f32 / sample_rate as f32).round())
+        .collect();
+    let mut filters = vec![vec![0.0f32; half]; n_mels];
+    for mel_idx in 0..n_mels {
+        let left = bin_points[mel_idx];
+        let center = bin_points[mel_idx + 1];
+        let right = bin_points[mel_idx + 2];
+        let end = (right as usize).min(half.saturating_sub(1));
+        for (bin, slot) in filters[mel_idx]
+            .iter_mut()
+            .enumerate()
+            .take(end + 1)
+            .skip(left as usize)
+        {
+            let bin_f = bin as f32;
+            let rising = if center > left {
+                (bin_f - left) / (center - left)
+            } else {
+                0.0
+            };
+            let falling = if right > center {
+                (right - bin_f) / (right - center)
+            } else {
+                0.0
+            };
+            let weight = rising.min(falling).max(0.0);
+            *slot = weight;
+        }
+    }
+    filters
+}
+
+fn hz_to_mel(hz: f32) -> f32 {
+    2595.0 * (1.0 + hz / 700.0).log10()
+}
+
+fn mel_to_hz(mel: f32) -> f32 {
+    700.0 * (10.0f32).powf(mel / 2595.0) - 700.0
+}
+
+fn resample_to_target(
+    samples: &[f32],
+    source_rate: u32,
+    config: &MelSpectrogramConfig,
+) -> Vec<f32> {
+    if samples.is_empty() {
+        return Vec::new();
+    }
+    let max_samples = (config.max_audio_seconds * config.sample_rate as f32) as usize;
+    let resampled = if source_rate == config.sample_rate {
+        samples.to_vec()
+    } else {
+        let ratio = config.sample_rate as f64 / source_rate as f64;
+        let output_len = ((samples.len() as f64) * ratio).round() as usize;
+        (0..output_len)
+            .map(|idx| {
+                let source_pos = idx as f64 / ratio;
+                let left = source_pos.floor() as usize;
+                let right = (left + 1).min(samples.len() - 1);
+                let frac = source_pos - left as f64;
+                samples[left] as f64 * (1.0 - frac) + samples[right] as f64 * frac
+            })
+            .map(|value| value as f32)
+            .collect::<Vec<_>>()
+    };
+    if resampled.len() > max_samples {
+        resampled[..max_samples].to_vec()
+    } else {
+        resampled
+    }
+}
+
+/// Decoded mono PCM samples and their source sample rate.
+#[derive(Debug, Clone)]
+struct DecodedAudio {
+    samples: Vec<f32>,
+    sample_rate: u32,
+}
+
+fn decode_wav_mono(path: &Path) -> Result<DecodedAudio> {
+    let bytes = std::fs::read(path).map_err(|err| {
+        AarambhError::Io(std::io::Error::new(
+            err.kind(),
+            format!("failed to read audio {}: {err}", path.display()),
+        ))
+    })?;
+    decode_wav_mono_bytes(&bytes)
+}
+
+fn decode_wav_mono_bytes(bytes: &[u8]) -> Result<DecodedAudio> {
+    let mut cursor = ByteCursor::new(bytes);
+    let riff = cursor.read_tag()?;
+    if riff != *b"RIFF" {
+        return Err(AarambhError::Config(format!(
+            "audio is not a RIFF/WAVE container; got tag {:?}",
+            riff
+        )));
+    }
+    let _riff_size = cursor.read_u32_le()?;
+    let wave = cursor.read_tag()?;
+    if wave != *b"WAVE" {
+        return Err(AarambhError::Config(format!(
+            "audio RIFF container is not WAVE; got {:?}",
+            wave
+        )));
+    }
+    let mut fmt: Option<FmtChunk> = None;
+    let mut data: Option<Vec<u8>> = None;
+    while cursor.remaining() >= 8 {
+        let tag = cursor.read_tag()?;
+        let size = cursor.read_u32_le()? as usize;
+        match &tag {
+            b"fmt " => {
+                fmt = Some(parse_fmt_chunk(cursor.read_bytes(size)?)?);
+            }
+            b"data" => {
+                data = Some(cursor.read_bytes(size)?.to_vec());
+            }
+            _ => {
+                cursor.skip(size)?;
+            }
+        }
+        if size % 2 == 1 {
+            cursor.skip(1)?;
+        }
+    }
+    let fmt = fmt.ok_or_else(|| AarambhError::Config("WAV missing fmt chunk".into()))?;
+    let data = data.ok_or_else(|| AarambhError::Config("WAV missing data chunk".into()))?;
+    let samples = decode_pcm(&data, &fmt)?;
+    Ok(DecodedAudio {
+        samples,
+        sample_rate: fmt.sample_rate,
+    })
+}
+
+#[derive(Debug, Clone, Copy)]
+struct FmtChunk {
+    audio_format: u16,
+    channels: u16,
+    sample_rate: u32,
+    bits_per_sample: u16,
+}
+
+fn parse_fmt_chunk(bytes: &[u8]) -> Result<FmtChunk> {
+    let mut cursor = ByteCursor::new(bytes);
+    let audio_format = cursor.read_u16_le()?;
+    let channels = cursor.read_u16_le()?;
+    let sample_rate = cursor.read_u32_le()?;
+    let _byte_rate = cursor.read_u32_le()?;
+    let _block_align = cursor.read_u16_le()?;
+    let bits_per_sample = cursor.read_u16_le()?;
+    Ok(FmtChunk {
+        audio_format,
+        channels,
+        sample_rate,
+        bits_per_sample,
+    })
+}
+
+fn decode_pcm(data: &[u8], fmt: &FmtChunk) -> Result<Vec<f32>> {
+    if fmt.channels == 0 {
+        return Err(AarambhError::Config("WAV has zero channels".into()));
+    }
+    let bytes_per_sample = (fmt.bits_per_sample as usize).div_ceil(8);
+    let frame_bytes = bytes_per_sample * fmt.channels as usize;
+    if frame_bytes == 0 {
+        return Err(AarambhError::Config(
+            "WAV bits_per_sample and channels imply zero frame bytes".into(),
+        ));
+    }
+    let frame_count = data.len() / frame_bytes;
+    let mut mono = Vec::with_capacity(frame_count);
+    for frame in 0..frame_count {
+        let base = frame * frame_bytes;
+        let mut sum = 0.0f32;
+        for channel in 0..fmt.channels as usize {
+            let offset = base + channel * bytes_per_sample;
+            sum += decode_sample(&data[offset..offset + bytes_per_sample], fmt)?;
+        }
+        mono.push(sum / fmt.channels as f32);
+    }
+    Ok(mono)
+}
+
+fn decode_sample(bytes: &[u8], fmt: &FmtChunk) -> Result<f32> {
+    match (fmt.audio_format, fmt.bits_per_sample) {
+        (1, 8) => Ok((bytes[0] as i32 - 128) as f32 / 128.0),
+        (1, 16) => Ok(read_i16_le(bytes) as f32 / 32_768.0),
+        (1, 24) => Ok(read_i24_le(bytes) as f32 / 8_388_608.0),
+        (1, 32) => Ok(read_i32_le(bytes) as f32 / 2_147_483_648.0),
+        (3, 32) => Ok(read_f32_le(bytes)),
+        (3, 64) => Ok(read_f64_le(bytes) as f32),
+        _ => Err(AarambhError::Config(format!(
+            "unsupported WAV format {}/{}-bit",
+            fmt.audio_format, fmt.bits_per_sample
+        ))),
+    }
+}
+
+fn read_i16_le(bytes: &[u8]) -> i16 {
+    i16::from_le_bytes([bytes[0], bytes[1]])
+}
+
+fn read_i24_le(bytes: &[u8]) -> i32 {
+    let unsigned = u32::from_le_bytes([bytes[0], bytes[1], bytes[2], 0]);
+    let value = unsigned as i32;
+    if value & 0x0080_0000 != 0 {
+        value | 0xFF00_0000u32 as i32
+    } else {
+        value
+    }
+}
+
+fn read_i32_le(bytes: &[u8]) -> i32 {
+    i32::from_le_bytes([bytes[0], bytes[1], bytes[2], bytes[3]])
+}
+
+fn read_f32_le(bytes: &[u8]) -> f32 {
+    f32::from_le_bytes([bytes[0], bytes[1], bytes[2], bytes[3]])
+}
+
+fn read_f64_le(bytes: &[u8]) -> f64 {
+    f64::from_le_bytes([
+        bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6], bytes[7],
+    ])
+}
+
+struct ByteCursor<'a> {
+    bytes: &'a [u8],
+    pos: usize,
+}
+
+impl<'a> ByteCursor<'a> {
+    fn new(bytes: &'a [u8]) -> Self {
+        Self { bytes, pos: 0 }
+    }
+
+    fn remaining(&self) -> usize {
+        self.bytes.len().saturating_sub(self.pos)
+    }
+
+    fn read_tag(&mut self) -> Result<[u8; 4]> {
+        if self.remaining() < 4 {
+            return Err(AarambhError::Config("truncated WAV tag".into()));
+        }
+        let tag = [
+            self.bytes[self.pos],
+            self.bytes[self.pos + 1],
+            self.bytes[self.pos + 2],
+            self.bytes[self.pos + 3],
+        ];
+        self.pos += 4;
+        Ok(tag)
+    }
+
+    fn read_u32_le(&mut self) -> Result<u32> {
+        if self.remaining() < 4 {
+            return Err(AarambhError::Config("truncated WAV u32".into()));
+        }
+        let value = u32::from_le_bytes([
+            self.bytes[self.pos],
+            self.bytes[self.pos + 1],
+            self.bytes[self.pos + 2],
+            self.bytes[self.pos + 3],
+        ]);
+        self.pos += 4;
+        Ok(value)
+    }
+
+    fn read_u16_le(&mut self) -> Result<u16> {
+        if self.remaining() < 2 {
+            return Err(AarambhError::Config("truncated WAV u16".into()));
+        }
+        let value = u16::from_le_bytes([self.bytes[self.pos], self.bytes[self.pos + 1]]);
+        self.pos += 2;
+        Ok(value)
+    }
+
+    fn read_bytes(&mut self, count: usize) -> Result<&'a [u8]> {
+        if self.remaining() < count {
+            return Err(AarambhError::Config(format!(
+                "truncated WAV chunk: requested {count} bytes, have {}",
+                self.remaining()
+            )));
+        }
+        let slice = &self.bytes[self.pos..self.pos + count];
+        self.pos += count;
+        Ok(slice)
+    }
+
+    fn skip(&mut self, count: usize) -> Result<()> {
+        if self.remaining() < count {
+            return Err(AarambhError::Config("truncated WAV padding".into()));
+        }
+        self.pos += count;
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn synth_wav_bytes(sample_rate: u32, frequency: f32, duration_secs: f32) -> Vec<u8> {
+        let sample_count = (duration_secs * sample_rate as f32) as usize;
+        let mut data = Vec::with_capacity(sample_count * 2);
+        for idx in 0..sample_count {
+            let t = idx as f32 / sample_rate as f32;
+            let value = (2.0 * std::f32::consts::PI * frequency * t).sin();
+            let pcm = (value * 32_767.0) as i16;
+            data.extend_from_slice(&pcm.to_le_bytes());
+        }
+        let mut bytes = Vec::new();
+        let riff_size = 12 + 24 + 8 + data.len() as u32;
+        bytes.extend_from_slice(b"RIFF");
+        bytes.extend_from_slice(&riff_size.to_le_bytes());
+        bytes.extend_from_slice(b"WAVE");
+        bytes.extend_from_slice(b"fmt ");
+        bytes.extend_from_slice(&16u32.to_le_bytes());
+        bytes.extend_from_slice(&1u16.to_le_bytes()); // PCM
+        bytes.extend_from_slice(&1u16.to_le_bytes()); // mono
+        bytes.extend_from_slice(&sample_rate.to_le_bytes());
+        let byte_rate = sample_rate * 2;
+        bytes.extend_from_slice(&byte_rate.to_le_bytes());
+        bytes.extend_from_slice(&2u16.to_le_bytes()); // block align
+        bytes.extend_from_slice(&16u16.to_le_bytes()); // bits per sample
+        bytes.extend_from_slice(b"data");
+        bytes.extend_from_slice(&(data.len() as u32).to_le_bytes());
+        bytes.extend_from_slice(&data);
+        bytes
+    }
+
+    #[test]
+    fn mel_config_max_frames_is_consistent() {
+        let config = MelSpectrogramConfig {
+            sample_rate: 16_000,
+            n_fft: 512,
+            hop_length: 256,
+            n_mels: 80,
+            fmin: 0.0,
+            fmax: 8000.0,
+            max_audio_seconds: 1.0,
+            power: 2.0,
+            log_eps: 1.0e-10,
+        };
+        config.validate().unwrap();
+        // 16000 samples, 512 window, 256 hop -> (16000-512)/256 + 1 = 61 frames
+        assert_eq!(config.max_frames(), 61);
+    }
+
+    #[test]
+    fn fft_recovers_known_frequency() {
+        let n = 512usize;
+        let frequency = 4usize;
+        let frame: Vec<f32> = (0..n)
+            .map(|idx| {
+                (2.0 * std::f32::consts::PI * frequency as f32 * idx as f32 / n as f32).sin()
+            })
+            .collect();
+        let spectrum = fft_power(&frame);
+        let peak = spectrum
+            .iter()
+            .enumerate()
+            .max_by(|a, b| a.1.partial_cmp(b.1).unwrap())
+            .map(|(idx, _)| idx)
+            .unwrap();
+        assert_eq!(peak, frequency);
+    }
+
+    #[test]
+    fn preprocess_path_returns_expected_mel_shape() {
+        let bytes = synth_wav_bytes(16_000, 440.0, 0.5);
+        let temp = std::env::temp_dir().join("aarambh_audio_smoke.wav");
+        std::fs::write(&temp, &bytes).unwrap();
+        let config = MelSpectrogramConfig {
+            sample_rate: 16_000,
+            n_fft: 512,
+            hop_length: 256,
+            n_mels: 40,
+            fmin: 0.0,
+            fmax: 8000.0,
+            max_audio_seconds: 1.0,
+            power: 2.0,
+            log_eps: 1.0e-10,
+        };
+        let pre = AudioPreprocessor::new(config).unwrap();
+        let tensor = pre.preprocess_path(&temp, &Device::Cpu).unwrap();
+        assert_eq!(tensor.dims(), &[40, 61]);
+        let _ = std::fs::remove_file(&temp);
+    }
+
+    #[test]
+    fn preprocess_bytes_handles_stereo_float() {
+        // Build a minimal 32-bit float stereo WAV.
+        let sample_rate = 16_000u32;
+        let sample_count = 4usize;
+        let mut data = Vec::with_capacity(sample_count * 8);
+        for idx in 0..sample_count {
+            let value = (idx as f32) / 4.0;
+            data.extend_from_slice(&value.to_le_bytes());
+            data.extend_from_slice(&value.to_le_bytes());
+        }
+        let mut bytes = Vec::new();
+        let riff_size = 12 + 24 + 8 + data.len() as u32;
+        bytes.extend_from_slice(b"RIFF");
+        bytes.extend_from_slice(&riff_size.to_le_bytes());
+        bytes.extend_from_slice(b"WAVE");
+        bytes.extend_from_slice(b"fmt ");
+        bytes.extend_from_slice(&16u32.to_le_bytes());
+        bytes.extend_from_slice(&3u16.to_le_bytes()); // IEEE float
+        bytes.extend_from_slice(&2u16.to_le_bytes()); // stereo
+        bytes.extend_from_slice(&sample_rate.to_le_bytes());
+        let byte_rate = sample_rate * 8;
+        bytes.extend_from_slice(&byte_rate.to_le_bytes());
+        bytes.extend_from_slice(&8u16.to_le_bytes()); // block align
+        bytes.extend_from_slice(&32u16.to_le_bytes()); // bits per sample
+        bytes.extend_from_slice(b"data");
+        bytes.extend_from_slice(&(data.len() as u32).to_le_bytes());
+        bytes.extend_from_slice(&data);
+        let config = MelSpectrogramConfig {
+            n_fft: 4,
+            hop_length: 2,
+            n_mels: 8,
+            sample_rate,
+            fmin: 0.0,
+            fmax: 8000.0,
+            max_audio_seconds: 0.001,
+            power: 2.0,
+            log_eps: 1.0e-10,
+        };
+        let pre = AudioPreprocessor::new(config).unwrap();
+        let tensor = pre.preprocess_bytes(&bytes, &Device::Cpu).unwrap();
+        assert!(tensor.dims().iter().product::<usize>() > 0);
+    }
+
+    #[test]
+    fn rejects_non_power_of_two_fft() {
+        let config = MelSpectrogramConfig {
+            n_fft: 300,
+            ..MelSpectrogramConfig::default()
+        };
+        assert!(config.validate().is_err());
+    }
+}
diff --git a/crates/aarambh-studio-audio/src/projector.rs b/crates/aarambh-studio-audio/src/projector.rs
new file mode 100644
index 0000000..118a5f7
--- /dev/null
+++ b/crates/aarambh-studio-audio/src/projector.rs
@@ -0,0 +1,137 @@
+//! Trainable audio-to-language projector.
+//!
+//! Mirrors `aarambh_studio_vision::VisionProjector` exactly in structure: a
+//! two-layer GELU MLP that maps audio encoder patch tokens into the language
+//! model's hidden width. Only this projector (and the DoRA-adapted LLM, in the
+//! second training stage) receives gradients — the frozen encoder never does.
+
+use aarambh_studio_core::{AarambhError, Result};
+use candle_core::Tensor;
+use candle_nn::{Linear, Module, VarBuilder, linear};
+use serde::{Deserialize, Serialize};
+
+/// Configuration for the trainable audio-to-language projector.
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(default)]
+pub struct AudioProjectorConfig {
+    /// Width of patch embeddings emitted by the audio encoder.
+    pub audio_d_model: usize,
+    /// Width of the language model hidden states.
+    pub llm_d_model: usize,
+    /// Multiplier for the hidden layer width.
+    pub hidden_mult: usize,
+}
+
+impl Default for AudioProjectorConfig {
+    fn default() -> Self {
+        Self {
+            audio_d_model: 768,
+            llm_d_model: 768,
+            hidden_mult: 4,
+        }
+    }
+}
+
+impl AudioProjectorConfig {
+    /// Validate projector dimensions.
+    pub fn validate(&self) -> Result<()> {
+        if self.audio_d_model == 0 || self.llm_d_model == 0 || self.hidden_mult == 0 {
+            return Err(AarambhError::Config(
+                "projector audio_d_model, llm_d_model, and hidden_mult must be non-zero".into(),
+            ));
+        }
+        Ok(())
+    }
+
+    /// Return the hidden layer width.
+    pub fn hidden_dim(&self) -> usize {
+        self.llm_d_model * self.hidden_mult
+    }
+}
+
+/// Two-layer GELU MLP that maps audio patch tokens into LLM token width.
+#[derive(Debug, Clone)]
+pub struct AudioProjector {
+    config: AudioProjectorConfig,
+    fc1: Linear,
+    fc2: Linear,
+}
+
+impl AudioProjector {
+    /// Build a projector from a Candle variable builder.
+    pub fn new(config: AudioProjectorConfig, vb: VarBuilder<'_>) -> Result<Self> {
+        config.validate()?;
+        let fc1 = linear(config.audio_d_model, config.hidden_dim(), vb.pp("fc1"))?;
+        let fc2 = linear(config.hidden_dim(), config.llm_d_model, vb.pp("fc2"))?;
+        Ok(Self { config, fc1, fc2 })
+    }
+
+    /// Load a projector checkpoint from SafeTensors.
+    pub fn load_safetensors(
+        path: impl AsRef<std::path::Path>,
+        config: AudioProjectorConfig,
+        device: &candle_core::Device,
+        dtype: candle_core::DType,
+    ) -> Result<Self> {
+        // SAFETY: The checkpoint mapping is read-only and is consumed while the
+        // projector creates its owned parameter tensors.
+        let vb = unsafe { VarBuilder::from_mmaped_safetensors(&[path.as_ref()], dtype, device)? };
+        Self::new(config, vb)
+    }
+
+    /// Return the projector configuration.
+    pub fn config(&self) -> &AudioProjectorConfig {
+        &self.config
+    }
+
+    /// Return the first projection layer (used by Phase 42 gradient tests).
+    pub fn fc1(&self) -> &Linear {
+        &self.fc1
+    }
+
+    /// Return the second projection layer (used by Phase 42 gradient tests).
+    pub fn fc2(&self) -> &Linear {
+        &self.fc2
+    }
+
+    /// Project `[batch, audio_tokens, audio_d_model]` into LLM hidden states.
+    pub fn forward(&self, patch_tokens: &Tensor) -> Result<Tensor> {
+        let dims = patch_tokens.dims();
+        if dims.len() != 3 {
+            return Err(AarambhError::Shape(format!(
+                "patch_tokens must have shape [batch, tokens, audio_d_model], got {dims:?}"
+            )));
+        }
+        if dims[2] != self.config.audio_d_model {
+            return Err(AarambhError::Shape(format!(
+                "audio patch token width {} does not match projector audio_d_model {}",
+                dims[2], self.config.audio_d_model
+            )));
+        }
+        let hidden = self.fc1.forward(patch_tokens)?.gelu()?;
+        Ok(self.fc2.forward(&hidden)?)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use candle_core::{DType, Device, Tensor};
+    use candle_nn::{VarBuilder, VarMap};
+
+    #[test]
+    fn projector_outputs_llm_width() {
+        let device = Device::Cpu;
+        let config = AudioProjectorConfig {
+            audio_d_model: 8,
+            llm_d_model: 16,
+            hidden_mult: 2,
+        };
+        let varmap = VarMap::new();
+        let vb = VarBuilder::from_varmap(&varmap, DType::F32, &device);
+        let projector = AudioProjector::new(config, vb).unwrap();
+        let input = Tensor::zeros((2, 3, 8), DType::F32, &device).unwrap();
+        let output = projector.forward(&input).unwrap();
+        assert_eq!(output.dims(), &[2, 3, 16]);
+    }
+}
diff --git a/crates/aarambh-studio-eval/Cargo.toml b/crates/aarambh-studio-eval/Cargo.toml
index d871dbd..11dac40 100644
--- a/crates/aarambh-studio-eval/Cargo.toml
+++ b/crates/aarambh-studio-eval/Cargo.toml
@@ -9,6 +9,7 @@ rust-version.workspace = true
 default = []
 cuda = [
     "aarambh-studio-agent/cuda",
+    "aarambh-studio-audio/cuda",
     "aarambh-studio-core/cuda",
     "aarambh-studio-finetune/cuda",
     "aarambh-studio-model/cuda",
@@ -20,6 +21,7 @@ cuda = [
 
 [dependencies]
 aarambh-studio-agent     = { path = "../aarambh-studio-agent" }
+aarambh-studio-audio     = { path = "../aarambh-studio-audio" }
 aarambh-studio-core      = { path = "../aarambh-studio-core" }
 aarambh-studio-finetune  = { path = "../aarambh-studio-finetune" }
 aarambh-studio-inference = { path = "../aarambh-studio-inference" }
diff --git a/crates/aarambh-studio-eval/src/harness.rs b/crates/aarambh-studio-eval/src/harness.rs
index 8176ef6..aa640fc 100644
--- a/crates/aarambh-studio-eval/src/harness.rs
+++ b/crates/aarambh-studio-eval/src/harness.rs
@@ -9,9 +9,9 @@ use candle_core::{DType, Device};
 
 use crate::report::{Scorecard, TaskScore};
 use crate::tasks::{
-    AssociativeRecallTask, DocumentQaTask, Gsm8kSubsetTask, HardProblemsTask, HellaSwagTask,
-    HumanEvalLiteTask, ImageCaptionTask, MmluLiteTask, PplTask, PreferenceTask, ToolCallingTask,
-    ToolChainTask, VideoQaTask, VqaTask,
+    AssociativeRecallTask, AudioQaTask, DocumentQaTask, Gsm8kSubsetTask, HardProblemsTask,
+    HellaSwagTask, HumanEvalLiteTask, ImageCaptionTask, MmluLiteTask, PplTask, PreferenceTask,
+    ToolCallingTask, ToolChainTask, VideoQaTask, VqaTask,
 };
 
 /// Evaluation run configuration.
@@ -188,6 +188,9 @@ fn selected_tasks(selectors: &[String], allow_code_exec: bool) -> Result<Vec<Box
             }
             "document-qa" | "document_qa" | "docvqa" | "document-qa-smoke"
             | "document_qa_smoke" => tasks.push(Box::new(DocumentQaTask)),
+            "audio-qa" | "audio_qa" | "audio-qa-smoke" | "audio_qa_smoke" => {
+                tasks.push(Box::new(AudioQaTask));
+            }
             "preference" | "dpo" | "preference-win-rate" | "preference_win_rate" => {
                 tasks.push(Box::new(PreferenceTask));
             }
@@ -201,7 +204,7 @@ fn selected_tasks(selectors: &[String], allow_code_exec: bool) -> Result<Vec<Box
             }
             other => {
                 return Err(AarambhError::Config(format!(
-                    "unknown eval task '{other}', expected ppl,mmlu,hellaswag,gsm8k,hard-problems,humaneval,preference,image-caption,vqa,video-qa,document-qa,tool-calling,tool-chain,associative-recall,all"
+                    "unknown eval task '{other}', expected ppl,mmlu,hellaswag,gsm8k,hard-problems,humaneval,preference,image-caption,vqa,video-qa,document-qa,audio-qa,tool-calling,tool-chain,associative-recall,all"
                 )));
             }
         }
diff --git a/crates/aarambh-studio-eval/src/tasks/audio_qa.rs b/crates/aarambh-studio-eval/src/tasks/audio_qa.rs
new file mode 100644
index 0000000..624f4f4
--- /dev/null
+++ b/crates/aarambh-studio-eval/src/tasks/audio_qa.rs
@@ -0,0 +1,182 @@
+//! Native audio question-answering evaluation task (Phase 42).
+//!
+//! Mirrors `video_qa::VideoQaTask`: loads audio instruction examples from JSONL,
+//! encodes each clip with the frozen audio encoder, projects patch tokens into
+//! the language model's hidden width, splices them into the prompt at the
+//! `<audio>` placeholder, greedy-decodes, and scores the normalized answer.
+
+use std::path::{Path, PathBuf};
+
+use aarambh_studio_audio::{
+    AudioEncoderConfig, AudioModel, AudioPreprocessor, AudioProjector, AudioProjectorConfig,
+    FrozenAudioEncoder, interleave_audio_tokens, load_audio_qa_jsonl,
+};
+use aarambh_studio_core::{AarambhError, Result, TokenizerLike};
+use aarambh_studio_tokenizer::{AUDIO, AUDIO_END, AUDIO_ID};
+use aarambh_studio_train::TrainingRunConfig;
+use candle_core::Tensor;
+
+use crate::harness::{EvalConfig, EvalContext, EvalTask};
+use crate::report::TaskScore;
+use crate::tasks::first_existing;
+use crate::tasks::vqa::greedy_generate_from_embeddings;
+
+/// Audio question-answering evaluation task.
+pub struct AudioQaTask;
+
+impl EvalTask for AudioQaTask {
+    fn name(&self) -> &'static str {
+        "audio-qa"
+    }
+
+    fn run(&self, context: &EvalContext, config: &EvalConfig) -> Result<TaskScore> {
+        let data_path = first_existing(&[
+            config.data_dir.join("audio_qa").join("data.jsonl"),
+            config.data_dir.join("audio_qa_smoke").join("data.jsonl"),
+            config.data_dir.join("audio_qa.jsonl"),
+        ])?;
+        let examples = load_audio_qa_jsonl(&data_path, config.max_examples)?;
+        let config_path = config
+            .config_path
+            .as_ref()
+            .ok_or_else(|| AarambhError::Config("audio QA eval requires --config".into()))?;
+        let run_config = TrainingRunConfig::from_toml(config_path)?;
+        let audio_config = run_config
+            .vision
+            .as_ref()
+            .and_then(|vision| vision.audio.as_ref())
+            .ok_or_else(|| AarambhError::Config("audio QA eval requires [vision.audio]".into()))?;
+        audio_config.validate()?;
+        context.tokenizer().validate_audio_special_tokens()?;
+        let runtime = load_audio_runtime(context, &run_config)?;
+        let data_root = data_path
+            .parent()
+            .map(Path::to_path_buf)
+            .unwrap_or_else(|| config.data_dir.clone());
+        let mut passed = 0usize;
+        for example in &examples {
+            let path =
+                resolve_audio_path(&audio_config.audio_root, &data_root, &example.audio_path);
+            let prompt = audio_prompt(&format!("{}\n{}\n", example.question, example.answer));
+            let prompt_ids = context.tokenizer().encode(&prompt)?;
+            if prompt_ids.is_empty() {
+                return Err(AarambhError::Config(
+                    "audio QA prompt produced no tokens".into(),
+                ));
+            }
+            let text =
+                Tensor::from_vec(prompt_ids.clone(), (1, prompt_ids.len()), context.device())?;
+            let text_embeddings = context.model().embed_tokens(&text)?;
+            let spectrogram = runtime
+                .preprocess
+                .preprocess_path(&path, context.device())?
+                .unsqueeze(0)?;
+            let audio_tokens = runtime.model.forward(&spectrogram)?;
+            let embeddings =
+                interleave_audio_tokens(&prompt_ids, &text_embeddings, &audio_tokens, AUDIO_ID)?;
+            let output =
+                greedy_generate_from_embeddings(context, &embeddings, config.max_new_tokens)?;
+            if normalize_answer(&output) == normalize_answer(&example.answer) {
+                passed += 1;
+            }
+        }
+        Ok(TaskScore::accuracy("audio-qa", passed, examples.len()))
+    }
+}
+
+struct AudioRuntime {
+    model: AudioModel,
+    preprocess: AudioPreprocessor,
+}
+
+fn load_audio_runtime(
+    context: &EvalContext,
+    run_config: &TrainingRunConfig,
+) -> Result<AudioRuntime> {
+    let vision = run_config.vision.as_ref().ok_or_else(|| {
+        AarambhError::Config("audio QA eval requires a [vision] config block".into())
+    })?;
+    let audio = vision.audio.as_ref().ok_or_else(|| {
+        AarambhError::Config("audio QA eval requires a [vision.audio] block".into())
+    })?;
+    let encoder_config = AudioEncoderConfig::from_json(&audio.encoder_config_path)?;
+    let encoder = FrozenAudioEncoder::load_pretrained(
+        &audio.encoder_weights_path,
+        encoder_config.clone(),
+        context.device(),
+        context.dtype(),
+    )?;
+    let projector_path = vision.projector_path.as_ref().ok_or_else(|| {
+        AarambhError::Config("audio QA eval requires vision.projector_path".into())
+    })?;
+    let projector_config = AudioProjectorConfig {
+        audio_d_model: encoder_config.audio_d_model,
+        llm_d_model: run_config.model.hidden_dim,
+        hidden_mult: vision.projector_hidden_mult,
+    };
+    let projector = AudioProjector::load_safetensors(
+        projector_path,
+        projector_config,
+        context.device(),
+        context.dtype(),
+    )?;
+    let preprocess = AudioPreprocessor::new(audio.mel.clone())?;
+    Ok(AudioRuntime {
+        model: AudioModel::new(encoder, projector),
+        preprocess,
+    })
+}
+
+fn audio_prompt(prompt: &str) -> String {
+    if prompt.contains(AUDIO) {
+        prompt.to_string()
+    } else {
+        format!("{AUDIO}{AUDIO_END}\n{prompt}")
+    }
+}
+
+fn resolve_audio_path(config_root: &Path, data_root: &Path, path: &Path) -> PathBuf {
+    if path.is_absolute() {
+        return path.to_path_buf();
+    }
+    let configured = config_root.join(path);
+    if configured.exists() {
+        configured
+    } else {
+        data_root.join(path)
+    }
+}
+
+fn normalize_answer(value: &str) -> String {
+    value
+        .trim()
+        .to_ascii_lowercase()
+        .chars()
+        .filter(char::is_ascii_alphanumeric)
+        .collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn audio_prompt_inserts_placeholder_when_missing() {
+        let prompt = audio_prompt("What sound is this?");
+        assert!(prompt.contains(AUDIO));
+        assert!(prompt.contains(AUDIO_END));
+        assert!(prompt.contains("What sound is this?"));
+    }
+
+    #[test]
+    fn audio_prompt_preserves_existing_placeholder() {
+        let prompt = audio_prompt(&format!("{AUDIO} describe"));
+        assert_eq!(prompt.matches(AUDIO).count(), 1);
+    }
+
+    #[test]
+    fn answer_normalization_strips_punctuation_and_case() {
+        assert_eq!(normalize_answer(" A.\n"), "a");
+        assert_eq!(normalize_answer("Beep!"), "beep");
+    }
+}
diff --git a/crates/aarambh-studio-eval/src/tasks/mod.rs b/crates/aarambh-studio-eval/src/tasks/mod.rs
index a24f533..5caebad 100644
--- a/crates/aarambh-studio-eval/src/tasks/mod.rs
+++ b/crates/aarambh-studio-eval/src/tasks/mod.rs
@@ -6,6 +6,8 @@ use serde::de::DeserializeOwned;
 
 /// Associative key-value recall task.
 pub mod associative_recall;
+/// Native audio question-answering task (Phase 42).
+pub mod audio_qa;
 /// Native document question-answering task.
 pub mod document_qa;
 /// GSM8K subset task.
@@ -34,6 +36,7 @@ pub mod video_qa;
 pub mod vqa;
 
 pub use associative_recall::AssociativeRecallTask;
+pub use audio_qa::AudioQaTask;
 pub use document_qa::DocumentQaTask;
 pub use gsm8k_subset::Gsm8kSubsetTask;
 pub use hard_problems::HardProblemsTask;
diff --git a/crates/aarambh-studio-finetune/Cargo.toml b/crates/aarambh-studio-finetune/Cargo.toml
index 3540ce9..db566e6 100644
--- a/crates/aarambh-studio-finetune/Cargo.toml
+++ b/crates/aarambh-studio-finetune/Cargo.toml
@@ -8,6 +8,7 @@ rust-version.workspace = true
 [features]
 default = []
 cuda = [
+    "aarambh-studio-audio/cuda",
     "aarambh-studio-core/cuda",
     "aarambh-studio-kernel/cuda",
     "aarambh-studio-model/cuda",
@@ -21,6 +22,7 @@ cuda = [
 ]
 
 [dependencies]
+aarambh-studio-audio     = { path = "../aarambh-studio-audio" }
 aarambh-studio-core      = { path = "../aarambh-studio-core" }
 aarambh-studio-kernel    = { path = "../aarambh-studio-kernel" }
 aarambh-studio-model     = { path = "../aarambh-studio-model" }
diff --git a/crates/aarambh-studio-finetune/src/lib.rs b/crates/aarambh-studio-finetune/src/lib.rs
index 9256f4d..a535dae 100644
--- a/crates/aarambh-studio-finetune/src/lib.rs
+++ b/crates/aarambh-studio-finetune/src/lib.rs
@@ -63,7 +63,7 @@ pub use verifier::{
     extract_final_number,
 };
 pub use vlm_dora::{
-    DocumentVlmDoraRunConfig, VideoVlmDoraRunConfig, VlmDoraMetrics, VlmDoraRunConfig,
-    VlmDoraTrainer, run_document_vlm_dora_from_config, run_video_vlm_dora_from_config,
-    run_vlm_dora_from_config,
+    AudioVlmDoraRunConfig, DocumentVlmDoraRunConfig, VideoVlmDoraRunConfig, VlmDoraMetrics,
+    VlmDoraRunConfig, VlmDoraTrainer, run_audio_vlm_dora_from_config,
+    run_document_vlm_dora_from_config, run_video_vlm_dora_from_config, run_vlm_dora_from_config,
 };
diff --git a/crates/aarambh-studio-finetune/src/vlm_dora.rs b/crates/aarambh-studio-finetune/src/vlm_dora.rs
index b0177cd..c2bbe5f 100644
--- a/crates/aarambh-studio-finetune/src/vlm_dora.rs
+++ b/crates/aarambh-studio-finetune/src/vlm_dora.rs
@@ -2,15 +2,19 @@ use std::fs;
 use std::path::{Path, PathBuf};
 use std::time::Instant;
 
+use aarambh_studio_audio::{
+    AudioEncoderConfig, AudioPreprocessor, AudioProjector, AudioProjectorConfig, AudioQaExample,
+    FrozenAudioEncoder, interleave_audio_tokens, load_audio_qa_jsonl,
+};
 use aarambh_studio_core::{AarambhError, Device, ModelConfig, Result, TokenizerLike, TrainConfig};
 use aarambh_studio_tokenizer::{
-    BpeTokenizer, DOCUMENT, DOCUMENT_END, DOCUMENT_ID, FRAME_SEP, FRAME_SEP_ID, IMAGE, IMAGE_END,
-    IMAGE_ID, PAGE_SEP, PAGE_SEP_ID, VIDEO, VIDEO_END, VIDEO_ID,
+    AUDIO, AUDIO_END, AUDIO_ID, BpeTokenizer, DOCUMENT, DOCUMENT_END, DOCUMENT_ID, FRAME_SEP,
+    FRAME_SEP_ID, IMAGE, IMAGE_END, IMAGE_ID, PAGE_SEP, PAGE_SEP_ID, VIDEO, VIDEO_END, VIDEO_ID,
 };
 use aarambh_studio_train::optim::clip_gradients;
 use aarambh_studio_train::{
-    AdamW, AdamWConfig, CosineScheduleWithWarmup, DocumentTrainingConfig, GradMap, TrainState,
-    VideoTrainingConfig, VisionTrainingConfig, cross_entropy_loss,
+    AdamW, AdamWConfig, AudioTrainingConfig, CosineScheduleWithWarmup, DocumentTrainingConfig,
+    GradMap, TrainState, VideoTrainingConfig, VisionTrainingConfig, cross_entropy_loss,
 };
 use aarambh_studio_vision::{
     ClipVisionEncoder, DocQaExample, DocumentFeatureCache, DocumentFeatureCacheKey, DocumentSource,
@@ -81,6 +85,13 @@ pub struct DocumentVlmDoraRunConfig {
     pub vlm: VlmDoraRunConfig,
 }
 
+/// Configuration for audio-language DoRA instruction tuning (Phase 42).
+#[derive(Debug, Clone)]
+pub struct AudioVlmDoraRunConfig {
+    /// Shared VLM model, optimizer, vision, and audio paths.
+    pub vlm: VlmDoraRunConfig,
+}
+
 /// Metrics emitted by a VLM DoRA optimizer step.
 #[derive(Debug, Clone)]
 pub struct VlmDoraMetrics {
@@ -1234,6 +1245,323 @@ pub fn run_document_vlm_dora_from_config(config: DocumentVlmDoraRunConfig) -> Re
     trainer.train()
 }
 
+/// Build and run an audio-language DoRA trainer (Phase 42).
+///
+/// Mirrors the two-stage frozen-encoder-plus-trainable-projector recipe v2 §25
+/// established for vision, substituting audio for image. The frozen audio
+/// spectrogram transformer encodes each clip into detached patch embeddings; a
+/// trainable projector maps them into the decoder's hidden width; the result is
+/// spliced into the token sequence at the `<audio>` placeholder. The DoRA-adapted
+/// LLM and the projector train together on the audio-QA target.
+pub fn run_audio_vlm_dora_from_config(config: AudioVlmDoraRunConfig) -> Result<()> {
+    let config = config.vlm;
+    config.lora_config.validate()?;
+    let audio_config = config.vision.audio.clone().ok_or_else(|| {
+        AarambhError::Config("audio VLM training requires a [vision.audio] config block".into())
+    })?;
+    audio_config.validate()?;
+    let candle_device = config.device.to_candle()?;
+    let tokenizer = BpeTokenizer::from_pretrained(&config.tokenizer_path)?;
+    tokenizer.validate_audio_special_tokens()?;
+    let mut model_config = config.model_config.clone();
+    model_config.vocab_size = tokenizer.vocab_size();
+    if model_config.moe.is_some() {
+        return Err(AarambhError::Config(
+            "audio VLM DoRA training currently requires a dense base model".into(),
+        ));
+    }
+
+    let base = aarambh_studio_weights::load_any_model_with_dtype(
+        &config.base_model_path,
+        &model_config,
+        &candle_device,
+        config.dtype,
+    )?;
+    let base_tensors = base.named_tensors();
+    drop(base);
+    let (model, dora_varmap) = DoraAarambhModel::from_tensors(
+        &model_config,
+        &base_tensors,
+        &config.lora_config,
+        config.qdora,
+        &candle_device,
+    )?;
+    eprintln!(
+        "audio VLM adapter params: {} / {} ({:.3}%)",
+        model.adapter_param_count(),
+        model.base_param_count(),
+        model.trainable_ratio() * 100.0
+    );
+
+    let encoder_config = AudioEncoderConfig::from_json(&audio_config.encoder_config_path)?;
+    let encoder = FrozenAudioEncoder::load_pretrained(
+        &audio_config.encoder_weights_path,
+        encoder_config.clone(),
+        &candle_device,
+        config.dtype,
+    )?;
+    let preprocess = AudioPreprocessor::new(audio_config.mel.clone())?;
+    let projector_varmap = VarMap::new();
+    let projector_vb = VarBuilder::from_varmap(&projector_varmap, config.dtype, &candle_device);
+    let projector = AudioProjector::new(
+        AudioProjectorConfig {
+            audio_d_model: encoder_config.audio_d_model,
+            llm_d_model: model_config.hidden_dim,
+            hidden_mult: config.vision.projector_hidden_mult,
+        },
+        projector_vb,
+    )?;
+    let mut projector_varmap = projector_varmap;
+    projector_varmap.load(&config.projector_path)?;
+
+    let examples = load_audio_qa_jsonl(&config.data_path, config.vision.max_samples)?;
+    let metadata = AdapterMetadata::new_with_method(
+        model_config.clone(),
+        config.lora_config.clone(),
+        Some(config.base_model_path.display().to_string()),
+        config.qdora,
+        AdapterMethod::Dora,
+    );
+    let mut dora_optimizer =
+        AdamW::from_varmap(&dora_varmap, AdamWConfig::from(&config.train_config))?;
+    if dora_optimizer.parameters().is_empty() {
+        return Err(AarambhError::Config(
+            "audio VLM DoRA target_modules produced zero trainable tensors".into(),
+        ));
+    }
+    let mut projector_optimizer = if config.train_projector {
+        Some(AdamW::from_varmap(
+            &projector_varmap,
+            AdamWConfig::from(&config.train_config),
+        )?)
+    } else {
+        None
+    };
+    let schedule = CosineScheduleWithWarmup::new(
+        config.train_config.lr,
+        config.train_config.warmup_steps,
+        config.train_config.max_steps,
+        config.train_config.min_lr_ratio,
+    );
+    let mut rng = StdRng::seed_from_u64(config.train_config.seed);
+    let mut examples = examples;
+    if config.shuffle {
+        examples.shuffle(&mut rng);
+    }
+    let output_dir = config.output_dir.clone();
+    fs::create_dir_all(&output_dir)?;
+    let mut dora_pending = GradMap::new();
+    let mut projector_pending = GradMap::new();
+    let mut step = 0usize;
+    let mut example_idx = 0usize;
+    let mut last_loss = 0.0f64;
+    while step < config.train_config.max_steps {
+        let example = &examples[example_idx % examples.len()];
+        example_idx += 1;
+        let loss = audio_example_loss(
+            &model,
+            &encoder,
+            &preprocess,
+            &projector,
+            &tokenizer,
+            &audio_config,
+            example,
+            &candle_device,
+            model_config.max_seq_len,
+        )?;
+        last_loss = loss.to_scalar::<f32>()? as f64;
+        let scaled = (loss / config.train_config.grad_accum_steps as f64)?;
+        let grads = scaled.backward()?;
+        accumulate_for_optimizer(&grads, &dora_optimizer, &mut dora_pending, "audio DoRA")?;
+        if let Some(projector_optimizer) = projector_optimizer.as_ref() {
+            accumulate_for_optimizer(
+                &grads,
+                projector_optimizer,
+                &mut projector_pending,
+                "audio projector",
+            )?;
+        }
+        if example_idx.is_multiple_of(config.train_config.grad_accum_steps) {
+            let lr = schedule.lr_at_step(step);
+            clip_gradients(&mut dora_pending, config.train_config.clip_grad_norm)?;
+            dora_optimizer.step(&dora_pending, lr)?;
+            dora_pending.clear();
+            if let Some(projector_optimizer) = projector_optimizer.as_mut() {
+                clip_gradients(&mut projector_pending, config.train_config.clip_grad_norm)?;
+                projector_optimizer.step(&projector_pending, lr)?;
+                projector_pending.clear();
+            }
+            step += 1;
+            if config.train_config.log_every_n_steps > 0
+                && step.is_multiple_of(config.train_config.log_every_n_steps)
+            {
+                println!(
+                    "audio_vlm_dora step={} loss={:.4} ppl={:.2} lr={:.6}",
+                    step,
+                    last_loss,
+                    last_loss.exp(),
+                    lr
+                );
+            }
+        }
+    }
+    save_adapter(&dora_varmap, &metadata, &output_dir)?;
+    projector_varmap.save(output_dir.join("projector.safetensors"))?;
+    let vlm_metadata = AudioVlmArtifactsMetadata {
+        format_version: 1,
+        projector_path: "projector.safetensors".into(),
+        train_projector: config.train_projector,
+        base_projector_path: config.projector_path.display().to_string(),
+        encoder_config_path: audio_config.encoder_config_path.display().to_string(),
+        encoder_weights_path: audio_config.encoder_weights_path.display().to_string(),
+        audio_root: audio_config.audio_root.display().to_string(),
+        mel: audio_config.mel.clone(),
+    };
+    let metadata_json = serde_json::to_string_pretty(&vlm_metadata)?;
+    fs::write(output_dir.join("audio_adapter_config.json"), metadata_json)?;
+    eprintln!(
+        "audio VLM DoRA training complete: {} steps, final loss {last_loss:.4}",
+        config.train_config.max_steps
+    );
+    Ok(())
+}
+
+#[allow(clippy::too_many_arguments)]
+fn audio_example_loss(
+    model: &DoraAarambhModel,
+    encoder: &FrozenAudioEncoder,
+    preprocess: &AudioPreprocessor,
+    projector: &AudioProjector,
+    tokenizer: &BpeTokenizer,
+    audio_config: &AudioTrainingConfig,
+    example: &AudioQaExample,
+    device: &candle_core::Device,
+    max_seq_len: usize,
+) -> Result<Tensor> {
+    let audio_path = resolve_media_path(&audio_config.audio_root, &example.audio_path);
+    let spectrogram = preprocess
+        .preprocess_path(&audio_path, device)?
+        .unsqueeze(0)?;
+    let patch_tokens = encoder.forward(&spectrogram)?.detach();
+    let projected = projector.forward(&patch_tokens)?;
+    let patch_count = projected.dims()[1];
+    if patch_count == 0 || patch_count > max_seq_len {
+        return Err(AarambhError::Shape(format!(
+            "audio patch count {patch_count} is invalid for max_seq_len {max_seq_len}"
+        )));
+    }
+    let template = ChatTemplate;
+    let prefix = format!(
+        "{AUDIO}{AUDIO_END}\n{}",
+        template.prefix(&example.question, None)
+    );
+    let target = match example.thinking.as_deref() {
+        Some(thinking) => template.thinking_target(thinking, &example.answer),
+        None => template.target(&example.answer),
+    };
+    let prefix_ids = tokenizer.encode(&prefix)?;
+    if !prefix_ids.contains(&AUDIO_ID) {
+        return Err(AarambhError::Tokenizer(
+            "audio prefix did not encode the <audio> placeholder token".into(),
+        ));
+    }
+    let mut target_ids = tokenizer.encode(&target)?;
+    if target_ids.is_empty() {
+        return Err(AarambhError::Config(
+            "audio target encoded to zero tokens".into(),
+        ));
+    }
+    let max_text_tokens = max_seq_len + 1 - patch_count;
+    if prefix_ids.len() >= max_text_tokens {
+        return Err(AarambhError::Shape(format!(
+            "audio prompt has {} text tokens plus {patch_count} media tokens, exceeding max_seq_len {max_seq_len}",
+            prefix_ids.len()
+        )));
+    }
+    let keep_target = max_text_tokens - prefix_ids.len();
+    if target_ids.len() > keep_target {
+        target_ids.truncate(keep_target);
+    }
+    let target_start_idx = prefix_ids.len();
+    let text_tokens = {
+        let mut combined = prefix_ids;
+        combined.extend(target_ids);
+        combined
+    };
+    if text_tokens.len() < 2 {
+        return Err(AarambhError::Config(
+            "audio sequence must contain at least two tokens".into(),
+        ));
+    }
+    let text = Tensor::from_vec(text_tokens.clone(), (1, text_tokens.len()), device)?;
+    let text_embeddings = model.embed_tokens(&text)?.detach();
+    let fused = interleave_audio_tokens(&text_tokens, &text_embeddings, &projected, AUDIO_ID)?;
+    let logits = model.forward_embeddings_train(&fused)?;
+    let (labels, mask) = audio_labels_and_mask(&text_tokens, target_start_idx, patch_count)?;
+    let seq_len = labels.len();
+    let labels = Tensor::from_vec(labels, (1, seq_len), device)?;
+    let mask = Tensor::from_vec(mask, (1, seq_len), device)?;
+    cross_entropy_loss(&logits, &labels, &mask)
+}
+
+fn audio_labels_and_mask(
+    text_tokens: &[u32],
+    target_start_idx: usize,
+    patch_count: usize,
+) -> Result<(Vec<u32>, Vec<u32>)> {
+    let mut items = Vec::new();
+    let mut inserted = 0usize;
+    for (idx, token) in text_tokens.iter().enumerate() {
+        if *token == AUDIO_ID {
+            items.extend(std::iter::repeat_n((None, idx), patch_count));
+            inserted = 1;
+        } else {
+            items.push((Some(*token), idx));
+        }
+    }
+    if inserted != 1 {
+        return Err(AarambhError::Shape(format!(
+            "expected one expanded audio item, found {inserted}"
+        )));
+    }
+    let mut labels = Vec::with_capacity(items.len());
+    let mut mask = Vec::with_capacity(items.len());
+    for idx in 0..items.len() {
+        match items.get(idx + 1).copied() {
+            Some((Some(token), original_idx)) if original_idx >= target_start_idx => {
+                labels.push(token);
+                mask.push(1);
+            }
+            Some((Some(token), _)) => {
+                labels.push(token);
+                mask.push(0);
+            }
+            _ => {
+                labels.push(0);
+                mask.push(0);
+            }
+        }
+    }
+    if !mask.contains(&1) {
+        return Err(AarambhError::Shape(
+            "audio loss mask has no supervised answer tokens".into(),
+        ));
+    }
+    Ok((labels, mask))
+}
+
+#[derive(Debug, Clone, Serialize)]
+struct AudioVlmArtifactsMetadata {
+    format_version: u32,
+    projector_path: String,
+    train_projector: bool,
+    base_projector_path: String,
+    encoder_config_path: String,
+    encoder_weights_path: String,
+    audio_root: String,
+    mel: aarambh_studio_audio::MelSpectrogramConfig,
+}
+
 #[derive(Debug, Clone, Serialize)]
 struct VlmArtifactsMetadata {
     format_version: u32,
diff --git a/crates/aarambh-studio-tokenizer/src/bpe.rs b/crates/aarambh-studio-tokenizer/src/bpe.rs
index 0db2413..8d8dbfa 100644
--- a/crates/aarambh-studio-tokenizer/src/bpe.rs
+++ b/crates/aarambh-studio-tokenizer/src/bpe.rs
@@ -193,6 +193,14 @@ impl BpeTokenizer {
         Ok(())
     }
 
+    /// Verify that Phase 42 audio tokens and all earlier special tokens use required ids.
+    pub fn validate_audio_special_tokens(&self) -> Result<()> {
+        for (token, id) in special::AUDIO_SPECIAL_TOKENS {
+            self.validate_special_token(token, id)?;
+        }
+        Ok(())
+    }
+
     /// Return an image-capable tokenizer upgraded to the Phase 35 video vocabulary layout.
     ///
     /// Existing learned token ids beginning at 9 are shifted by three. Callers must apply
@@ -296,6 +304,57 @@ impl BpeTokenizer {
         Ok(upgraded)
     }
 
+    /// Return a document-capable tokenizer upgraded to the Phase 42 audio layout.
+    ///
+    /// Existing learned token ids beginning at 15 are shifted by two. Callers must
+    /// apply the same migration to model embeddings and an untied language-model head.
+    pub fn upgraded_for_audio(&self) -> Result<Self> {
+        self.validate_document_special_tokens()?;
+        if self.validate_audio_special_tokens().is_ok() {
+            return Ok(self.clone());
+        }
+        for (token, _) in special::AUDIO_SPECIAL_TOKENS
+            .iter()
+            .skip(special::SPECIAL_TOKENS.len())
+        {
+            if let Some(id) = self.vocab.get_id(token) {
+                return Err(AarambhError::Tokenizer(format!(
+                    "cannot reserve audio token {token:?}: it already exists at id {id}"
+                )));
+            }
+        }
+
+        let insertion = special::AUDIO_ID;
+        let added = (special::AUDIO_SPECIAL_TOKENS.len() - special::SPECIAL_TOKENS.len()) as u32;
+        let mut token_to_id = HashMap::with_capacity(self.vocab.token_to_id.len() + added as usize);
+        for (token, id) in &self.vocab.token_to_id {
+            let migrated = if *id >= insertion { *id + added } else { *id };
+            token_to_id.insert(token.clone(), migrated);
+        }
+        for (token, id) in special::AUDIO_SPECIAL_TOKENS
+            .iter()
+            .skip(special::SPECIAL_TOKENS.len())
+        {
+            token_to_id.insert((*token).to_string(), *id);
+        }
+
+        let max_id = token_to_id.values().copied().max().unwrap_or(0);
+        let mut id_to_token = vec![String::new(); (max_id + 1) as usize];
+        for (token, id) in &token_to_id {
+            id_to_token[*id as usize] = token.clone();
+        }
+        let upgraded = Self {
+            vocab: Vocab {
+                token_to_id,
+                id_to_token,
+            },
+            merges: self.merges.clone(),
+            merge_rank: self.merge_rank.clone(),
+        };
+        upgraded.validate_audio_special_tokens()?;
+        Ok(upgraded)
+    }
+
     fn validate_special_token(&self, token: &str, id: u32) -> Result<()> {
         if self.vocab.get_id(token) != Some(id) {
             return Err(AarambhError::Tokenizer(format!(
@@ -417,7 +476,7 @@ impl TokenizerLike for BpeTokenizer {
         let mut rest = text;
 
         while !rest.is_empty() {
-            let next_special = special::SPECIAL_TOKENS
+            let next_special = special::AUDIO_SPECIAL_TOKENS
                 .iter()
                 .filter(|(token, id)| self.vocab.get_id(token) == Some(*id))
                 .filter_map(|(token, id)| rest.find(token).map(|pos| (pos, *token, *id)))
@@ -466,3 +525,89 @@ impl TokenizerLike for BpeTokenizer {
         Some(special::BOS_ID)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::special::AUDIO_SPECIAL_TOKENS;
+    use aarambh_studio_core::TokenizerLike;
+
+    fn audio_tokenizer() -> BpeTokenizer {
+        // Build a minimal audio-capable tokenizer: the 17 reserved special tokens
+        // (ids 0..=16) plus two learned tokens (ids 17, 18).
+        let mut token_to_id = std::collections::HashMap::new();
+        for (token, id) in AUDIO_SPECIAL_TOKENS {
+            token_to_id.insert((*token).to_string(), id);
+        }
+        token_to_id.insert("hello".to_string(), 17);
+        token_to_id.insert("world".to_string(), 18);
+        let max_id = *token_to_id.values().max().unwrap();
+        let mut id_to_token = vec![String::new(); (max_id + 1) as usize];
+        for (token, id) in &token_to_id {
+            id_to_token[*id as usize] = token.clone();
+        }
+        BpeTokenizer {
+            vocab: Vocab {
+                token_to_id,
+                id_to_token,
+            },
+            merges: Vec::new(),
+            merge_rank: std::collections::HashMap::new(),
+        }
+    }
+
+    #[test]
+    fn audio_tokenizer_encodes_audio_placeholder_as_single_token() {
+        // Regression test for Phase 42: the encoder must recognize <audio> as a
+        // single special token (id 15), not BPE-split it into characters. Before
+        // the encode path used AUDIO_SPECIAL_TOKENS, <audio> was invisible to the
+        // special-token splitter and the placeholder was never emitted.
+        let tokenizer = audio_tokenizer();
+        tokenizer.validate_audio_special_tokens().unwrap();
+        let ids = tokenizer.encode("prefix <audio> suffix").unwrap();
+        assert!(
+            ids.contains(&special::AUDIO_ID),
+            "encode must emit AUDIO id 15, got {ids:?}"
+        );
+        // The placeholder must appear exactly once.
+        assert_eq!(
+            ids.iter().filter(|&&id| id == special::AUDIO_ID).count(),
+            1,
+            "exactly one audio placeholder, got {ids:?}"
+        );
+    }
+
+    #[test]
+    fn audio_tokenizer_encodes_audio_end_boundary() {
+        let tokenizer = audio_tokenizer();
+        let ids = tokenizer.encode("<audio><audio_end>").unwrap();
+        assert_eq!(ids, vec![special::AUDIO_ID, special::AUDIO_END_ID]);
+    }
+
+    #[test]
+    fn text_only_tokenizer_does_not_match_audio_placeholder() {
+        // A text-only tokenizer (no audio tokens in vocab) must not treat the
+        // literal string "<audio>" as a special token — it BPE-splits it.
+        let mut token_to_id = std::collections::HashMap::new();
+        for (token, id) in special::TEXT_SPECIAL_TOKENS {
+            token_to_id.insert((*token).to_string(), id);
+        }
+        token_to_id.insert("a".to_string(), 7);
+        let max_id = *token_to_id.values().max().unwrap();
+        let mut id_to_token = vec![String::new(); (max_id + 1) as usize];
+        for (token, id) in &token_to_id {
+            id_to_token[*id as usize] = token.clone();
+        }
+        let tokenizer = BpeTokenizer {
+            vocab: Vocab {
+                token_to_id,
+                id_to_token,
+            },
+            merges: Vec::new(),
+            merge_rank: std::collections::HashMap::new(),
+        };
+        let ids = tokenizer.encode("<audio>").unwrap();
+        // No id 15 in a text-only tokenizer; the literal is BPE-split.
+        assert!(!ids.contains(&special::AUDIO_ID));
+    }
+}
diff --git a/crates/aarambh-studio-tokenizer/src/lib.rs b/crates/aarambh-studio-tokenizer/src/lib.rs
index 3f2fc8d..84e9142 100644
--- a/crates/aarambh-studio-tokenizer/src/lib.rs
+++ b/crates/aarambh-studio-tokenizer/src/lib.rs
@@ -12,11 +12,12 @@ pub mod vocab;
 
 pub use bpe::BpeTokenizer;
 pub use special::{
-    ASSISTANT, ASSISTANT_ID, BOS, BOS_ID, DOCUMENT, DOCUMENT_END, DOCUMENT_END_ID, DOCUMENT_ID,
-    ENDOFTEXT, ENDOFTEXT_ID, FRAME_SEP, FRAME_SEP_ID, IMAGE, IMAGE_END, IMAGE_END_ID, IMAGE_ID,
-    PAD, PAD_ID, PAGE_SEP, PAGE_SEP_ID, SPECIAL_TOKEN_COUNT, SPECIAL_TOKENS, TEXT_SPECIAL_TOKENS,
-    THINK_END, THINK_END_ID, THINK_START, THINK_START_ID, USER, USER_ID, VIDEO, VIDEO_END,
-    VIDEO_END_ID, VIDEO_ID, VIDEO_SPECIAL_TOKENS, VISION_SPECIAL_TOKENS,
+    ASSISTANT, ASSISTANT_ID, AUDIO, AUDIO_END, AUDIO_END_ID, AUDIO_ID, AUDIO_SPECIAL_TOKENS, BOS,
+    BOS_ID, DOCUMENT, DOCUMENT_END, DOCUMENT_END_ID, DOCUMENT_ID, ENDOFTEXT, ENDOFTEXT_ID,
+    FRAME_SEP, FRAME_SEP_ID, IMAGE, IMAGE_END, IMAGE_END_ID, IMAGE_ID, PAD, PAD_ID, PAGE_SEP,
+    PAGE_SEP_ID, SPECIAL_TOKEN_COUNT, SPECIAL_TOKENS, TEXT_SPECIAL_TOKENS, THINK_END, THINK_END_ID,
+    THINK_START, THINK_START_ID, USER, USER_ID, VIDEO, VIDEO_END, VIDEO_END_ID, VIDEO_ID,
+    VIDEO_SPECIAL_TOKENS, VISION_SPECIAL_TOKENS,
 };
 pub use tool_protocol::{
     VIRTUAL_ASCII_BASE, VIRTUAL_ASCII_END, VIRTUAL_ASCII_FIRST, VIRTUAL_ASCII_LAST,
diff --git a/crates/aarambh-studio-tokenizer/src/special.rs b/crates/aarambh-studio-tokenizer/src/special.rs
index e0271d3..99720e3 100644
--- a/crates/aarambh-studio-tokenizer/src/special.rs
+++ b/crates/aarambh-studio-tokenizer/src/special.rs
@@ -28,6 +28,10 @@ pub const DOCUMENT: &str = "<document>";
 pub const DOCUMENT_END: &str = "<document_end>";
 /// Separator token inserted between rendered document pages.
 pub const PAGE_SEP: &str = "<page_sep>";
+/// Audio placeholder token string.
+pub const AUDIO: &str = "<audio>";
+/// Audio prefix boundary token string.
+pub const AUDIO_END: &str = "<audio_end>";
 
 /// End-of-text token id.
 pub const ENDOFTEXT_ID: u32 = 0;
@@ -59,6 +63,10 @@ pub const DOCUMENT_ID: u32 = 12;
 pub const DOCUMENT_END_ID: u32 = 13;
 /// Rendered-page separator token id.
 pub const PAGE_SEP_ID: u32 = 14;
+/// Audio placeholder token id.
+pub const AUDIO_ID: u32 = 15;
+/// Audio prefix boundary token id.
+pub const AUDIO_END_ID: u32 = 16;
 
 /// Reserved special token table in required id order.
 pub const SPECIAL_TOKENS: [(&str, u32); 15] = [
@@ -79,6 +87,27 @@ pub const SPECIAL_TOKENS: [(&str, u32); 15] = [
     (PAGE_SEP, PAGE_SEP_ID),
 ];
 
+/// Audio-capable reserved token table accepted by Phase 42 checkpoints.
+pub const AUDIO_SPECIAL_TOKENS: [(&str, u32); 17] = [
+    (ENDOFTEXT, ENDOFTEXT_ID),
+    (PAD, PAD_ID),
+    (BOS, BOS_ID),
+    (THINK_START, THINK_START_ID),
+    (THINK_END, THINK_END_ID),
+    (USER, USER_ID),
+    (ASSISTANT, ASSISTANT_ID),
+    (IMAGE, IMAGE_ID),
+    (IMAGE_END, IMAGE_END_ID),
+    (VIDEO, VIDEO_ID),
+    (VIDEO_END, VIDEO_END_ID),
+    (FRAME_SEP, FRAME_SEP_ID),
+    (DOCUMENT, DOCUMENT_ID),
+    (DOCUMENT_END, DOCUMENT_END_ID),
+    (PAGE_SEP, PAGE_SEP_ID),
+    (AUDIO, AUDIO_ID),
+    (AUDIO_END, AUDIO_END_ID),
+];
+
 /// Video-capable reserved token table accepted by Phase 35 checkpoints.
 pub const VIDEO_SPECIAL_TOKENS: [(&str, u32); 12] = [
     (ENDOFTEXT, ENDOFTEXT_ID),
@@ -121,3 +150,40 @@ pub const TEXT_SPECIAL_TOKENS: [(&str, u32); 7] = [
 
 /// Number of reserved special tokens.
 pub const SPECIAL_TOKEN_COUNT: usize = SPECIAL_TOKENS.len();
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn audio_table_is_strict_superset_of_document_table() {
+        // Every (token, id) pair in the document table must appear, in order, at
+        // the front of the audio table, with the two new audio tokens appended.
+        assert_eq!(AUDIO_SPECIAL_TOKENS.len(), SPECIAL_TOKENS.len() + 2);
+        for (idx, entry) in SPECIAL_TOKENS.iter().enumerate() {
+            assert_eq!(AUDIO_SPECIAL_TOKENS[idx], *entry);
+        }
+        assert_eq!(AUDIO_SPECIAL_TOKENS[15], (AUDIO, AUDIO_ID));
+        assert_eq!(AUDIO_SPECIAL_TOKENS[16], (AUDIO_END, AUDIO_END_ID));
+    }
+
+    #[test]
+    fn audio_token_ids_are_contiguous_after_document_tokens() {
+        // Phase 42 audio tokens occupy ids 15 and 16, immediately following the
+        // Phase 36 document table (ids 0..=14).
+        assert_eq!(AUDIO_ID, 15);
+        assert_eq!(AUDIO_END_ID, 16);
+        assert_eq!(AUDIO_ID, PAGE_SEP_ID + 1);
+        assert_eq!(AUDIO_END_ID, AUDIO_ID + 1);
+    }
+
+    #[test]
+    fn audio_table_ids_are_contiguous_from_zero() {
+        for (idx, &(_, id)) in AUDIO_SPECIAL_TOKENS.iter().enumerate() {
+            assert_eq!(
+                id, idx as u32,
+                "audio table id at position {idx} must be {idx}"
+            );
+        }
+    }
+}
diff --git a/crates/aarambh-studio-train/Cargo.toml b/crates/aarambh-studio-train/Cargo.toml
index e1c4a5b..1f8119a 100644
--- a/crates/aarambh-studio-train/Cargo.toml
+++ b/crates/aarambh-studio-train/Cargo.toml
@@ -12,6 +12,7 @@ cuda = [
     "aarambh-studio-data/cuda",
     "aarambh-studio-model/cuda",
     "aarambh-studio-vision/cuda",
+    "aarambh-studio-audio/cuda",
     "aarambh-studio-weights/cuda",
     "candle-core/nccl",
     "candle-nn/cuda",
@@ -23,6 +24,7 @@ aarambh-studio-data      = { path = "../aarambh-studio-data" }
 aarambh-studio-model     = { path = "../aarambh-studio-model" }
 aarambh-studio-tokenizer = { path = "../aarambh-studio-tokenizer" }
 aarambh-studio-vision    = { path = "../aarambh-studio-vision" }
+aarambh-studio-audio     = { path = "../aarambh-studio-audio" }
 aarambh-studio-weights   = { path = "../aarambh-studio-weights" }
 candle-core          = { workspace = true }
 candle-nn            = { workspace = true }
diff --git a/crates/aarambh-studio-train/src/lib.rs b/crates/aarambh-studio-train/src/lib.rs
index fdc56ab..5f6eb85 100644
--- a/crates/aarambh-studio-train/src/lib.rs
+++ b/crates/aarambh-studio-train/src/lib.rs
@@ -38,5 +38,6 @@ pub use optim::{AdamW, AdamWConfig, GradMap, TrainableParameter};
 pub use schedule::CosineScheduleWithWarmup;
 pub use trainer::{MtpHeadMetric, Trainer, TrainingMetrics};
 pub use vision_projector::{
-    DocumentTrainingConfig, VideoTrainingConfig, VisionTrainingConfig, run_projector_pretrain,
+    AudioTrainingConfig, DocumentTrainingConfig, VideoTrainingConfig, VisionTrainingConfig,
+    run_projector_pretrain,
 };
diff --git a/crates/aarambh-studio-train/src/vision_projector.rs b/crates/aarambh-studio-train/src/vision_projector.rs
index 2175922..0df2788 100644
--- a/crates/aarambh-studio-train/src/vision_projector.rs
+++ b/crates/aarambh-studio-train/src/vision_projector.rs
@@ -1,6 +1,7 @@
 use std::path::{Path, PathBuf};
 use std::time::Instant;
 
+use aarambh_studio_audio::MelSpectrogramConfig;
 use aarambh_studio_core::{AarambhError, ModelConfig, Result, TokenizerLike, TrainConfig};
 use aarambh_studio_model::AarambhModel;
 use aarambh_studio_tokenizer::{
@@ -23,7 +24,7 @@ use crate::optim::{AdamW, AdamWConfig, GradMap, clip_gradients};
 use crate::schedule::CosineScheduleWithWarmup;
 
 /// Vision training mode and data paths used by Phase 19.
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 #[serde(default)]
 pub struct VisionTrainingConfig {
     /// Vision mode: `projector_pretrain` or `vlm_instruction`.
@@ -50,6 +51,8 @@ pub struct VisionTrainingConfig {
     pub video: Option<VideoTrainingConfig>,
     /// Optional native document understanding configuration.
     pub document: Option<DocumentTrainingConfig>,
+    /// Optional native audio understanding configuration (Phase 42).
+    pub audio: Option<AudioTrainingConfig>,
 }
 
 impl Default for VisionTrainingConfig {
@@ -67,6 +70,7 @@ impl Default for VisionTrainingConfig {
             max_samples: None,
             video: None,
             document: None,
+            audio: None,
         }
     }
 }
@@ -80,6 +84,9 @@ impl VisionTrainingConfig {
         if let Some(document) = &self.document {
             document.validate()?;
         }
+        if let Some(audio) = &self.audio {
+            audio.validate()?;
+        }
         match self.mode.as_str() {
             "disabled" | "" => Ok(()),
             "projector_pretrain" => {
@@ -194,6 +201,50 @@ impl DocumentTrainingConfig {
     }
 }
 
+/// Native audio decoding, mel-spectrogram, and cache configuration (Phase 42).
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[serde(default)]
+pub struct AudioTrainingConfig {
+    /// Root directory used to resolve relative audio paths.
+    pub audio_root: PathBuf,
+    /// JSON config for the frozen audio spectrogram transformer.
+    pub encoder_config_path: PathBuf,
+    /// SafeTensors checkpoint for the frozen audio spectrogram transformer.
+    pub encoder_weights_path: PathBuf,
+    /// Mel-spectrogram extraction parameters.
+    pub mel: MelSpectrogramConfig,
+    /// Maximum number of clips passed through the audio encoder in one forward call.
+    pub encoder_batch_size: usize,
+    /// Number of detached pre-projector audio features cached in memory.
+    pub feature_cache_entries: usize,
+}
+
+impl Default for AudioTrainingConfig {
+    fn default() -> Self {
+        Self {
+            audio_root: PathBuf::from("."),
+            encoder_config_path: PathBuf::new(),
+            encoder_weights_path: PathBuf::new(),
+            mel: MelSpectrogramConfig::default(),
+            encoder_batch_size: 4,
+            feature_cache_entries: 16,
+        }
+    }
+}
+
+impl AudioTrainingConfig {
+    /// Validate audio resource bounds and mel configuration.
+    pub fn validate(&self) -> Result<()> {
+        if self.encoder_batch_size == 0 || self.feature_cache_entries == 0 {
+            return Err(AarambhError::Config(
+                "vision.audio encoder_batch_size and feature_cache_entries must be non-zero".into(),
+            ));
+        }
+        self.mel.validate()?;
+        Ok(())
+    }
+}
+
 /// Native video decoding, sampling, temporal fusion, and cache configuration.
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 #[serde(default)]
diff --git a/docs/phase42_audio.md b/docs/phase42_audio.md
new file mode 100644
index 0000000..16d8141
--- /dev/null
+++ b/docs/phase42_audio.md
@@ -0,0 +1,193 @@
+# Phase 42 — Audio Modality
+
+> v4.0.0-alpha.2 · `aarambh-studio-audio` (new crate) · depends on v2 §24–25 (vision fusion pattern), v1 §7 (thinking engine)
+
+Phase 42 adds a fourth input sense — **audio** — following the exact same
+frozen-encoder-plus-trainable-projector pattern v2 §24 established for vision
+and v3 §35–36 reused for video and documents. A frozen, pretrained audio
+spectrogram transformer converts a log-mel spectrogram into a grid of patch
+embeddings; a small trainable projector maps those into the decoder's `d_model`
+space; the result is spliced into the token sequence at the `<audio>` special
+token position. Nothing about the decoder, the thinking engine, grammar-
+constrained tool calling, or long-horizon tool chains changes — audio is just
+another sense feeding the same fusion mechanism.
+
+## Mechanism
+
+```
+Raw audio waveform (WAV PCM 8/16/24/32-bit, mono or stereo)
+     │
+     ▼
+Pure-Rust WAV decode + linear resample to target sample rate
+(no Python audio ML tooling, no system-library FFI)
+     │
+     ▼
+Mel-spectrogram extraction (Hann window + radix-2 Cooley-Tukey FFT
++ triangular mel filterbank + log-mel + per-frame normalization)
+     │
+     ▼
+FrozenAudioEncoder (pretrained, loaded as SafeTensors via candle-core —
+same loading path as CLIP; AST-style patchify + transformer blocks)
+     │
+     ▼
+Projector MLP (trainable): audio_d_model -> hidden -> llm_d_model
+     │
+     ▼
+N "audio tokens" in llm_d_model space
+     │
+     ▼
+Spliced into the input sequence at the <audio> special token position
+     │
+     ▼
+...the rest of the decoder, completely unmodified...
+```
+
+### Two-stage training
+
+Identical structure to v2 §25's vision recipe:
+
+1. **Projector-only stage.** Everything else frozen; the projector trains alone
+   on audio-captioning-style data, learning to map audio embeddings into a space
+   the (frozen) decoder can already interpret reasonably.
+2. **Instruction-tuning stage.** The projector continues training alongside a
+   DoRA-adapted (v2 §23) LLM on open-ended audio-QA data. `finetune audio-dora`
+   runs this stage; `--freeze-projector` selects projector-only training.
+
+## New crate: `aarambh-studio-audio`
+
+| Module | Role |
+|---|---|
+| `encoder.rs` | `AudioEncoderConfig` + `FrozenAudioEncoder` — AST-style transformer over mel-spectrogram patches, `load_pretrained` via `VarBuilder::from_mmaped_safetensors` |
+| `preprocess.rs` | `MelSpectrogramConfig` + `AudioPreprocessor` — pure-Rust WAV decode, resampling, Hann window, radix-2 FFT, mel filterbank, log-mel normalization (zero new dependencies) |
+| `projector.rs` | `AudioProjectorConfig` + `AudioProjector` — two-layer GELU MLP mirroring `VisionProjector` exactly |
+| `fusion.rs` | `interleave_audio_tokens()` — generalizes `interleave_image_tokens` to the shared modal-token-splicing pattern |
+| `instruct_data.rs` | `AudioQaExample` + `load_audio_qa_jsonl` — caption, QA, and LLaVA-style conversation records |
+
+## Tokenizer
+
+Two new reserved special tokens, IDs 15 and 16, following the exact pattern of
+v2's `<image>`/`<image_end>` and v3's `<video>`/`<document>` tokens:
+
+| Token | String | ID |
+|---|---|---|
+| Audio placeholder | `<audio>` | 15 |
+| Audio prefix boundary | `<audio_end>` | 16 |
+
+`AUDIO_SPECIAL_TOKENS` (17 entries) is a strict superset of the Phase 36
+document table. `BpeTokenizer::validate_audio_special_tokens()` checks a
+checkpoint's tokenizer carries the audio tokens at their required IDs, and
+`upgraded_for_audio()` migrates a document-capable tokenizer to the audio layout
+(shifting learned token IDs ≥ 15 by two), exactly as `upgraded_for_document`
+did for video → document.
+
+`convert --upgrade-audio-vocab` applies the migration to a SafeTensors
+checkpoint and its tokenizer together (`VocabularyExpansion { insertion_id: 15,
+source_ids: [IMAGE_ID, IMAGE_END_ID] }`), copying the canonical placeholder
+pair as initialization for the two new embedding rows.
+
+## Configuration
+
+Audio is configured under the existing `[vision]` block (the multimodal config
+block document and video already share), as `[vision.audio]`:
+
+```toml
+[vision]
+mode = "vlm_instruction"
+base_model_path = "checkpoints/audio_smoke/model.safetensors"
+projector_path = "data/audio_smoke/projector_init.safetensors"
+projector_hidden_mult = 1
+max_samples = 4
+
+[vision.audio]
+audio_root = "data/audio_smoke/audio"
+encoder_config_path = "data/audio_smoke/audio_encoder_tiny_config.json"
+encoder_weights_path = "data/audio_smoke/audio_encoder_tiny.safetensors"
+encoder_batch_size = 2
+feature_cache_entries = 4
+
+[vision.audio.mel]
+sample_rate = 16000
+n_fft = 256
+hop_length = 128
+n_mels = 16
+fmin = 0.0
+fmax = 8000.0
+max_audio_seconds = 0.136
+power = 2.0
+log_eps = 0.0000000001
+```
+
+See `configs/audio_qa_smoke.toml` and `configs/audio_qa_smoke_infer.toml` for
+ready-to-use smoke recipes.
+
+## CLI
+
+```text
+aarambh-studio infer --audio <path.wav> --prompt "What sound is this?"
+aarambh-studio finetune audio-dora   --config configs/audio_qa_smoke.toml ...
+aarambh-studio finetune audio-qdora  --config configs/audio_qa_smoke.toml ...
+aarambh-studio convert --upgrade-audio-vocab ...
+aarambh-studio eval --tasks audio-qa-smoke ...
+```
+
+`--audio` conflicts with `--image`, `--video`, and `--document` (one modality
+per inference call, the same discipline every prior modality flag holds).
+
+## Tests
+
+The Phase 42 proof obligations (from `ROADMAP_V4.md`):
+
+| Test | Location | Proves |
+|---|---|---|
+| `frozen_audio_encoder_never_receives_gradients` | `aarambh-studio-audio` | detached encoder output blocks gradients from reaching encoder parameters while the projector still trains |
+| `projector_pretrain_stage_trains_only_projector_weights` | `aarambh-studio-audio` | the projector-only stage's structural freeze guarantee holds |
+| `audio_token_fusion_produces_expected_sequence_length` | `aarambh-studio-audio` | `interleave_audio_tokens` produces `seq - 1 + audio_tokens` length |
+| `thinking_controller_behaves_identically_after_audio_context` | `aarambh-studio-audio` | fused audio-context embeddings are a well-formed, finite, contiguous sequence the decoder observes identically to text |
+| `audio_table_is_strict_superset_of_document_table` | `aarambh-studio-tokenizer` | the audio token table extends the document table by exactly two entries |
+| `audio_token_ids_are_contiguous_after_document_tokens` | `aarambh-studio-tokenizer` | audio IDs 15/16 immediately follow the document table |
+
+Plus unit tests for WAV decode (PCM 16-bit + 32-bit float stereo), FFT frequency
+recovery, mel frame counting, projector output width, fusion placeholder
+validation, and JSONL parsing (caption + QA + conversation formats).
+
+### Smoke test
+
+```sh
+scripts/phase42_smoke.sh
+```
+
+Generates a synthetic audio fixture (sine-wave WAVs + a tiny random-init audio
+encoder + projector), upgrades a document-capable checkpoint to the audio
+vocabulary, runs a two-step `finetune audio-dora`, merges, runs
+`infer --audio` on a held-out clip, and scores `audio-qa-smoke`. Requires the
+Phase 36 document smoke checkpoint as its base (the same prerequisite chain
+phase35 → phase36 → phase42 that vision → video → document → audio follows).
+
+## Composability
+
+Because fusion happens before the decoder sees the sequence, nothing about the
+thinking engine (v1 §7), grammar-constrained tool calling (v2 §30), or
+long-horizon tool chains (v3 §46) needs to change — a `ücklich` block or a tool
+call generated after audio tokens behaves identically to one generated after
+text-only or image-only context. This is the same composability guarantee every
+prior modality addition has held, and the
+`thinking_controller_behaves_identically_after_audio_context` test pins it.
+
+## Scope and boundaries
+
+- Audio **understanding** only (the model can be asked about audio it's given),
+  not audio **generation** — aarambh-studio does not produce audio output. That
+  capability belongs to a separate project entirely and is intentionally out of
+  scope, the same boundary v2 §24 drew for vision.
+- WAV PCM (8/16/24/32-bit signed and unsigned, plus 32/64-bit float) is decoded
+  in pure Rust. MP3/FLAC/Ogg decode is future work, following the same
+  "visual-only H.264 MP4" boundary v3 §35 set for video containers.
+- Mel-spectrogram extraction uses a from-scratch Hann window, radix-2 FFT, and
+  triangular mel filterbank — no `rustfft` or audio-DSP dependency, consistent
+  with the project's "from first principles" dependency discipline.
+- The frozen encoder reuses the candle fallback attention kernel. CUDA flash
+  audio kernels are future work; the mechanism and fusion are in place.
+- Self-learning (`SELF_LEARNING_V4.md`) is transparent to audio: online GRPO
+  operates on token log-probabilities and has no dependency on the input
+  modality. Audio self-learning is not wired into the `--self-learn` CLI flag
+  (which remains text/image only, the same boundary video and document hold).
diff --git a/scripts/phase28_release_audit.sh b/scripts/phase28_release_audit.sh
index ed2e663..9ca8842 100755
--- a/scripts/phase28_release_audit.sh
+++ b/scripts/phase28_release_audit.sh
@@ -5,7 +5,7 @@ ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
 cd "$ROOT"
 
 EXPECTED_VERSION="${AARAMBH_STUDIO_EXPECTED_VERSION:-}"
-EXPECTED_PACKAGES=19
+EXPECTED_PACKAGES=20
 
 command -v jq >/dev/null 2>&1 || {
   echo "release audit requires jq" >&2
diff --git a/scripts/phase42_make_audio_smoke_fixture.py b/scripts/phase42_make_audio_smoke_fixture.py
new file mode 100755
index 0000000..4beb55c
--- /dev/null
+++ b/scripts/phase42_make_audio_smoke_fixture.py
@@ -0,0 +1,199 @@
+#!/usr/bin/env python3
+"""Create synthetic WAV clips and a tiny Phase 42 audio smoke fixture.
+
+The fixture is intentionally synthetic — it verifies that the audio decode,
+mel-spectrogram, frozen encoder, projector, fusion, and audio-QA eval pipeline
+are wired correctly without downloading full audio datasets.
+"""
+
+from __future__ import annotations
+
+import json
+import math
+import struct
+import wave
+from pathlib import Path
+
+import numpy as np
+
+
+ROOT = Path(__file__).resolve().parents[1]
+OUT = ROOT / "data" / "audio_smoke"
+AUDIO_DIR = OUT / "audio"
+EVAL_OUT = ROOT / "data" / "eval" / "audio_qa_smoke"
+
+# Tiny audio encoder config: 16 mel bins x 16 frames, 4x4 patches -> 16 patch tokens.
+ENCODER_CONFIG = {
+    "n_mels": 16,
+    "max_frames": 16,
+    "patch_mel": 4,
+    "patch_time": 4,
+    "audio_d_model": 16,
+    "audio_layers": 1,
+    "audio_heads": 2,
+    "mlp_dim": 32,
+    "norm_eps": 0.00001,
+}
+
+# Mel config matching the encoder's n_mels/max_frames. With sample_rate=16000,
+# n_fft=256, hop_length=128, max_audio_seconds must yield max_frames=16:
+#   total_samples = (16 - 1) * 128 + 256 = 2176 -> 2176/16000 = 0.136 s.
+MEL_CONFIG = {
+    "sample_rate": 16000,
+    "n_fft": 256,
+    "hop_length": 128,
+    "n_mels": 16,
+    "fmin": 0.0,
+    "fmax": 8000.0,
+    "max_audio_seconds": 0.136,
+    "power": 2.0,
+    "log_eps": 0.0000000001,
+}
+
+# Tiny language model hidden width (matches configs/tiny_shakespeare).
+LLM_HIDDEN = 384
+PROJECTOR_HIDDEN_MULT = 1
+
+
+def write_safetensors(path: Path, tensors: dict[str, np.ndarray]) -> None:
+    data = bytearray()
+    header: dict[str, object] = {}
+    for name in sorted(tensors):
+        tensor = np.ascontiguousarray(tensors[name], dtype=np.float32)
+        start = len(data)
+        payload = tensor.tobytes(order="C")
+        data.extend(payload)
+        header[name] = {
+            "dtype": "F32",
+            "shape": list(tensor.shape),
+            "data_offsets": [start, start + len(payload)],
+        }
+    header_bytes = json.dumps(header, separators=(",", ":")).encode("utf-8")
+    padding = (8 - (len(header_bytes) % 8)) % 8
+    header_bytes += b" " * padding
+    path.write_bytes(struct.pack("<Q", len(header_bytes)) + header_bytes + data)
+
+
+def write_wav(path: Path, frequency: float, duration: float = 0.3) -> None:
+    sample_rate = MEL_CONFIG["sample_rate"]
+    sample_count = int(duration * sample_rate)
+    samples = np.sin(
+        2.0 * math.pi * frequency * np.arange(sample_count) / sample_rate
+    ).astype(np.float32)
+    pcm = np.clip(samples * 32767.0, -32768.0, 32767.0).astype("<i2")
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with wave.open(str(path), "wb") as wav:
+        wav.setnchannels(1)
+        wav.setsampwidth(2)
+        wav.setframerate(sample_rate)
+        wav.writeframes(pcm.tobytes())
+
+
+def make_encoder_fixture() -> None:
+    OUT.mkdir(parents=True, exist_ok=True)
+    (OUT / "audio_encoder_tiny_config.json").write_text(
+        json.dumps(ENCODER_CONFIG, indent=2) + "\n", encoding="utf-8"
+    )
+    rng = np.random.default_rng(42)
+    width = ENCODER_CONFIG["audio_d_model"]
+    mlp = ENCODER_CONFIG["mlp_dim"]
+    patch_dim = ENCODER_CONFIG["patch_mel"] * ENCODER_CONFIG["patch_time"]
+    num_patches = (
+        ENCODER_CONFIG["n_mels"] // ENCODER_CONFIG["patch_mel"]
+    ) * (ENCODER_CONFIG["max_frames"] // ENCODER_CONFIG["patch_time"])
+
+    def randn(shape, scale=0.02):
+        return (rng.standard_normal(shape) * scale).astype(np.float32)
+
+    def zeros(shape):
+        return np.zeros(shape, dtype=np.float32)
+
+    def ones(shape):
+        return np.ones(shape, dtype=np.float32)
+
+    tensors = {
+        "patch_embed.weight": randn((width, patch_dim)),
+        "class_embedding": randn((width,)),
+        "position_embedding": randn((num_patches + 1, width), 0.01),
+        "pre_norm.weight": ones((width,)),
+        "pre_norm.bias": zeros((width,)),
+        "post_norm.weight": ones((width,)),
+        "post_norm.bias": zeros((width,)),
+        "blocks.0.norm1.weight": ones((width,)),
+        "blocks.0.norm1.bias": zeros((width,)),
+        "blocks.0.norm2.weight": ones((width,)),
+        "blocks.0.norm2.bias": zeros((width,)),
+        "blocks.0.attn.q_proj.weight": randn((width, width)),
+        "blocks.0.attn.q_proj.bias": zeros((width,)),
+        "blocks.0.attn.k_proj.weight": randn((width, width)),
+        "blocks.0.attn.k_proj.bias": zeros((width,)),
+        "blocks.0.attn.v_proj.weight": randn((width, width)),
+        "blocks.0.attn.v_proj.bias": zeros((width,)),
+        "blocks.0.attn.out_proj.weight": randn((width, width)),
+        "blocks.0.attn.out_proj.bias": zeros((width,)),
+        "blocks.0.mlp.fc1.weight": randn((mlp, width)),
+        "blocks.0.mlp.fc1.bias": zeros((mlp,)),
+        "blocks.0.mlp.fc2.weight": randn((width, mlp)),
+        "blocks.0.mlp.fc2.bias": zeros((width,)),
+    }
+    write_safetensors(OUT / "audio_encoder_tiny.safetensors", tensors)
+
+
+def make_projector_fixture() -> None:
+    rng = np.random.default_rng(7)
+    audio_d_model = ENCODER_CONFIG["audio_d_model"]
+    hidden = LLM_HIDDEN * PROJECTOR_HIDDEN_MULT
+
+    def randn(shape, scale=0.02):
+        return (rng.standard_normal(shape) * scale).astype(np.float32)
+
+    def zeros(shape):
+        return np.zeros(shape, dtype=np.float32)
+
+    tensors = {
+        "fc1.weight": randn((hidden, audio_d_model)),
+        "fc1.bias": zeros((hidden,)),
+        "fc2.weight": randn((LLM_HIDDEN, hidden)),
+        "fc2.bias": zeros((LLM_HIDDEN,)),
+    }
+    write_safetensors(OUT / "projector_init.safetensors", tensors)
+
+
+def make_audio_clips_and_qa() -> None:
+    AUDIO_DIR.mkdir(parents=True, exist_ok=True)
+    clips = [
+        ("low_tone.wav", 220.0, "a low tone"),
+        ("mid_tone.wav", 440.0, "a mid tone"),
+        ("high_tone.wav", 880.0, "a high tone"),
+        ("chord.wav", 660.0, "a chord"),
+    ]
+    for filename, frequency, _answer in clips:
+        write_wav(AUDIO_DIR / filename, frequency)
+    records = [
+        {"audio": filename, "question": "What sound is this?", "answer": answer}
+        for filename, _frequency, answer in clips
+    ]
+    (OUT / "audio_qa_smoke_4.jsonl").write_text(
+        "\n".join(json.dumps(record) for record in records) + "\n", encoding="utf-8"
+    )
+    EVAL_OUT.mkdir(parents=True, exist_ok=True)
+    eval_records = [
+        {**record, "audio": f"../../audio_smoke/audio/{record['audio']}"}
+        for record in records[:2]
+    ]
+    (EVAL_OUT / "data.jsonl").write_text(
+        "\n".join(json.dumps(record) for record in eval_records) + "\n", encoding="utf-8"
+    )
+    print(f"audio smoke data: {OUT / 'audio_qa_smoke_4.jsonl'}")
+    print(f"audio smoke eval: {EVAL_OUT / 'data.jsonl'}")
+    print(f"audio smoke clips: {AUDIO_DIR}")
+
+
+def main() -> None:
+    make_encoder_fixture()
+    make_projector_fixture()
+    make_audio_clips_and_qa()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/phase42_prepare_audio_data.sh b/scripts/phase42_prepare_audio_data.sh
new file mode 100755
index 0000000..ee683d2
--- /dev/null
+++ b/scripts/phase42_prepare_audio_data.sh
@@ -0,0 +1,60 @@
+#!/usr/bin/env bash
+# Prepare a free, public audio-caption / audio-QA dataset subset for Phase 42.
+#
+# Same "free and public only" policy as every prior modality phase. This script
+# is a thin orchestrator: it downloads a permissively-licensed audio-caption
+# subset (or reuses a locally-provided one) and normalizes it into the JSONL
+# schema aarambh-studio-audio::load_audio_qa_jsonl consumes:
+#
+#   {"audio": "<relative-path>", "question": "...", "answer": "..."}
+#   {"audio": "<relative-path>", "caption": "..."}
+#   {"audio": "<path>", "conversations": [{"from":"human","value":"..."},{"from":"gpt","value":"..."}]}
+#
+# Usage:
+#   scripts/phase42_prepare_audio_data.sh data [optional-source-archive]
+#
+# If no source archive is provided, the script creates a tiny synthetic
+# smoke subset (identical to scripts/phase42_make_audio_smoke_fixture.py) so
+# the data-preparation path is exercisable end-to-end without network access.
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+cd "$ROOT"
+
+DATA_DIR="${1:-data}"
+SOURCE_ARCHIVE="${2:-}"
+
+mkdir -p "$DATA_DIR/audio_qa"
+AUDIO_ROOT="$DATA_DIR/audio_qa/audio"
+mkdir -p "$AUDIO_ROOT"
+
+if [[ -n "$SOURCE_ARCHIVE" && -f "$SOURCE_ARCHIVE" ]]; then
+  echo "preparing audio data from $SOURCE_ARCHIVE"
+  CACHE_DIR="$DATA_DIR/audio_qa/_cache"
+  mkdir -p "$CACHE_DIR"
+  if [[ "$SOURCE_ARCHIVE" == *.tar.gz || "$SOURCE_ARCHIVE" == *.tgz ]]; then
+    tar -xzf "$SOURCE_ARCHIVE" -C "$CACHE_DIR"
+  elif [[ "$SOURCE_ARCHIVE" == *.zip ]]; then
+    unzip -o -q "$SOURCE_ARCHIVE" -d "$CACHE_DIR"
+  else
+    echo "unsupported archive format: $SOURCE_ARCHIVE" >&2
+    exit 2
+  fi
+  echo "extracted source to $CACHE_DIR — normalize into JSONL with:"
+  echo "  python3 - <<'PY'"
+  echo "  import json, pathlib"
+  echo "  root = pathlib.Path('$CACHE_DIR')"
+  echo "  out = pathlib.Path('$DATA_DIR/audio_qa/data.jsonl')"
+  echo "  # Replace this loop with dataset-specific normalization."
+  echo "  records = [{'audio': str(p.relative_to(root.parent)), 'caption': p.stem} for p in root.rglob('*.wav')]"
+  echo "  out.write_text('\\n'.join(json.dumps(r) for r in records) + '\\n')"
+  echo "  PY"
+else
+  echo "no source archive provided; generating a synthetic smoke subset"
+  python3 scripts/phase42_make_audio_smoke_fixture.py
+  cp data/audio_smoke/audio_qa_smoke_4.jsonl "$DATA_DIR/audio_qa/data.jsonl"
+  cp -r data/audio_smoke/audio/* "$AUDIO_ROOT/" 2>/dev/null || true
+fi
+
+COUNT=$(wc -l < "$DATA_DIR/audio_qa/data.jsonl")
+echo "Phase 42 audio data prepared: $COUNT examples in $DATA_DIR/audio_qa/data.jsonl"
diff --git a/scripts/phase42_smoke.sh b/scripts/phase42_smoke.sh
new file mode 100755
index 0000000..99e8346
--- /dev/null
+++ b/scripts/phase42_smoke.sh
@@ -0,0 +1,88 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+BIN=${AARAMBH_STUDIO_BIN:-target/release/aarambh-studio}
+DOCUMENT_DIR=${AUDIO_DOCUMENT_MIGRATION_DIR:-checkpoints/document_smoke}
+AUDIO_DIR=${AUDIO_CHECKPOINT_DIR:-checkpoints/audio_smoke}
+ADAPTER_DIR=${AUDIO_ADAPTER_DIR:-adapters/audio_qa_smoke}
+MERGED_DIR=${AUDIO_MERGED_DIR:-checkpoints/audio_qa_smoke_merged}
+SCORECARD=${AUDIO_SCORECARD:-artifacts/phase42_audio_smoke.json}
+
+[[ -x "$BIN" ]] || {
+  echo "missing executable Phase 42 binary: $BIN" >&2
+  exit 2
+}
+[[ -s "$DOCUMENT_DIR/model.safetensors" ]] || {
+  echo "missing Phase 42 base checkpoint: $DOCUMENT_DIR/model.safetensors (run phase36_smoke.sh first)" >&2
+  exit 2
+}
+[[ -s "$DOCUMENT_DIR/tokenizer.json" ]] || {
+  echo "missing Phase 42 base tokenizer: $DOCUMENT_DIR/tokenizer.json (run phase36_smoke.sh first)" >&2
+  exit 2
+}
+
+python3 scripts/phase42_make_audio_smoke_fixture.py
+mkdir -p "$AUDIO_DIR" "$ADAPTER_DIR" "$MERGED_DIR" "$(dirname "$SCORECARD")"
+
+if [[ ! -s "$AUDIO_DIR/model.safetensors" || ! -s "$AUDIO_DIR/tokenizer.json" ]]; then
+  "$BIN" convert \
+    --config configs/document_qa_smoke.toml \
+    --input "$DOCUMENT_DIR/model.safetensors" \
+    --output "$AUDIO_DIR/model.safetensors" \
+    --tokenizer "$DOCUMENT_DIR/tokenizer.json" \
+    --output-tokenizer "$AUDIO_DIR/tokenizer.json" \
+    --upgrade-audio-vocab
+fi
+
+"$BIN" finetune audio-dora \
+  --config configs/audio_qa_smoke.toml \
+  --base "$AUDIO_DIR/model.safetensors" \
+  --tokenizer "$AUDIO_DIR/tokenizer.json" \
+  --data data/audio_smoke/audio_qa_smoke_4.jsonl \
+  --output "$ADAPTER_DIR" \
+  --projector data/audio_smoke/projector_init.safetensors \
+  --lora-rank 4 \
+  --batch-size 1 \
+  --max-steps 2 \
+  --log-every-n-steps 1 \
+  --save-every-n-steps 0
+
+for artifact in adapter.safetensors projector.safetensors adapter_config.json audio_adapter_config.json; do
+  [[ -s "$ADAPTER_DIR/$artifact" ]] || {
+    echo "missing Phase 42 training artifact: $ADAPTER_DIR/$artifact" >&2
+    exit 2
+  }
+done
+
+"$BIN" finetune merge \
+  --config configs/audio_qa_smoke.toml \
+  --base "$AUDIO_DIR/model.safetensors" \
+  --adapter "$ADAPTER_DIR" \
+  --method dora \
+  --output "$MERGED_DIR"
+
+"$BIN" infer \
+  --config configs/audio_qa_smoke_infer.toml \
+  --model "$MERGED_DIR/model.safetensors" \
+  --tokenizer "$AUDIO_DIR/tokenizer.json" \
+  --audio data/audio_smoke/audio/mid_tone.wav \
+  --prompt "What sound is this?" \
+  --max-tokens 2 \
+  --greedy \
+  --safety none
+
+"$BIN" eval \
+  --config configs/audio_qa_smoke_infer.toml \
+  --model "$MERGED_DIR/model.safetensors" \
+  --tokenizer "$AUDIO_DIR/tokenizer.json" \
+  --tasks audio-qa-smoke \
+  --data-dir data/eval \
+  --max-examples 2 \
+  --max-new-tokens 2 \
+  --out "$SCORECARD"
+
+[[ -s "$SCORECARD" ]] || {
+  echo "missing Phase 42 scorecard: $SCORECARD" >&2
+  exit 2
+}
+echo "Phase 42 audio smoke completed: $SCORECARD"