diff --git a/src-tauri/crates/berd-call/VAD_REPLAY.md b/src-tauri/crates/berd-call/VAD_REPLAY.md
new file mode 100644
index 000000000..80e03d47e
--- /dev/null
+++ b/src-tauri/crates/berd-call/VAD_REPLAY.md
@@ -0,0 +1,21 @@
+# Offline VAD replay
+
+This command evaluates continuous-recognition activity gates from normalized JSON fixtures and measures observed waiting from call capture event logs.
+
+Run `berd-call vad-replay INPUT.json --candidates CANDIDATES.json`. It emits JSONL, one report for the recorded settings followed by each named candidate, without opening a microphone or reading/writing live profiles. Candidate settings must be static. Recorded settings may include dynamic values because each frame records the values actually applied; replay does not simulate recognizer-driven learning.
+
+Input has `schema_version: 1`, `session_id`, `held_out`, `frames`, `labels` and `reply_waiting`. Frames contain `end_ms`, `epoch`, `confidence`, `mode` (listening/interruption), and `settings` using the existing DetectionSettings schema. Each frame represents 16 ms. Epoch changes are explicit live gate resets; missing frame intervals leave state unknown until a full onset/release run determines it again.
+
+Labels contain `start_ms`, `end_ms`, `speech` and `provenance` (human_checked/inferred). Label intervals must be ordered and nonoverlapping. Silence must be labeled explicitly; unlabelled audio is not assumed silent. Reply-waiting intervals contain start_ms/end_ms, also ordered and nonoverlapping. All times share the fixture's audio timeline. Candidate files contain an array of `{name, settings}`; names must be unique.
+
+Scores report human-checked speech missed and false activity durations at 16 ms resolution, silent activity overlapping a waiting reply, onset-delay samples, missed/excluded utterances and fragmentation. Inferred labels are counted but excluded from correctness scores. Full onset samples require uninterrupted known detector coverage over the annotation. Interruption detection samples use the recorded playback mode at speech onset. They measure gate detection, not audible agent stopping. Raw samples allow tail analysis without hiding misses in an average.
+
+These reports do not estimate a changed conversation's playback schedule. In particular, original reply-ready intervals and modes are fixed evidence. Replaying a stronger gate might change later playback in reality. Compare candidates on held-out sessions, inspect missed speech alongside latency, and trial improvements live before promoting them. No candidate is promoted by this command.
+
+Each input file is capped at 128 MiB and a comparison at 64 candidates. Split long recordings into fixtures with preserved context and epoch boundaries. Raw recordings and fixtures stay local unless separately shared.
+
+Run `berd-call vad-replay events CAPTURE_DIR` to analyze a `berd-call-capture/1` directory's `events.jsonl`. It measures the union of outstanding prepare-request intervals, their overlaps with VAD and pending recognition (reported separately and together), and admitted-request delay samples. Pending/not-admitted outcomes end a request interval without a successful admission sample. Gaps and capture limits censor outstanding requests; the interval immediately before a gap is excluded because its events may be missing. Requests left open at file end are reported unresolved. Logs must be ordered by monotonic microseconds; malformed/unknown-version input fails instead of producing a success score.
+
+Request-wait overlap is observational. It includes preparation and other scheduling, so it is not proof of delay caused solely by VAD or recognition. The event analyzer uses the capture clock; normalized frame fixtures use the audio timeline. Converting the per-frame capture trace into candidate fixtures requires explicit sample/clock and epoch mapping. It must never infer timestamps by concatenating across muted/dropped input.
+
+Pending recognition can hold replies after VAD clears. The Apple worker currently uses VAD end to start a five-second no-result deadline, then cancels and recreates recognition. Gate replay cannot prove transcript preservation under changed reset policies. Those trials require original audio, repeated recognition runs against the current-policy baseline, and omission/duplicate/late-result evaluation.
diff --git a/src-tauri/crates/berd-call/src/capture_metrics.rs b/src-tauri/crates/berd-call/src/capture_metrics.rs
new file mode 100644
index 000000000..49887c791
--- /dev/null
+++ b/src-tauri/crates/berd-call/src/capture_metrics.rs
@@ -0,0 +1,141 @@
+//! Observed request/recognition timing from capture events, not causal attribution.
+use serde::Serialize;
+use serde_json::Value;
+use std::collections::HashMap;
+
+#[derive(Default, Serialize)]
+pub struct CaptureMetrics {
+    pub request_wait_us: u64,
+    pub request_wait_with_vad_us: u64,
+    pub request_wait_with_recognition_pending_us: u64,
+    pub request_wait_with_both_us: u64,
+    pub request_wait_with_unknown_state_us: u64,
+    pub admitted_request_delays_us: Vec<u64>,
+    pub unresolved_requests: u64,
+    pub requests_censored_by_gap: u64,
+    pub capture_gaps: u64,
+    pub recognizer_events: u64,
+    pub excluded_before_gap_us: u64,
+    pub capture_limited: bool,
+}
+
+pub fn measure(events: &[Value]) -> Result<CaptureMetrics, String> {
+    let mut result = CaptureMetrics::default();
+    let mut pending = HashMap::<u64, u64>::new();
+    let mut speaking = Some(false);
+    let mut recognition = Some(false);
+    let mut previous = None;
+    for event in events {
+        let us = event["us"]
+            .as_u64()
+            .ok_or("capture event needs unsigned us")?;
+        let kind = event["type"].as_str().ok_or("capture event needs type")?;
+        if previous.is_some_and(|previous| us < previous) {
+            return Err("capture events must be ordered by monotonic us".into());
+        }
+        let duration = us - previous.unwrap_or(us);
+        if matches!(kind, "gap" | "limit") {
+            result.excluded_before_gap_us += duration;
+        } else if !pending.is_empty() {
+            result.request_wait_us += duration;
+            match (speaking, recognition) {
+                (Some(true), Some(true)) => result.request_wait_with_both_us += duration,
+                (Some(true), Some(false)) => result.request_wait_with_vad_us += duration,
+                (Some(false), Some(true)) => {
+                    result.request_wait_with_recognition_pending_us += duration
+                }
+                (None, _) | (_, None) => result.request_wait_with_unknown_state_us += duration,
+                _ => {}
+            }
+        }
+        previous = Some(us);
+        match kind {
+            "gap" | "limit" => {
+                result.capture_gaps += 1;
+                result.capture_limited |= kind == "limit";
+                result.requests_censored_by_gap += pending.len() as u64;
+                pending.clear();
+                speaking = None;
+                recognition = None;
+            }
+            "recognizer" => {
+                result.recognizer_events += 1;
+            }
+            "in" | "out" => {
+                let message = &event["message"];
+                let message_type = message["type"]
+                    .as_str()
+                    .ok_or("protocol event needs message.type")?;
+                match (kind, message_type) {
+                    ("in", "prepare_speak") => {
+                        let id = message["id"].as_u64().ok_or("prepare_speak needs id")?;
+                        if pending.insert(id, us).is_some() {
+                            return Err("duplicate outstanding prepare_speak id".into());
+                        }
+                    }
+                    ("out", "admitted" | "not_admitted" | "pending") => {
+                        let id = message["id"].as_u64().ok_or("prepare outcome needs id")?;
+                        if let Some(start) = pending.remove(&id) {
+                            if message_type == "admitted" {
+                                result.admitted_request_delays_us.push(us - start);
+                            }
+                        }
+                    }
+                    ("out", "input_speaking") => {
+                        speaking = Some(
+                            message["active"]
+                                .as_bool()
+                                .ok_or("input_speaking needs active")?,
+                        );
+                    }
+                    ("out", "recognition_pending") => {
+                        recognition = Some(
+                            message["active"]
+                                .as_bool()
+                                .ok_or("recognition_pending needs active")?,
+                        );
+                    }
+                    _ => {}
+                }
+            }
+            _ => {}
+        }
+    }
+    result.unresolved_requests = pending.len() as u64;
+    Ok(result)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+    #[test]
+    fn separates_vad_from_recognition_only_waiting() {
+        let events = vec![
+            json!({"us":0,"type":"out","message":{"type":"input_speaking","active":true}}),
+            json!({"us":0,"type":"out","message":{"type":"recognition_pending","active":true}}),
+            json!({"us":10,"type":"in","message":{"type":"prepare_speak","id":1}}),
+            json!({"us":20,"type":"out","message":{"type":"input_speaking","active":false}}),
+            json!({"us":50,"type":"out","message":{"type":"recognition_pending","active":false}}),
+            json!({"us":60,"type":"out","message":{"type":"admitted","id":1}}),
+        ];
+        let result = measure(&events).unwrap();
+        assert_eq!(result.request_wait_us, 50);
+        assert_eq!(result.request_wait_with_both_us, 10);
+        assert_eq!(result.request_wait_with_recognition_pending_us, 30);
+        assert_eq!(result.admitted_request_delays_us, vec![50]);
+    }
+    #[test]
+    fn gaps_censor_requests_instead_of_scoring_success() {
+        let events = vec![
+            json!({"us":0,"type":"in","message":{"type":"prepare_speak","id":1}}),
+            json!({"us":20,"type":"gap","reason":"capture_dropped"}),
+            json!({"us":30,"type":"out","message":{"type":"admitted","id":1}}),
+        ];
+        let result = measure(&events).unwrap();
+        assert_eq!(result.requests_censored_by_gap, 1);
+        assert_eq!(result.request_wait_us, 0);
+        assert_eq!(result.excluded_before_gap_us, 20);
+        assert!(result.admitted_request_delays_us.is_empty());
+    }
+}
diff --git a/src-tauri/crates/berd-call/src/cli_help.rs b/src-tauri/crates/berd-call/src/cli_help.rs
index a3772424a..a3c141b2e 100644
--- a/src-tauri/crates/berd-call/src/cli_help.rs
+++ b/src-tauri/crates/berd-call/src/cli_help.rs
@@ -22,6 +22,7 @@ Speech and models:
   models                  Inspect or install speech models
 
 Diagnostics:
