@@ -0,0 +1,120 @@
+//! WAV 轴 ≡ 会话轴的对齐纯函数（批 6 T23 / R5.5-b 的根治方案）。
+//!
+//! @ai-context: Why —— 写块路径今天「纯追加」（WAV 轴 = 已写样本数 ÷ 16000），而会话轴
+//!              （`segments[].start_ms` = 会话纪元 − 累计暂停）走墙钟；`capture/audio_loopback.rs:432-437`
+//!              的**静默窗根本不产包**（`probe-audio-runtime.md` 的 D2）⇒ 两轴必然分叉
+//!              且**无上界** ⇒ 播放头会漂到分钟级。本模块判定「这一块之前该补多少静音」。
+//!              **基准轴 = `AudioChunk.timestamp_ms`**，它**已含暂停补偿**
+//!              （`audio_loopback.rs:455-466` 逐字 `epoch.elapsed() - paused_ms`；暂停时长在
+//!              恢复成功时 `:367-374` 才累加）⇒ 与 `segments[].start_ms` 同轴，无需另立基准。
+//! @ai-context: 副作用 = **无**（纯函数、零 IO、零依赖、无全局态）；`AlignBook` 是调用方
+//!              持有的值类型。消费者 = `audio_store::SessionAudioWriter::write_chunk`
+//!              与 `audio_align_tests.rs` / `audio_store_tests.rs`。
+//! @ai-context: 边界（**失效安全优先**：宁可退回今天的纯追加，也不写错位置）——`None` 的
+//!              四种情形：① 本块时间戳缺失 ② 为负 ③ **回退/乱序**（`next < prev_end`）
+//!              ④ 空档 > `MAX_GAP_MS`。`None` 的语义统一 =「**本块及后续一律不补**
+//!              （纯追加）」，由调用方同时置 `aligned = false` ⇒ **样本一个不丢**、
+//!              **不阻断会话主链路**（`audio_store.rs:9-10` 的降级方向不变）。
+//!              首块（`prev_end_ms = None`）⇒ `Some(0)`：T0 由首块锚定。
+
+/// 1 毫秒的样本数（16 kHz ÷ 1000；与 `audio_store::SAMPLE_RATE` 同契约，不重复定义采样率）。
+pub const SAMPLES_PER_MS: usize = 16;
+
+/// 单次空档补静音的**上限**（10 分钟）。
+///
+/// @ai-context: Why 必须有上限：空档由「静默窗无包」造成，**上不封界**（D2）⇒ 无上限会在
+///              一次超长静默里当场分配巨量缓冲（1 小时 = 115 MB）⇒ 超出即 `None`
+///              （不补 + `aligned = false`）。10 分钟是批 6 计划定的安全参数（追认项）。
+pub const MAX_GAP_MS: i64 = 10 * 60 * 1000;
+
+/// 一个空档应补多少静音样本；`None` = **失效安全**（不补，退回纯追加）。
+/// @ai-context: `prev_end_ms` 由调用方按「首个带时间戳的块 + 已写样本数 ÷ 16」推
+///              （不额外存时间戳，见 `AlignBook::last_end_ms`）；`next_ts_ms` = 本块的
+///              `AudioChunk.timestamp_ms`（块**发点** = 块末 ⇒ 首块锚定后，WAV 轴与该块
+///              末样本的会话时刻重合）。
+pub fn silence_gap_samples(prev_end_ms: Option<i64>, next_ts_ms: Option<i64>) -> Option<usize> {
+    let next = next_ts_ms?;
+    if next < 0 {
+        return None;
+    }
+    let Some(prev_end) = prev_end_ms else {
+        return Some(0); // 首块锚定 T0：不补
+    };
+    if next < prev_end {
+        return None; // 回退/乱序
+    }
+    let gap_ms = next - prev_end;
+    if gap_ms > MAX_GAP_MS {
+        return None; // 超大空档：宁可不补，也不写巨量静音
+    }
+    Some(gap_ms as usize * SAMPLES_PER_MS)
+}
+
+/// 对齐簿记（`SessionAudioWriter` 的字段集合；`aligned` 是**自证量**）。
+///
+/// @ai-context: `aligned` 初始 `true`（=「尚未发现偏差」，**不**等于「已确认对齐」），
+///              但**只要遇到一次**「缺失/为负/回退/超大空档」就**永久置 `false`**
+///              （本次会话内不恢复）；`aligned == false` ⇒ 后续块一律纯追加。
+///              **禁止**把它写成恒 `true` 的字段（R5.5-b 第 3 条）——读侧
+///              `commands_audio::read_aligned` 据此如实区分「有/无时间基准」，
+///              本修复之前录的 WAV 无 sidecar ⇒ 读侧 false（历史录音不假装精确）。
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct AlignBook {
+    /// 自证量（对外值用 `is_aligned()`：空录音不冒充「已对齐」）
+    pub aligned: bool,
+    /// 首个带时间戳的块的 `timestamp_ms`（= R5.5-b 的 T0）
+    pub first_ts_ms: Option<i64>,
+    /// 已写样本对应的**会话轴末端**（`first_ts_ms + 已写样本数 ÷ 16`，由样本数推）
+    pub last_end_ms: Option<i64>,
+    /// 已写样本数（含补的静音；`last_end_ms` 由它推 ⇒ 不额外存「上一块时间戳」）
+    written: u64,
+}
+
+impl AlignBook {
+    /// 新建（`aligned` 初始 `true` =「尚未发现偏差」）。
+    pub fn new() -> Self {
+        Self { aligned: true, first_ts_ms: None, last_end_ms: None, written: 0 }
+    }
+
+    /// 推进一块（**唯一**的状态转移：`write_chunk` 与 `alignment_plan` 共用 ⇒ 不分叉）；返回本块之前应补的静音样本数（`None` = 不补）。
+    pub fn step(&mut self, ts_ms: Option<i64>, samples: usize) -> Option<usize> {
+        if !self.aligned {
+            return None; // 已失效：后续纯追加（不补、不丢样本）
+        }
+        let Some(ts) = ts_ms else {
+            self.aligned = false; // ① 缺失时间戳
+            return None;
+        };
+        let pad = match silence_gap_samples(self.last_end_ms, Some(ts)) {
+            Some(pad) => pad,
+            None => {
+                self.aligned = false; // ②/③/④：为负 / 回退 / 超大空档
+                return None;
+            }
+        };
+        let first = *self.first_ts_ms.get_or_insert(ts); // 首块锚定 T0（此时 pad 必为 0）
+        self.written += (pad + samples) as u64;
+        self.last_end_ms = Some(first + (self.written / SAMPLES_PER_MS as u64) as i64);
+        Some(pad)
+    }
+
+    /// 自证量：`aligned` **且**至少写过一个带时间戳的块（空录音不得自称「已对齐」）。
+    pub fn is_aligned(&self) -> bool {
+        self.aligned && self.first_ts_ms.is_some()
+    }
+}
+
+/// 块序列 → 逐块的「写入前应补静音样本数」（纯函数；单测与自证的主入口）。
+///
+/// @ai-context: 与 `AlignBook::step` 的逐块驱动**逐元素相等**（V5 对拍）；生产路径
+///              （`write_chunk`）是增量的 ⇒ 本函数无生产调用点（同 `ChunkAccumulator::flush`）。
+#[allow(dead_code)]
+pub fn alignment_plan(chunks: &[(Option<i64>, usize)]) -> Vec<Option<usize>> {
+    let mut book = AlignBook::new();
+    chunks.iter().map(|(ts, n)| book.step(*ts, *n)).collect()
+}
+
+/// 单测独立文件（保持本文件 ≤300 行，AGENTS.md §3）。
+#[cfg(test)]
+#[path = "audio_align_tests.rs"]
+mod tests;
@@ -0,0 +1,192 @@
+//! WAV 轴与会话轴对齐的边界单测（批 6 T23 / R5.5-b 第 2 条逐字：≥7 条边界）。
+//!
+//! @ai-context: AAA 模式；**纯函数、零 IO、无墙钟**（夹具只用相对毫秒）。
+//!              覆盖：首块 · 连续块（零空档）· 单空档 · 多空档 · 超大空档 ·
+//!              时间戳回退/乱序 · 缺 `timestamp_ms` · 负时间戳 · 批量≡增量对拍 ·
+//!              **自证不变式**（含「发生过暂停」的会话形态）。
+
+use super::*;
+
+/// 会话纪元（毫秒；夹具只关心相对差）。
+const T0: i64 = 1_000;
+/// 一块的样本数 = 200 ms @16 kHz（`audio_loopback.rs:338` 的 `block_samples`）。
+const BLOCK: usize = 200 * SAMPLES_PER_MS;
+/// 一块的毫秒数（自证不变式的常数项：`timestamp_ms` 是块**发点** = 块末）。
+const BLOCK_MS: i64 = 200;
+
+// ① 首块：T0 由首块锚定 ⇒ 不补
+#[test]
+fn first_chunk_anchors_t0_without_padding() {
+    // Arrange & Act & Assert
+    assert_eq!(silence_gap_samples(None, Some(T0)), Some(0));
+    assert_eq!(silence_gap_samples(None, Some(0)), Some(0)); // 会话纪元处起步同样不补
+}
+
+// ② 连续块（零空档）：上一块末端 == 本块时间戳 ⇒ 不补
+#[test]
+fn consecutive_blocks_need_zero_padding() {
+    assert_eq!(silence_gap_samples(Some(T0 + 200), Some(T0 + 200)), Some(0));
+}
+
+// ③ 单空档：补**等长**静音（200 ms ⇒ 200 × 16 样本）
+#[test]
+fn single_gap_pads_equal_length_silence() {
+    assert_eq!(silence_gap_samples(Some(T0), Some(T0 + 200)), Some(200 * SAMPLES_PER_MS));
+    assert_eq!(silence_gap_samples(Some(T0), Some(T0 + 1)), Some(SAMPLES_PER_MS));
+}
+
+// ④ 多空档：逐块独立、总数守恒（每块各补自己的空档）
+#[test]
+fn multiple_gaps_are_independent() {
+    // Arrange：首块 T0 → 空档 300ms → 空档 700ms
+    let fixture = [
+        (Some(T0), BLOCK),
+        (Some(T0 + 200 + 300), BLOCK),
+        (Some(T0 + 200 + 300 + 200 + 700), BLOCK),
+    ];
+    // Act
+    let plan = alignment_plan(&fixture);
+    // Assert：首块 0；第 2 块补 300ms；第 3 块补 700ms（不叠加）
+    assert_eq!(plan, vec![Some(0), Some(300 * SAMPLES_PER_MS), Some(700 * SAMPLES_PER_MS)]);
+    let total: usize = fixture.iter().zip(&plan).map(|((_, n), p)| n + p.unwrap()).sum();
+    assert_eq!(total, 3 * BLOCK + 1_000 * SAMPLES_PER_MS); // 总数守恒
+}
+
+// ⑤ 超大空档：恰好上限仍补，多 1 ms 即失效安全（不补）
+#[test]
+fn oversized_gap_fails_safe_at_the_limit() {
+    assert_eq!(
+        silence_gap_samples(Some(T0), Some(T0 + MAX_GAP_MS)),
+        Some(MAX_GAP_MS as usize * SAMPLES_PER_MS)
+    );
+    assert_eq!(silence_gap_samples(Some(T0), Some(T0 + MAX_GAP_MS + 1)), None);
+}
+
+// ⑥ 时间戳回退/乱序：一律不补（`None`），且相等不是回退
+#[test]
+fn rollback_and_out_of_order_fail_safe() {
+    assert_eq!(silence_gap_samples(Some(T0 + 200), Some(T0 + 100)), None); // 回退 100ms
+    assert_eq!(silence_gap_samples(Some(T0 + 200), Some(T0)), None); // 乱序（退回更早）
+    assert_eq!(silence_gap_samples(Some(T0 + 200), Some(T0 - 1)), None);
+}
+
+// ⑦ 缺 `timestamp_ms`：不补；会话级 ⇒ 该块与后续所有块都不补（纯追加）
+#[test]
+fn missing_timestamp_fails_safe() {
+    assert_eq!(silence_gap_samples(Some(T0), None), None);
+    assert_eq!(silence_gap_samples(None, None), None); // 首块就缺时间戳 ⇒ 无基准
+    let fixture = [(Some(T0), BLOCK), (None, BLOCK), (Some(T0 + 5_000), BLOCK)];
+    assert_eq!(alignment_plan(&fixture), vec![Some(0), None, None]);
+}
+
+// ⑧ 负时间戳：不补（`None`），含首块为负
+#[test]
+fn negative_timestamp_fails_safe() {
+    assert_eq!(silence_gap_samples(None, Some(-1)), None);
+    assert_eq!(silence_gap_samples(Some(T0), Some(-200)), None);
+}
+
+// ⑨ 空簿记不冒充「已对齐」；一次偏差即**永久**失效（后续即便单调也不补）
+#[test]
+fn book_stays_unusable_after_a_single_deviation() {
+    // Arrange：空簿记（如零样本会话）
+    let mut book = AlignBook::new();
+    assert!(!book.is_aligned(), "无任何带时间戳的块 ⇒ 不得自称已对齐");
+    // Act：首块锚定 → 回退一次 → 恢复单调
+    assert_eq!(book.step(Some(T0), BLOCK), Some(0));
+    assert!(book.is_aligned());
+    assert_eq!(book.step(Some(T0 + 100), BLOCK), None); // 回退 ⇒ 永久失效
+    assert!(!book.is_aligned());
+    assert_eq!(book.step(Some(T0 + 100_000), BLOCK), None); // 失效后不再补
+    // Assert：失效后基准不再推进（纯追加不改变已写样本的会话轴末端）
+    assert_eq!(book.first_ts_ms, Some(T0));
+    assert_eq!(book.last_end_ms, Some(T0 + 200));
+    assert_eq!(book.aligned, false);
+}
+
+// ⑩ 批量 ≡ 增量（对拍）：两条路径在 ≥7 条夹具上逐元素相等
+#[test]
+fn batch_plan_equals_incremental_driver_on_all_fixtures() {
+    let fixtures: Vec<Vec<(Option<i64>, usize)>> = vec![
+        vec![],                                                    // 空序列
+        vec![(Some(T0), BLOCK)],                                   // 首块
+        vec![(Some(T0), BLOCK), (Some(T0 + 200), BLOCK)],          // 连续
+        vec![(Some(T0), BLOCK), (Some(T0 + 500), BLOCK)],          // 单空档
+        vec![(Some(T0), BLOCK), (Some(T0 + 500), BLOCK), (Some(T0 + 1_500), BLOCK)], // 多空档
+        vec![(Some(T0), BLOCK), (Some(T0 + MAX_GAP_MS + 1), BLOCK)], // 超大空档
+        vec![(Some(T0 + 1_000), BLOCK), (Some(T0 + 500), BLOCK)],  // 回退
+        vec![(Some(T0), BLOCK), (None, BLOCK), (Some(T0 + 9_000), BLOCK)], // 缺时间戳
+        vec![(Some(T0), BLOCK), (Some(-5), BLOCK)],                // 负时间戳
+        vec![(None, BLOCK), (Some(T0), BLOCK)],                    // 首块缺时间戳
+    ];
+    for f in &fixtures {
+        assert_eq!(alignment_plan(f), incremental_plan(f), "夹具 {:?}", f);
+    }
+}
+
+// ⑪ 自证不变式：补静音后「已写样本数 × 1000 ÷ 16000 ==（末块 ts − 首块 ts）+ 块长」，
+//    在「发生过暂停」的会话形态上同样成立（暂停两侧抵消 ⇒ 会话轴上不可见）
+#[test]
+fn self_proof_invariant_holds_across_pause_and_silence_window() {
+    // Arrange：连续两块 →（暂停 30s：端点停采 + 时间戳补偿 ⇒ 会话轴冻结点接续）→
+    //          恢复后一块 → 2s 静默窗（无包）→ 收尾两块
+    let fixture = vec![
+        (Some(T0), BLOCK),
+        (Some(T0 + 200), BLOCK),
+        (Some(T0 + 400), BLOCK),   // 暂停后恢复：会话轴上仍连续
+        (Some(T0 + 2_400), BLOCK), // 静默窗 1.8s ⇒ 补静音
+        (Some(T0 + 2_600), BLOCK),
+    ];
+    // Act
+    let plan = alignment_plan(&fixture);
+    let written: u64 = fixture
+        .iter()
+        .zip(&plan)
+        .map(|((_, n), p)| *n as u64 + p.unwrap_or(0) as u64)
+        .sum();
+    // Assert：逐字读数 —— 44800 样本；2800 ms == (2600 − 1000) + 200
+    assert_eq!(plan, vec![Some(0), Some(0), Some(0), Some(1_800 * SAMPLES_PER_MS), Some(0)]);
+    assert_eq!(written, 44_800);
+    let first = fixture[0].0.unwrap();
+    let last = fixture[fixture.len() - 1].0.unwrap();
+    assert_eq!(written * 1000 / 16_000, (last - first + BLOCK_MS) as u64);
+    // 等价形态：用「末块会话轴末端」（= `last_end_ms`）替代末块发点，二者差一个块长
+    let mut book = AlignBook::new();
+    for (ts, n) in &fixture {
+        book.step(*ts, *n);
+    }
+    assert!(book.is_aligned());
+    assert_eq!(written * 1000 / 16_000, (book.last_end_ms.unwrap() - first) as u64);
+}
+
+/// 逐块驱动（**测试侧独立实现**：只调 `silence_gap_samples`，不复用 `AlignBook`）——
+/// V5 对拍的基准：批量与增量两条路径分叉即红。
+fn incremental_plan(chunks: &[(Option<i64>, usize)]) -> Vec<Option<usize>> {
+    let mut out = Vec::new();
+    let mut aligned = true;
+    let mut first: Option<i64> = None;
+    let mut written: u64 = 0;
+    for (ts, n) in chunks {
+        if !aligned {
+            out.push(None);
+            written += *n as u64;
+            continue;
+        }
+        let prev_end = first.map(|f| f + (written / SAMPLES_PER_MS as u64) as i64);
+        match silence_gap_samples(prev_end, *ts) {
+            Some(pad) => {
+                if first.is_none() {
+                    first = *ts;
+                }
+                written += (pad + n) as u64;
+                out.push(Some(pad));
+            }
+            None => {
+                aligned = false;
+                written += *n as u64;
+                out.push(None);
+            }
+        }
+    }
+    out
+}
@@ -14,6 +14,14 @@
 use std::io::{Seek, Write};
 use std::path::{Path, PathBuf};
 
+/// WAV 轴 ≡ 会话轴的对齐纯函数（T23/R5.5-b 的根治方案；纯逻辑、零 IO、零依赖）。
+///
+/// @ai-context: 由父模块自己声明（DISPATCH-TEMPLATE §二）；`pub(crate)` 是跨模块引用的
+///              必要条件（`live_session*` 与本模块的测试都要用）。
+#[path = "audio_align.rs"]
+#[allow(dead_code)] // 本提交只落纯函数 + 单测（尚未接线）；接线提交落地后即删
+pub(crate) mod audio_align;
+
 /// 默认保留期（天）。
 pub const DEFAULT_RETENTION_DAYS: u64 = 30;
 /// 默认磁盘预算（字节；1 小时 ≈ 115MB，预算 4GB ≈ 35 小时会话）。