+  vad-replay              Compare offline continuous-recognition VAD fixtures
   benchmark tts           Benchmark a TTS backend
   benchmark stt           Benchmark an STT backend
 
@@ -275,6 +276,7 @@ fn help_for(topic: &[&str]) -> Option<&'static str> {
         | ["models", "openai", "voices"]
         | ["models", "pocket", "status" | "install" | "voices"]
         | ["models", "parakeet", "status" | "install"] => Some(MODELS_HELP),
+        ["vad-replay"] => Some("Usage: berd-call vad-replay INPUT.json [--candidates CANDIDATES.json]\n       berd-call vad-replay events CAPTURE_DIR\n\nReplays continuous-recognition VAD fixtures without changing live profiles.\nWrites one JSON report per recorded/candidate profile. See VAD_REPLAY.md for the fixture schema and scoring limits."),
         ["benchmark"] => Some(BENCHMARK_HELP),
         ["benchmark", "tts"] => Some(BENCHMARK_TTS_HELP),
         ["benchmark", "stt"] => Some(BENCHMARK_STT_HELP),
diff --git a/src-tauri/crates/berd-call/src/lib.rs b/src-tauri/crates/berd-call/src/lib.rs
index ecdc19644..90ce549b3 100644
--- a/src-tauri/crates/berd-call/src/lib.rs
+++ b/src-tauri/crates/berd-call/src/lib.rs
@@ -6,6 +6,7 @@ pub const MAC_SPEECH_RECOGNITION_FINISH_TIMEOUT_SECONDS: u64 = 5;
 mod asset_verification;
 mod audio_output;
 pub mod benchmark;
+pub mod capture_metrics;
 pub mod causal_inbox;
 mod configured_tts;
 pub mod detection;
@@ -42,6 +43,7 @@ mod synthesis;
 mod tts;
 #[cfg(target_os = "macos")]
 pub mod update_guard;
+pub mod vad_replay;
 
 pub use audio_output::{wait_until_drained, PcmAudioOutput};
 pub use configured_tts::{
diff --git a/src-tauri/crates/berd-call/src/main.rs b/src-tauri/crates/berd-call/src/main.rs
index fb0ab5404..2a20f8250 100644
--- a/src-tauri/crates/berd-call/src/main.rs
+++ b/src-tauri/crates/berd-call/src/main.rs
@@ -82,6 +82,7 @@ mod session_audio;
 mod session_framing;
 #[cfg(target_os = "macos")]
 mod system_input_mute;
+mod vad_replay_cli;
 
 use session_audio::{
     AudioHostAck, AudioOutputControlRequest, AudioPipeTransport, RemotePcmAudioOutput,
@@ -550,6 +551,13 @@ fn main() {
         None => {}
     }
     match args.get(1).map(String::as_str) {
+        Some("vad-replay") => {
+            if let Err(error) = vad_replay_cli::run(&args[2..]) {
+                eprintln!("berd-call vad-replay: {error}");
+                std::process::exit(2);
+            }
+        }
+
         #[cfg(target_os = "macos")]
         Some("detection-profile") => {
             let result = (|| -> Result<serde_json::Value, String> {
diff --git a/src-tauri/crates/berd-call/src/vad_replay.rs b/src-tauri/crates/berd-call/src/vad_replay.rs
new file mode 100644
index 000000000..7f0222045
--- /dev/null
+++ b/src-tauri/crates/berd-call/src/vad_replay.rs
@@ -0,0 +1,488 @@
+//! Deterministic replay of the continuous-recognition activity gate.
+//! This predicts gate decisions, never counterfactual audible playback.
+use crate::detection::{DetectionSettings, SpeechGate};
+use serde::{Deserialize, Serialize};
+
+pub const FRAME_MS: u64 = 16;
+
+#[derive(Clone, Copy, Debug, Deserialize, Serialize, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+pub enum Mode {
+    Listening,
+    Interruption,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(deny_unknown_fields)]
+pub struct Frame {
+    /// End of a complete 16 ms detector frame on the recording timeline.
+    pub end_ms: u64,
+    pub epoch: u64,
+    pub confidence: f32,
+    pub mode: Mode,
+    pub settings: DetectionSettings,
+}
+
+#[derive(Clone, Copy, Debug, Deserialize, Serialize, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+pub enum Provenance {
+    HumanChecked,
+    Inferred,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(deny_unknown_fields)]
+pub struct Label {
+    pub start_ms: u64,
+    pub end_ms: u64,
+    pub speech: bool,
+    pub provenance: Provenance,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(deny_unknown_fields)]
+pub struct Interval {
+    pub start_ms: u64,
+    pub end_ms: u64,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(deny_unknown_fields)]
+pub struct ReplayInput {
+    pub schema_version: u32,
+    pub session_id: String,
+    pub held_out: bool,
+    pub frames: Vec<Frame>,
+    pub labels: Vec<Label>,
+    /// Reply-ready until admitted/cancelled, on the same timeline.
+    pub reply_waiting: Vec<Interval>,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(deny_unknown_fields)]
+pub struct Candidate {
+    pub name: String,
+    pub settings: DetectionSettings,
+}
+
+#[derive(Debug, Serialize)]
+pub struct Decision {
+    pub end_ms: u64,
+    pub epoch: u64,
+    pub mode: Mode,
+    /// None means a capture gap has left the prior gate state unknown.
+    pub active: Option<bool>,
+}
+
+#[derive(Debug, Default, Serialize)]
+pub struct Latencies {
+    pub samples_ms: Vec<u64>,
+    pub missed: u64,
+    pub excluded: u64,
+}
+
+#[derive(Debug, Default, Serialize)]
+pub struct Scores {
+    pub human_checked_ms: u64,
+    pub speech_onset: Latencies,
+    pub interruption_detection: Latencies,
+    pub speech_fragments: u64,
+    pub missed_speech_ms: u64,
+    pub false_activity_ms: u64,
+    pub silent_reply_held_ms: u64,
+    pub inferred_label_ms: u64,
+    pub unlabelled_ms: u64,
+    pub gap_ms: u64,
+    pub uncertain_ms: u64,
+}
+
+#[derive(Debug, Serialize)]
+pub struct Report {
+    pub session_id: String,
+    pub held_out: bool,
+    pub candidate: String,
+    pub scores: Scores,
+    pub decisions: Vec<Decision>,
+}
+
+fn validate_intervals(intervals: impl Iterator<Item = (u64, u64)>) -> Result<(), String> {
+    let mut previous_end = 0;
+    for (start, end) in intervals {
+        if start >= end || start < previous_end {
+            return Err("intervals must be nonempty, ordered and nonoverlapping".into());
+        }
+        previous_end = end;
+    }
+    Ok(())
+}
+
+impl ReplayInput {
+    pub fn validate(&self) -> Result<(), String> {
+        if self.schema_version != 1 || self.session_id.trim().is_empty() || self.frames.is_empty() {
+            return Err("replay needs schema_version 1, a session_id and frames".into());
+        }
+        validate_intervals(
+            self.labels
+                .iter()
+                .map(|label| (label.start_ms, label.end_ms)),
+        )?;
+        validate_intervals(
+            self.reply_waiting
+                .iter()
+                .map(|span| (span.start_ms, span.end_ms)),
+        )?;
+        let mut previous = None;
+        for frame in &self.frames {
+            frame.settings.validate()?;
+            if !frame.confidence.is_finite() || !(0.0..=1.0).contains(&frame.confidence) {
+                return Err("frame confidence must be finite and between 0 and 1".into());
+            }
+            if frame.end_ms < FRAME_MS
+                || previous.is_some_and(|end| frame.end_ms.saturating_sub(end) < FRAME_MS)
+            {
+                return Err("detector frames must be ordered and nonoverlapping".into());
+            }
+            previous = Some(frame.end_ms);
+        }
+        Ok(())
+    }
+}
+
+/// Reuse the live gate and its strict confidence comparison.
+/// Candidates are static profiles; outcome-based online learning is not simulated.
+pub fn replay(input: &ReplayInput, candidate: Option<&Candidate>) -> Result<Report, String> {
+    input.validate()?;
+    if let Some(candidate) = candidate {
+        candidate.settings.validate()?;
+        if candidate.name.trim().is_empty()
+            || candidate.settings.listening.dynamic
+            || candidate.settings.interruption.dynamic
+        {
+            return Err("candidate needs a name and static thresholds".into());
+        }
+    }
+    let mut report = Report {
+        session_id: input.session_id.clone(),
+        held_out: input.held_out,
+        candidate: candidate.map_or("recorded".into(), |value| value.name.clone()),
+        scores: Scores::default(),
+        decisions: Vec::with_capacity(input.frames.len()),
+    };
+    let mut gate = SpeechGate::default();
+    let mut previous: Option<&Frame> = None;
+    let mut uncertain = false;
+    let mut consecutive = 0u64;
+    let mut last_detected = None;
+    let mut label_index = 0;
+    let mut waiting_index = 0;
+    for frame in &input.frames {
+        let settings = candidate.map_or(frame.settings, |value| value.settings);
+        let gap = previous.map_or(frame.end_ms - FRAME_MS, |prior| {
+            frame.end_ms - prior.end_ms - FRAME_MS
+        });
+        if gap > 0 {
+            report.scores.gap_ms += gap;
+            gate = SpeechGate::default();
+            uncertain = true;
+            consecutive = 0;
+            last_detected = None;
+        }
+        // Epoch changes correspond to explicit live gate resets.
+        if previous.is_some_and(|prior| prior.epoch != frame.epoch) {
+            gate = SpeechGate::default();
+            uncertain = false;
+            consecutive = 0;
+            last_detected = None;
+        }
+        let threshold = match frame.mode {
+            Mode::Listening => settings.listening.value,
+            Mode::Interruption => settings.interruption.value,
+        };
+        let detected = frame.confidence > threshold;
+        consecutive = if last_detected == Some(detected) {
+            consecutive + 1
+        } else {
+            1
+        };
+        last_detected = Some(detected);
+        // Either a full onset or release run determines state regardless of missing history.
+        let settling_ms = if detected {
+            settings.timing.onset_ms
+        } else {
+            settings.timing.release_ms
+        };
+        if consecutive >= u64::from(settling_ms.div_ceil(16).max(1)) {
+            uncertain = false;
+        }
+        let active = gate.observe(detected, settings.timing);
+        let start = frame.end_ms - FRAME_MS;
+        while label_index < input.labels.len() && input.labels[label_index].end_ms <= start {
+            label_index += 1;
+        }
+        while waiting_index < input.reply_waiting.len()
+            && input.reply_waiting[waiting_index].end_ms <= start
+        {
+            waiting_index += 1;
+        }
+        if uncertain {
+            report.scores.uncertain_ms += FRAME_MS;
+        } else {
+            let mut labelled_ms = 0;
+            for label in input.labels[label_index..]
+                .iter()
+                .take_while(|label| label.start_ms < frame.end_ms)
+            {
+                let end = label.end_ms.min(frame.end_ms);
+                let begin = label.start_ms.max(start);
+                let duration = end.saturating_sub(begin);
+                labelled_ms += duration;
+                if label.provenance == Provenance::Inferred {
+                    report.scores.inferred_label_ms += duration;
+                    continue;
+                }
+                report.scores.human_checked_ms += duration;
+                if label.speech && !active {
+                    report.scores.missed_speech_ms += duration;
+                }
+                if !label.speech && active {
+                    report.scores.false_activity_ms += duration;
+                    for span in input.reply_waiting[waiting_index..]
+                        .iter()
+                        .take_while(|span| span.start_ms < end)
+                    {
+                        report.scores.silent_reply_held_ms += end
+                            .min(span.end_ms)
+                            .saturating_sub(begin.max(span.start_ms));
+                    }
+                }
+            }
+            report.scores.unlabelled_ms += FRAME_MS - labelled_ms;
+        }
+        report.decisions.push(Decision {
+            end_ms: frame.end_ms,
+            epoch: frame.epoch,
+            mode: frame.mode,
+            active: (!uncertain).then_some(active),
+        });
+        previous = Some(frame);
+    }
+    score_utterances(input, &mut report);
+    Ok(report)
+}
+
+fn score_utterances(input: &ReplayInput, report: &mut Report) {
+    for label in input
+        .labels
+        .iter()
+        .filter(|label| label.speech && label.provenance == Provenance::HumanChecked)
+    {
+        let first = report
+            .decisions
+            .partition_point(|decision| decision.end_ms <= label.start_ms);
+        let end = report
+            .decisions
+            .partition_point(|decision| decision.end_ms < label.end_ms);
+        let end = (end + 1).min(report.decisions.len());
+        let decisions = &report.decisions[first..end.max(first)];
+        // Full speech annotation must have uninterrupted detector coverage.
+        let covered = decisions
+            .first()
+            .is_some_and(|value| value.end_ms - FRAME_MS <= label.start_ms)
+            && decisions
+                .last()
+                .is_some_and(|value| value.end_ms >= label.end_ms)
+            && decisions.windows(2).all(|pair| {
+                pair[1].end_ms - pair[0].end_ms == FRAME_MS && pair[1].epoch == pair[0].epoch
+            })
+            && decisions.iter().all(|decision| decision.active.is_some());
+        let interruption = decisions
+            .first()
+            .is_some_and(|value| value.mode == Mode::Interruption);
+        if !covered {
+            report.scores.speech_onset.excluded += 1;
+            if interruption {
+                report.scores.interruption_detection.excluded += 1;
+            }
+            continue;
+        }
+        let delay = decisions
+            .iter()
+            .find(|decision| decision.active == Some(true))
+            .map(|decision| decision.end_ms.saturating_sub(label.start_ms));
+        for latency in std::iter::once(&mut report.scores.speech_onset)
+            .chain(interruption.then_some(&mut report.scores.interruption_detection))
+        {
+            if let Some(delay) = delay {
+                latency.samples_ms.push(delay);
+            } else {
+                latency.missed += 1;
+            }
+        }
+        let runs = u64::from(
+            decisions
+                .first()
+                .is_some_and(|value| value.active == Some(true)),
+        ) + decisions
+            .windows(2)
+            .filter(|pair| pair[0].active == Some(false) && pair[1].active == Some(true))
+            .count() as u64;
+        report.scores.speech_fragments += runs.saturating_sub(1);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    fn input(confidences: &[f32]) -> ReplayInput {
+        ReplayInput {
+            schema_version: 1,
+            session_id: "fixture".into(),
+            held_out: true,
+            frames: confidences
+                .iter()
+                .enumerate()
+                .map(|(index, confidence)| Frame {
+                    end_ms: (index as u64 + 1) * FRAME_MS,
+                    epoch: 0,
+                    confidence: *confidence,
+                    mode: Mode::Listening,
+                    settings: DetectionSettings::default(),
+                })
+                .collect(),
+            labels: vec![],
+            reply_waiting: vec![],
+        }
+    }
+    #[test]
+    fn onset_latency_misses_and_fragmentation_use_complete_annotations() {
+        let mut input = input(&[0.0, 0.9, 0.0, 0.9]);
+        for frame in &mut input.frames {
+            frame.settings.timing.release_ms = 16;
+        }
+        input.labels = vec![Label {
+            start_ms: 0,
+            end_ms: 64,
+            speech: true,
+            provenance: Provenance::HumanChecked,
+        }];
+        let result = replay(&input, None).unwrap();
+        assert_eq!(result.scores.speech_onset.samples_ms, vec![32]);
+        assert_eq!(result.scores.speech_fragments, 1);
+        input.frames[2].epoch = 1;
+        input.frames[3].epoch = 1;
+        let result = replay(&input, None).unwrap();
+        assert_eq!(result.scores.speech_onset.excluded, 1);
+    }
+
+    #[test]
+    fn matches_production_gate_and_strict_threshold() {
+        let input = input(&[0.5, 0.51, 0.0, 0.0]);
+        let result = replay(&input, None).unwrap();
+        assert_eq!(
+            result
+                .decisions
+                .iter()
+                .map(|value| value.active)
+                .collect::<Vec<_>>(),
+            vec![Some(false), Some(true), Some(true), Some(true)]
+        );
+    }
+    #[test]
+    fn only_human_labels_score_and_only_waiting_time_is_penalized() {
+        let mut input = input(&[0.9, 0.0, 0.0]);
+        input.labels = vec![
+            Label {
+                start_ms: 0,
+                end_ms: 16,
+                speech: true,
+                provenance: Provenance::Inferred,
+            },
+            Label {
+                start_ms: 16,
+                end_ms: 48,
+                speech: false,
+                provenance: Provenance::HumanChecked,
+            },
+        ];
+        input.reply_waiting = vec![Interval {
+            start_ms: 24,
+            end_ms: 40,
+        }];
+        let report = replay(&input, None).unwrap();
+        assert_eq!(report.scores.human_checked_ms, 32);
+        assert_eq!(report.scores.inferred_label_ms, 16);
+        assert_eq!(report.scores.false_activity_ms, 32);
+        assert_eq!(report.scores.silent_reply_held_ms, 16);
+    }
+    #[test]
+    fn gaps_are_unknown_until_state_is_determined() {
+        let mut input = input(&[0.9, 0.0, 0.9]);
+        input.frames[1].end_ms = 64;
+        input.frames[2].end_ms = 80;
+        let report = replay(&input, None).unwrap();
+        assert_eq!(report.scores.gap_ms, 32);
+        assert_eq!(report.decisions[1].active, None);
+        assert_eq!(report.decisions[2].active, Some(true));
+    }
+    #[test]
+    fn mode_switch_uses_independent_threshold_and_epoch_resets() {
+        let mut input = input(&[0.6, 0.6]);
+        input.frames[1].mode = Mode::Interruption;
+        input.frames[1].epoch = 1;
+        let report = replay(&input, None).unwrap();
+        assert_eq!(report.decisions[0].active, Some(true));
+        assert_eq!(report.decisions[1].active, Some(false));
+    }
+    #[test]
+    fn candidate_is_static_and_does_not_mutate_recording() {
+        let input = input(&[0.6]);
+        let mut settings = DetectionSettings::default();
+        settings.listening.value = 0.7;
+        let candidate = Candidate {
+            name: "quiet".into(),
+            settings,
+        };
+        assert_eq!(
+            replay(&input, Some(&candidate)).unwrap().decisions[0].active,
+            Some(false)
+        );
+        assert_eq!(
+            replay(&input, None).unwrap().decisions[0].active,
+            Some(true)
+        );
+        settings.listening.dynamic = true;
+        assert!(replay(
+            &input,
+            Some(&Candidate {
+                name: "invalid".into(),
+                settings
+            })
+        )
+        .is_err());
+    }
+    #[test]
+    fn rejects_bad_frames_and_overlapping_labels() {
+        let mut input = input(&[0.2, 0.3]);
+        input.frames[1].end_ms = 16;
+        assert!(replay(&input, None).is_err());
+        input.frames[1].end_ms = 32;
+        input.frames[0].confidence = f32::NAN;
+        assert!(replay(&input, None).is_err());
+        input.frames[0].confidence = 0.5;
+        input.labels = vec![
+            Label {
+                start_ms: 0,
+                end_ms: 20,
+                speech: true,
+                provenance: Provenance::HumanChecked,
+            },
+            Label {
+                start_ms: 16,
+                end_ms: 32,
+                speech: false,
+                provenance: Provenance::HumanChecked,
+            },
+        ];
+        assert!(replay(&input, None).is_err());
+    }
+}
diff --git a/src-tauri/crates/berd-call/src/vad_replay_cli.rs b/src-tauri/crates/berd-call/src/vad_replay_cli.rs
new file mode 100644
index 000000000..b60030e76
--- /dev/null
+++ b/src-tauri/crates/berd-call/src/vad_replay_cli.rs
@@ -0,0 +1,86 @@
+use berd_call::vad_replay::{replay, Candidate, ReplayInput};
+use std::io::{Read, Write};
+use std::path::Path;
+
+const MAX_INPUT: u64 = 128 * 1024 * 1024;
+
+fn read_json<T: serde::de::DeserializeOwned>(path: &Path) -> Result<T, String> {
+    let file = std::fs::File::open(path).map_err(|error| format!("{}: {error}", path.display()))?;
+    let mut bytes = Vec::new();
+    file.take(MAX_INPUT + 1)
+        .read_to_end(&mut bytes)
+        .map_err(|error| error.to_string())?;
+    if bytes.len() as u64 > MAX_INPUT {
+        return Err("replay input exceeds 128 MiB; split sessions into fixtures".into());
+    }
+    serde_json::from_slice(&bytes).map_err(|error| format!("{}: {error}", path.display()))
+}
+
+pub fn run(args: &[String]) -> Result<(), String> {
+    if args.first().is_some_and(|value| value == "events") {
+        if args.len() != 2 {
+            return Err("usage: berd-call vad-replay events CAPTURE_DIR".into());
+        }
+        let root = Path::new(&args[1]);
+        let manifest: serde_json::Value = read_json(&root.join("manifest.json"))?;
+        if manifest["schema"] != "berd-call-capture/1" {
+            return Err("unsupported capture schema".into());
+        }
+        let file =
+            std::fs::File::open(root.join("events.jsonl")).map_err(|error| error.to_string())?;
+        let mut bytes = String::new();
+        file.take(MAX_INPUT + 1)
+            .read_to_string(&mut bytes)
+            .map_err(|error| error.to_string())?;
+        if bytes.len() as u64 > MAX_INPUT {
+            return Err("capture events exceed 128 MiB".into());
+        }
+        let events: Vec<serde_json::Value> = bytes
+            .lines()
+            .map(serde_json::from_str)
+            .collect::<Result<_, _>>()
+            .map_err(|error| error.to_string())?;
+        let metrics = berd_call::capture_metrics::measure(&events)?;
+        serde_json::to_writer(std::io::stdout().lock(), &metrics)
+            .map_err(|error| error.to_string())?;
+        println!();
+        return Ok(());
+    }
+    if args.len() != 1 && !(args.len() == 3 && args[1] == "--candidates") {
+        return Err("usage: berd-call vad-replay INPUT.json [--candidates CANDIDATES.json]".into());
+    }
+    let input: ReplayInput = read_json(Path::new(&args[0]))?;
+    let candidates: Vec<Candidate> = if args.len() == 3 {
+        read_json(Path::new(&args[2]))?
+    } else {
+        vec![]
+    };
+    if candidates.len() > 64 {
+        return Err("at most 64 candidates per comparison".into());
+    }
+    let mut names = std::collections::HashSet::new();
+    for candidate in &candidates {
+        if candidate.name == "recorded" || !names.insert(&candidate.name) {
+            return Err("candidate names must be unique and cannot be recorded".into());
+        }
+    }
+    // Validate every candidate before emitting any report.
+    input.validate()?;
+    for candidate in &candidates {
+        candidate.settings.validate()?;
+        if candidate.name.trim().is_empty()
+            || candidate.settings.listening.dynamic
+            || candidate.settings.interruption.dynamic
+        {
+            return Err("candidates need unique names and static thresholds".into());
+        }
+    }
+    let stdout = std::io::stdout();
+    let mut output = std::io::BufWriter::new(stdout.lock());
+    for candidate in std::iter::once(None).chain(candidates.iter().map(Some)) {
+        let report = replay(&input, candidate)?;
+        serde_json::to_writer(&mut output, &report).map_err(|error| error.to_string())?;
+        output.write_all(b"\n").map_err(|error| error.to_string())?;
+    }
+    output.flush().map_err(|error| error.to_string())
+}
diff --git a/src-tauri/crates/berd-call/tests/vad_replay_cli.rs b/src-tauri/crates/berd-call/tests/vad_replay_cli.rs
new file mode 100644
index 000000000..e1738a636
--- /dev/null
+++ b/src-tauri/crates/berd-call/tests/vad_replay_cli.rs
@@ -0,0 +1,106 @@
+use serde_json::{json, Value};
+use std::process::Command;
+
+fn settings(listening: f64) -> Value {
+    json!({"listening":{"value":listening,"dynamic":false},"interruption":{"value":0.65,"dynamic":false},"timing":{"onset_ms":16,"release_ms":16}})
+}
+
+#[test]
+fn real_cli_compares_profiles_and_preserves_input() {
+    let dir = tempfile::tempdir().unwrap();
+    let input = dir.path().join("input.json");
+    let candidates = dir.path().join("candidates.json");
+    let fixture = json!({
+        "schema_version":1,"session_id":"held-out-test","held_out":true,
+        "frames":[
+            {"end_ms":16,"epoch":0,"confidence":0.6,"mode":"listening","settings":settings(0.5)},
+            {"end_ms":32,"epoch":0,"confidence":0.0,"mode":"listening","settings":settings(0.5)}
+        ],
+        "labels":[{"start_ms":0,"end_ms":16,"speech":true,"provenance":"human_checked"},{"start_ms":16,"end_ms":32,"speech":false,"provenance":"human_checked"}],
+        "reply_waiting":[{"start_ms":16,"end_ms":32}]
+    }).to_string();
+    std::fs::write(&input, &fixture).unwrap();
+    std::fs::write(
+        &candidates,
+        json!([{"name":"higher","settings":settings(0.7)}]).to_string(),
+    )
+    .unwrap();
+    let output = Command::new(env!("CARGO_BIN_EXE_berd-call"))
+        .args([
+            "vad-replay",
+            input.to_str().unwrap(),
+            "--candidates",
+            candidates.to_str().unwrap(),
+        ])
+        .output()
+        .unwrap();
+    assert!(
+        output.status.success(),
+        "{}",
+        String::from_utf8_lossy(&output.stderr)
+    );
+    let reports: Vec<Value> = String::from_utf8(output.stdout)
+        .unwrap()
+        .lines()
+        .map(|line| serde_json::from_str(line).unwrap())
+        .collect();
+    assert_eq!(reports.len(), 2);
+    assert_eq!(reports[0]["scores"]["missed_speech_ms"], 0);
+    assert_eq!(reports[1]["scores"]["missed_speech_ms"], 16);
+    assert_eq!(
+        reports[0]["scores"]["speech_onset"]["samples_ms"],
+        json!([16])
+    );
+    assert_eq!(reports[1]["scores"]["speech_onset"]["missed"], 1);
+    assert_eq!(std::fs::read_to_string(input).unwrap(), fixture);
+}
+
+#[test]
+fn malformed_or_unsupported_input_fails_without_reports() {
+    let dir = tempfile::tempdir().unwrap();
+    let input = dir.path().join("invalid.json");
+    std::fs::write(&input, r#"{"schema_version":99}"#).unwrap();
+    let output = Command::new(env!("CARGO_BIN_EXE_berd-call"))
+        .args(["vad-replay", input.to_str().unwrap()])
+        .output()
+        .unwrap();
+    assert_eq!(output.status.code(), Some(2));
+    assert!(output.stdout.is_empty());
+}
+
+#[test]
+fn real_cli_reads_capture_events_and_reports_recognition_waiting() {
+    let dir = tempfile::tempdir().unwrap();
+    std::fs::write(
+        dir.path().join("manifest.json"),
+        r#"{"schema":"berd-call-capture/1"}"#,
+    )
+    .unwrap();
+    let events = [
+        json!({"us":0,"frame":0,"type":"out","message":{"type":"recognition_pending","active":true}}),
+        json!({"us":10,"frame":0,"type":"in","message":{"type":"prepare_speak","id":1}}),
+        json!({"us":50,"frame":0,"type":"out","message":{"type":"recognition_pending","active":false}}),
+        json!({"us":60,"frame":0,"type":"out","message":{"type":"admitted","id":1}}),
+    ];
+    std::fs::write(
+        dir.path().join("events.jsonl"),
+        events
+            .iter()
+            .map(Value::to_string)
+            .collect::<Vec<_>>()
+            .join("\n"),
+    )
+    .unwrap();
+    let output = Command::new(env!("CARGO_BIN_EXE_berd-call"))
+        .args(["vad-replay", "events", dir.path().to_str().unwrap()])
+        .output()
+        .unwrap();
+    assert!(
+        output.status.success(),
+        "{}",
+        String::from_utf8_lossy(&output.stderr)
+    );
+    let report: Value = serde_json::from_slice(&output.stdout).unwrap();
+    assert_eq!(report["request_wait_with_recognition_pending_us"], 40);
+    assert_eq!(report["admitted_request_delays_us"], json!([50]));
+}