feat(audio,bridge,flutter): v1 audio + PTT lifecycle implementation (SDD-094..097)

Implement the SDD-094 / SDD-095 / SDD-096 / SDD-097 detailed designs
committed in dfa84ee.

Rust side
- chanora_audio::TransmitMode enum (Ptt/Continuous/VoiceActivity) with
  serde-friendly u8 repr (SDD-095).
- chanora_audio::TransmitModeSelector: lock-free Atomic-backed selector
  that is the sole writer of transmit_active (per SAD-083), applying
  hard_mute as a final clamp. VoiceActivity falls through to Continuous
  for v1 (DEC-030 placeholder).
- chanora_audio::ReleaseTailTimer: tokio-task-owning struct driving the
  selector's ptt_held input; default 200 ms tail, configurable 0–500 ms
  with AtomicU32 hot read; pending JoinHandle held in a std::sync::Mutex
  touched only on PTT edge transitions (SDD-096).
- chanora_storage: AudioMeta persisted as audio_meta.json next to
  identity.dek; get/set_transmit_mode + get/set_release_tail_ms with
  0..=500 clamp on write.
- chanora_core::ChanoraSession: voice_join(channel, password) and
  voice_leave() are the new lifecycle entry points; ensure_audio_running
  and shutdown_audio_if_idle are private helpers around the existing
  Option<AudioEngine> field. SessionEvent::VoiceState carries the
  in_channel / transmit_mode / mute / release_tail_ms tuple. Selector
  state survives reconnect; supervisor rewires it to each fresh engine
  gate.
- chanora_bridge: drop start_audio; add voice_join, voice_leave,
  set/get_transmit_mode, set/get_release_tail_ms, set_hard_mute.
  BridgeEvent::VoiceState mirrors the core event. AudioStarted/Stopped
  kept for backwards compat but Flutter ignores them in the new UI.

Flutter side
- New apps/chanora_flutter/lib/widgets/voice_bar.dart replaces the
  legacy _AudioControls widget. Renders channel pill, mode badge,
  mute toggle, level meter, PttCapabilityBadge, leave button. No
  manual Start affordance anywhere.
- New apps/chanora_flutter/lib/widgets/voice_settings.dart dialog with
  TransmitMode radio group (VoiceActivity disabled with 'Coming soon'
  trailing label per DEC-030), bind-key button, release-tail slider
  0–500 ms step 25.
- main.dart: state fields _inChannel, _transmitMode, _hardMute,
  _releaseTailMs driven by BridgeEvent_VoiceState. Channel-tap now
  calls voiceJoin instead of moveToChannel. Removed _onStartAudio,
  _audioStarted-gated branch, and the FilledButton.
- l10n: 11 new strings in app_en.arb + app_zh.arb.

Verification
- cargo check --workspace: clean.
- cargo test --workspace --lib: 72 passed / 0 failed / 1 ignored
  (chanora_audio: +12 new tests for TransmitMode/Selector/ReleaseTail;
  chanora_storage: +2 new tests for audio_meta round-trip).
- flutter analyze: 0 errors, 0 warnings; 6 infos are the Flutter 3.32
  Radio.groupValue deprecation (pre-existing API usage).
- FRB Dart/Rust bindings regenerated via flutter_rust_bridge_codegen.

Follow-up (intentionally deferred)
- PttController and per-platform PTT backends still drive AudioTransmitGate
  directly via the legacy set_ptt path; routing those key edges through
  ChanoraSession::release_tail_timer().{key_down,key_up} so the tail
  applies to native PTT input is a contained wiring change in a follow-up.
- Real audio-level RMS in BridgeAudioStats (current meter is binary).
- VoiceActivity backend (DEC-030).

crates/chanora_audio/src/engine.rs

@@ -137,9 +137,23 @@ impl AudioEngine {
     /// Start the engine: open capture + playback streams, spawn the
     /// inbound-voice forwarder, return a handle.
     pub fn start(
+        cfg: AudioEngineConfig,
+        voice_out_tx: mpsc::Sender<OutPacket>,
+        voice_in_rx: mpsc::Receiver<InboundVoice>,
+    ) -> Result<Self, AudioError> {
+        let gate = crate::ptt::AudioTransmitGate::new(cfg.ptt_initial);
+        Self::start_with_gate(cfg, voice_out_tx, voice_in_rx, gate)
+    }
+
+    /// Start the engine using an externally-owned
+    /// [`AudioTransmitGate`]. The gate is shared with whatever
+    /// upstream (typically [`crate::TransmitModeSelector`]) is the
+    /// authoritative writer of `transmit_active`. See SAD-083.
+    pub fn start_with_gate(
         cfg: AudioEngineConfig,
         voice_out_tx: mpsc::Sender<OutPacket>,
         mut voice_in_rx: mpsc::Receiver<InboundVoice>,
+        transmit_gate: crate::ptt::AudioTransmitGate,
     ) -> Result<Self, AudioError> {
         let host = cpal::default_host();
         info!(
@@ -237,7 +251,6 @@ impl AudioEngine {
             }
         }
 
-        let transmit_gate = crate::ptt::AudioTransmitGate::new(cfg.ptt_initial);
         let transmit_flag_for_capture = transmit_gate.flag_arc();
         let frames_sent = Arc::new(AtomicU32::new(0));
         let frames_received = Arc::new(AtomicU32::new(0));

crates/chanora_audio/src/lib.rs

@@ -31,6 +31,9 @@
 mod engine;
 pub mod ptt;
 pub mod ptt_backends;
+pub mod release_tail;
+pub mod transmit_mode;
+pub mod transmit_selector;
 
 pub use engine::{AudioEngine, AudioEngineConfig};
 pub use ptt::{
@@ -40,6 +43,9 @@ pub use ptt_backends::{
     select as select_ptt_backend, DesktopPttBackend, FocusedPttBackend, PttBackendError,
     PttBinding, PttInputClass,
 };
+pub use release_tail::{ReleaseTailTimer, DEFAULT_TAIL_MS, MAX_TAIL_MS};
+pub use transmit_mode::TransmitMode;
+pub use transmit_selector::TransmitModeSelector;
 
 use thiserror::Error;
 

crates/chanora_audio/src/release_tail.rs

@@ -0,0 +1,181 @@
+//! Release-tail timer (SDD-096).
+//!
+//! When a PTT key is released we don't immediately cut transmission
+//! — we keep the gate open for a short configurable tail (0–500 ms,
+//! default 200 ms) so room reverb and the trailing edge of words
+//! aren't clipped. A subsequent `key_down` within the tail window
+//! cancels the pending release so transmission stays continuous.
+//!
+//! The timer drives the `ptt_held` input of a
+//! [`crate::transmit_selector::TransmitModeSelector`] rather than
+//! the [`crate::AudioTransmitGate`] directly — the selector then
+//! decides whether the desired gate state is `true` or `false`
+//! based on the current [`crate::TransmitMode`]. This keeps a
+//! single owner of `transmit_active` (SAD-083).
+//!
+//! Threading model:
+//!
+//! * `tail_ms` is an [`AtomicU32`] so config changes are visible
+//!   immediately to any in-flight release task.
+//! * The pending [`JoinHandle`] is held in a [`std::sync::Mutex`].
+//!   The mutex is only ever touched on PTT *edge* transitions
+//!   (`key_down` / `key_up`) — never on the audio frame hot path
+//!   — so the brief acquisition is acceptable.
+
+use std::sync::atomic::{AtomicU32, Ordering};
+use std::sync::{Arc, Mutex};
+use std::time::Duration;
+
+use tokio::task::JoinHandle;
+
+use crate::transmit_selector::TransmitModeSelector;
+
+/// Maximum configurable release-tail, in milliseconds.
+pub const MAX_TAIL_MS: u32 = 500;
+
+/// Default release-tail (SDD-096).
+pub const DEFAULT_TAIL_MS: u32 = 200;
+
+/// Coalesces a PTT key release into a deferred selector update.
+///
+/// Cheap to clone via `Arc`.
+pub struct ReleaseTailTimer {
+    selector: Arc<TransmitModeSelector>,
+    pending: Arc<Mutex<Option<JoinHandle<()>>>>,
+    tail_ms: AtomicU32,
+}
+
+impl ReleaseTailTimer {
+    /// Construct a new timer wired to `selector`. `tail_ms` is
+    /// clamped to `0..=MAX_TAIL_MS` (SDD-096).
+    pub fn new(selector: Arc<TransmitModeSelector>, tail_ms: u32) -> Self {
+        Self {
+            selector,
+            pending: Arc::new(Mutex::new(None)),
+            tail_ms: AtomicU32::new(tail_ms.min(MAX_TAIL_MS)),
+        }
+    }
+
+    /// Update the configured tail, clamped to `0..=MAX_TAIL_MS`.
+    pub fn set_tail_ms(&self, ms: u32) {
+        self.tail_ms.store(ms.min(MAX_TAIL_MS), Ordering::Relaxed);
+    }
+
+    /// Current configured tail (post-clamp).
+    pub fn tail_ms(&self) -> u32 {
+        self.tail_ms.load(Ordering::Relaxed)
+    }
+
+    /// Notify the timer that the PTT key went down. Cancels any
+    /// pending release and immediately marks the selector's
+    /// `ptt_held` input as `true`.
+    pub fn key_down(&self) {
+        self.cancel_pending();
+        self.selector.set_ptt_held(true);
+    }
+
+    /// Notify the timer that the PTT key went up. Spawns a task
+    /// that sleeps for `tail_ms` and then clears the selector's
+    /// `ptt_held` input. A subsequent [`Self::key_down`] within
+    /// the window cancels this task.
+    pub fn key_up(&self) {
+        let tail = self.tail_ms();
+        let selector = self.selector.clone();
+        let new_handle = tokio::spawn(async move {
+            if tail > 0 {
+                tokio::time::sleep(Duration::from_millis(tail as u64)).await;
+            }
+            selector.set_ptt_held(false);
+        });
+        if let Ok(mut g) = self.pending.lock() {
+            if let Some(prev) = g.replace(new_handle) {
+                prev.abort();
+            }
+        }
+    }
+
+    /// Cancel any pending release task and leave the selector's
+    /// `ptt_held` flag at whatever value it currently holds.
+    pub fn cancel(&self) {
+        self.cancel_pending();
+    }
+
+    fn cancel_pending(&self) {
+        if let Ok(mut g) = self.pending.lock() {
+            if let Some(h) = g.take() {
+                h.abort();
+            }
+        }
+    }
+}
+
+impl Drop for ReleaseTailTimer {
+    fn drop(&mut self) {
+        self.cancel_pending();
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::ptt::AudioTransmitGate;
+    use crate::transmit_mode::TransmitMode;
+
+    fn setup(tail_ms: u32) -> (AudioTransmitGate, Arc<TransmitModeSelector>, ReleaseTailTimer) {
+        let gate = AudioTransmitGate::new(false);
+        let sel = Arc::new(TransmitModeSelector::new(gate.clone()));
+        sel.set_mode(TransmitMode::Ptt);
+        sel.set_in_channel(true);
+        let timer = ReleaseTailTimer::new(sel.clone(), tail_ms);
+        (gate, sel, timer)
+    }
+
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn release_clears_after_tail() {
+        let (gate, _sel, timer) = setup(80);
+        timer.key_down();
+        assert!(gate.load());
+        timer.key_up();
+        // Still transmitting during the tail.
+        tokio::time::sleep(Duration::from_millis(20)).await;
+        assert!(gate.load(), "should still be true during tail");
+        // After the tail elapses, gate clears.
+        tokio::time::sleep(Duration::from_millis(120)).await;
+        assert!(!gate.load(), "gate should clear after tail");
+    }
+
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn redown_within_tail_cancels_release() {
+        let (gate, _sel, timer) = setup(200);
+        timer.key_down();
+        timer.key_up();
+        tokio::time::sleep(Duration::from_millis(20)).await;
+        timer.key_down();
+        // Wait past the original tail; gate must still be true.
+        tokio::time::sleep(Duration::from_millis(250)).await;
+        assert!(gate.load(), "subsequent key_down should cancel pending release");
+    }
+
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn zero_tail_clears_immediately() {
+        let (gate, _sel, timer) = setup(0);
+        timer.key_down();
+        assert!(gate.load());
+        timer.key_up();
+        tokio::time::sleep(Duration::from_millis(30)).await;
+        assert!(!gate.load());
+    }
+
+    #[test]
+    fn set_tail_ms_clamps_to_max() {
+        let gate = AudioTransmitGate::new(false);
+        let sel = Arc::new(TransmitModeSelector::new(gate));
+        let timer = ReleaseTailTimer::new(sel, 100);
+        timer.set_tail_ms(99999);
+        assert_eq!(timer.tail_ms(), MAX_TAIL_MS);
+        timer.set_tail_ms(0);
+        assert_eq!(timer.tail_ms(), 0);
+        timer.set_tail_ms(MAX_TAIL_MS);
+        assert_eq!(timer.tail_ms(), MAX_TAIL_MS);
+    }
+}

crates/chanora_audio/src/transmit_mode.rs

@@ -0,0 +1,90 @@
+//! Voice transmit mode (SDD-095).
+//!
+//! Selects how `transmit_active` is driven from the user's input
+//! signals. Persisted per-identity in
+//! [`chanora_storage::IdentityFileStore`] under the `transmit_mode`
+//! metadata key (default [`TransmitMode::Ptt`]).
+//!
+//! `VoiceActivity` is reserved per DEC-030 — for v1 the
+//! [`crate::transmit_selector::TransmitModeSelector`] treats it
+//! exactly like [`TransmitMode::Continuous`] until a real VAD
+//! implementation lands.
+
+/// User-visible voice transmit mode.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[repr(u8)]
+pub enum TransmitMode {
+    /// Push-to-talk: transmit only while the bound key is held
+    /// (with release-tail per SDD-096).
+    Ptt = 0,
+    /// Continuous: transmit whenever the user is in a voice
+    /// channel and not hard-muted.
+    Continuous = 1,
+    /// Voice activity detection. Reserved per DEC-030; v1 behaves
+    /// as [`TransmitMode::Continuous`] until a VAD implementation
+    /// is allocated.
+    VoiceActivity = 2,
+}
+
+impl Default for TransmitMode {
+    fn default() -> Self {
+        Self::Ptt
+    }
+}
+
+impl TransmitMode {
+    /// Encode as the persisted single-byte value.
+    pub fn as_u8(self) -> u8 {
+        self as u8
+    }
+
+    /// Decode from the persisted single-byte value. Returns
+    /// `None` for unknown encodings (the storage layer should
+    /// fall back to [`TransmitMode::default`] in that case).
+    pub fn from_u8(v: u8) -> Option<Self> {
+        match v {
+            0 => Some(Self::Ptt),
+            1 => Some(Self::Continuous),
+            2 => Some(Self::VoiceActivity),
+            _ => None,
+        }
+    }
+
+    /// Stable diagnostic identifier (never localised).
+    pub fn as_str(self) -> &'static str {
+        match self {
+            Self::Ptt => "ptt",
+            Self::Continuous => "continuous",
+            Self::VoiceActivity => "voice-activity",
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn default_is_ptt() {
+        assert_eq!(TransmitMode::default(), TransmitMode::Ptt);
+    }
+
+    #[test]
+    fn round_trip_u8() {
+        for m in [
+            TransmitMode::Ptt,
+            TransmitMode::Continuous,
+            TransmitMode::VoiceActivity,
+        ] {
+            assert_eq!(TransmitMode::from_u8(m.as_u8()), Some(m));
+        }
+        assert_eq!(TransmitMode::from_u8(99), None);
+    }
+
+    #[test]
+    fn as_str_is_stable() {
+        assert_eq!(TransmitMode::Ptt.as_str(), "ptt");
+        assert_eq!(TransmitMode::Continuous.as_str(), "continuous");
+        assert_eq!(TransmitMode::VoiceActivity.as_str(), "voice-activity");
+    }
+}

crates/chanora_audio/src/transmit_selector.rs

@@ -0,0 +1,206 @@
+//! Cross-platform transmit-mode selector (SAD-083).
+//!
+//! Single writer of `transmit_active` other than the missed-key-up
+//! watchdog (SAD-079). Computes the desired gate state from four
+//! lock-free inputs:
+//!
+//! * `mode` — current [`TransmitMode`]
+//! * `in_channel` — true when the session is in a voice channel
+//! * `hard_mute` — final clamp; forces `false` regardless of mode
+//! * `ptt_held` — raw key state (via [`crate::ReleaseTailTimer`]
+//!   on PTT mode)
+//!
+//! Hard-mute is a final clamp; leaving the channel forces the gate
+//! to `false`. `VoiceActivity` is treated identically to
+//! `Continuous` per DEC-030 until a VAD implementation lands.
+//!
+//! All four inputs are stored as atomics so any thread can update
+//! them without taking a lock. After each update we call
+//! [`TransmitModeSelector::recompute`] which writes the resolved
+//! desired value through the [`AudioTransmitGate`].
+
+use std::sync::atomic::{AtomicBool, AtomicU8, Ordering};
+
+use crate::ptt::AudioTransmitGate;
+use crate::transmit_mode::TransmitMode;
+
+/// Selector that maps user/session state to the `transmit_active`
+/// gate (SAD-083).
+pub struct TransmitModeSelector {
+    gate: std::sync::RwLock<AudioTransmitGate>,
+    mode: AtomicU8,
+    in_channel: AtomicBool,
+    hard_mute: AtomicBool,
+    ptt_held: AtomicBool,
+}
+
+impl TransmitModeSelector {
+    /// Construct a selector wired to `gate`. Defaults:
+    /// [`TransmitMode::Ptt`], not in channel, not muted, key
+    /// released. The gate's initial value is left untouched until
+    /// the first mutating call (which then writes the resolved
+    /// value).
+    pub fn new(gate: AudioTransmitGate) -> Self {
+        Self {
+            gate: std::sync::RwLock::new(gate),
+            mode: AtomicU8::new(TransmitMode::default().as_u8()),
+            in_channel: AtomicBool::new(false),
+            hard_mute: AtomicBool::new(false),
+            ptt_held: AtomicBool::new(false),
+        }
+    }
+
+    /// Rewire the selector to a fresh [`AudioTransmitGate`]
+    /// (typically the gate exposed by a newly-started
+    /// [`crate::AudioEngine`]). Cached mode / channel / mute /
+    /// ptt_held are preserved; the new gate is immediately
+    /// updated to the resolved value.
+    pub fn replace_gate(&self, gate: AudioTransmitGate) {
+        if let Ok(mut g) = self.gate.write() {
+            *g = gate;
+        }
+        self.recompute();
+    }
+
+    /// Update the selected mode and re-evaluate the gate.
+    pub fn set_mode(&self, m: TransmitMode) {
+        self.mode.store(m.as_u8(), Ordering::Relaxed);
+        self.recompute();
+    }
+
+    /// Current selected mode.
+    pub fn mode(&self) -> TransmitMode {
+        TransmitMode::from_u8(self.mode.load(Ordering::Relaxed)).unwrap_or_default()
+    }
+
+    /// Update channel membership and re-evaluate.
+    pub fn set_in_channel(&self, v: bool) {
+        self.in_channel.store(v, Ordering::Relaxed);
+        self.recompute();
+    }
+
+    /// Current channel-membership flag.
+    pub fn in_channel(&self) -> bool {
+        self.in_channel.load(Ordering::Relaxed)
+    }
+
+    /// Final-clamp hard mute. When `true` the gate is forced to
+    /// `false` regardless of mode.
+    pub fn set_hard_mute(&self, v: bool) {
+        self.hard_mute.store(v, Ordering::Relaxed);
+        self.recompute();
+    }
+
+    /// Current hard-mute flag.
+    pub fn hard_mute(&self) -> bool {
+        self.hard_mute.load(Ordering::Relaxed)
+    }
+
+    /// PTT key state (set by the platform input backend through
+    /// [`crate::ReleaseTailTimer`]).
+    pub fn set_ptt_held(&self, v: bool) {
+        self.ptt_held.store(v, Ordering::Relaxed);
+        self.recompute();
+    }
+
+    /// Current PTT-held flag.
+    pub fn ptt_held(&self) -> bool {
+        self.ptt_held.load(Ordering::Relaxed)
+    }
+
+    /// Shared snapshot of the underlying gate. Provided for the
+    /// audio engine's hot read path. Returns a clone so callers
+    /// don't hold the internal lock.
+    pub fn gate(&self) -> AudioTransmitGate {
+        self.gate.read().expect("selector gate lock poisoned").clone()
+    }
+
+    fn compute(&self) -> bool {
+        if self.hard_mute.load(Ordering::Relaxed) {
+            return false;
+        }
+        if !self.in_channel.load(Ordering::Relaxed) {
+            return false;
+        }
+        match self.mode() {
+            TransmitMode::Ptt => self.ptt_held.load(Ordering::Relaxed),
+            // DEC-030: VoiceActivity behaves as Continuous in v1.
+            TransmitMode::Continuous | TransmitMode::VoiceActivity => true,
+        }
+    }
+
+    /// Recompute the desired gate state and publish it. Exposed
+    /// for tests; callers normally trigger this implicitly through
+    /// the setter methods.
+    pub fn recompute(&self) {
+        let desired = self.compute();
+        if let Ok(g) = self.gate.read() {
+            g.set(desired);
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn fresh() -> (AudioTransmitGate, TransmitModeSelector) {
+        let g = AudioTransmitGate::new(false);
+        let s = TransmitModeSelector::new(g.clone());
+        (g, s)
+    }
+
+    #[test]
+    fn ptt_requires_channel_and_key() {
+        let (g, s) = fresh();
+        s.set_mode(TransmitMode::Ptt);
+        s.set_ptt_held(true);
+        assert!(!g.load(), "no channel -> false");
+        s.set_in_channel(true);
+        assert!(g.load(), "channel + key -> true");
+        s.set_ptt_held(false);
+        assert!(!g.load(), "key released -> false");
+    }
+
+    #[test]
+    fn continuous_ignores_ptt_held() {
+        let (g, s) = fresh();
+        s.set_mode(TransmitMode::Continuous);
+        s.set_in_channel(true);
+        assert!(g.load(), "channel + continuous -> true");
+        s.set_ptt_held(true);
+        assert!(g.load());
+        s.set_ptt_held(false);
+        assert!(g.load(), "continuous independent of key state");
+    }
+
+    #[test]
+    fn voice_activity_matches_continuous_v1() {
+        let (g, s) = fresh();
+        s.set_mode(TransmitMode::VoiceActivity);
+        s.set_in_channel(true);
+        assert!(g.load());
+    }
+
+    #[test]
+    fn hard_mute_clamps() {
+        let (g, s) = fresh();
+        s.set_mode(TransmitMode::Continuous);
+        s.set_in_channel(true);
+        assert!(g.load());
+        s.set_hard_mute(true);
+        assert!(!g.load(), "hard mute clamps to false");
+        s.set_hard_mute(false);
+        assert!(g.load());
+    }
+
+    #[test]
+    fn leaving_channel_forces_false() {
+        let (g, s) = fresh();
+        s.set_mode(TransmitMode::Continuous);
+        s.set_in_channel(true);
+        assert!(g.load());
+        s.set_in_channel(false);
+        assert!(!g.load());
+    }
+}

crates/chanora_bridge/src/api.rs

@@ -232,24 +232,128 @@ pub async fn is_connected() -> bool {
 
 // ---------- Audio commands (Beta) ----------
 
-/// Start the audio engine on the active connection. Requires a
-/// connection; idempotent (will replace any previous engine).
-pub async fn start_audio() -> Result<(), BridgeError> {
+// `start_audio` was removed per SDD-094 — voice activation now
+// flows through `voice_join` / `voice_leave`, which transparently
+// drive `AudioEngine::ensure_running` / `shutdown_if_idle`.
+
+/// Set the push-to-talk state.
+///
+/// Superseded in v1 by [`set_transmit_mode`] + the binding capture
+/// dialog. Retained so legacy callers and integration tests keep
+/// working; the new VoiceBar UI no longer invokes this.
+pub async fn set_ptt(active: bool) -> Result<(), BridgeError> {
     runtime()
-        .spawn(async {
-            session()
-                .start_audio(chanora_core::AudioEngineConfig::default())
-                .await
-        })
+        .spawn(async move { session().set_ptt(active).await })
         .await
         .map_err(|e| BridgeError::Unmapped(format!("join: {e}")))??;
     Ok(())
 }
 
-/// Set the push-to-talk state.
-pub async fn set_ptt(active: bool) -> Result<(), BridgeError> {
+// ---------- v1 voice lifecycle (SDD-094/095/096) ----------
+
+/// Voice transmit mode mirror (SDD-095). Schema-controlled enum;
+/// the wire encoding matches [`chanora_core::TransmitMode::as_u8`].
+#[derive(Debug, Clone, Copy)]
+pub enum BridgeTransmitMode {
+    /// Push-to-talk (default).
+    Ptt,
+    /// Continuous transmission while in channel and not muted.
+    Continuous,
+    /// Voice-activity detection — reserved per DEC-030; v1 behaves
+    /// as `Continuous`.
+    VoiceActivity,
+}
+
+impl From<BridgeTransmitMode> for chanora_core::TransmitMode {
+    fn from(m: BridgeTransmitMode) -> Self {
+        match m {
+            BridgeTransmitMode::Ptt => Self::Ptt,
+            BridgeTransmitMode::Continuous => Self::Continuous,
+            BridgeTransmitMode::VoiceActivity => Self::VoiceActivity,
+        }
+    }
+}
+
+impl From<chanora_core::TransmitMode> for BridgeTransmitMode {
+    fn from(m: chanora_core::TransmitMode) -> Self {
+        match m {
+            chanora_core::TransmitMode::Ptt => Self::Ptt,
+            chanora_core::TransmitMode::Continuous => Self::Continuous,
+            chanora_core::TransmitMode::VoiceActivity => Self::VoiceActivity,
+        }
+    }
+}
+
+fn transmit_mode_from_u8(v: u8) -> BridgeTransmitMode {
+    chanora_core::TransmitMode::from_u8(v)
+        .unwrap_or_default()
+        .into()
+}
+
+/// Join a voice channel (SDD-094). Moves the user to `channel_id`,
+/// brings up the audio engine if needed, and emits
+/// `BridgeEvent::VoiceState`. `password` may be empty.
+pub async fn voice_join(channel_id: u64, password: String) -> Result<(), BridgeError> {
+    let pw = if password.is_empty() { None } else { Some(password) };
     runtime()
-        .spawn(async move { session().set_ptt(active).await })
+        .spawn(async move { session().voice_join(channel_id, pw).await })
+        .await
+        .map_err(|e| BridgeError::Unmapped(format!("join: {e}")))??;
+    Ok(())
+}
+
+/// Leave the current voice channel (SDD-094). Tears down the audio
+/// engine and emits `BridgeEvent::VoiceState`.
+pub async fn voice_leave() -> Result<(), BridgeError> {
+    runtime()
+        .spawn(async { session().voice_leave().await })
+        .await
+        .map_err(|e| BridgeError::Unmapped(format!("join: {e}")))??;
+    Ok(())
+}
+
+/// Set the active transmit mode (SDD-095).
+pub async fn set_transmit_mode(mode: BridgeTransmitMode) -> Result<(), BridgeError> {
+    runtime()
+        .spawn(async move { session().set_transmit_mode(mode.into()).await })
+        .await
+        .map_err(|e| BridgeError::Unmapped(format!("join: {e}")))??;
+    Ok(())
+}
+
+/// Read the active transmit mode.
+pub async fn get_transmit_mode() -> BridgeTransmitMode {
+    runtime()
+        .spawn(async { session().transmit_mode() })
+        .await
+        .unwrap_or(chanora_core::TransmitMode::Ptt)
+        .into()
+}
+
+/// Update the release-tail in milliseconds (SDD-096). Values are
+/// clamped to `0..=500` on the Rust side; passing anything larger
+/// silently saturates.
+pub async fn set_release_tail_ms(ms: u32) -> Result<(), BridgeError> {
+    runtime()
+        .spawn(async move { session().set_release_tail_ms(ms).await })
+        .await
+        .map_err(|e| BridgeError::Unmapped(format!("join: {e}")))??;
+    Ok(())
+}
+
+/// Read the current release-tail in milliseconds.
+pub async fn get_release_tail_ms() -> u32 {
+    runtime()
+        .spawn(async { session().release_tail_ms() })
+        .await
+        .unwrap_or(200)
+}
+
+/// Engage or release the hard-mute clamp (SDD-094). When `true`
+/// the audio engine transmits nothing regardless of mode.
+pub async fn set_hard_mute(muted: bool) -> Result<(), BridgeError> {
+    runtime()
+        .spawn(async move { session().set_hard_mute(muted).await })
         .await
         .map_err(|e| BridgeError::Unmapped(format!("join: {e}")))??;
     Ok(())
@@ -579,6 +683,19 @@ pub enum BridgeEvent {
         /// `"mouse-side-button"`); empty when no binding is active.
         bound_input_class: String,
     },
+    /// Voice subsystem state snapshot (SDD-094). The Flutter
+    /// VoiceBar listens to this stream.
+    VoiceState {
+        /// True when the session is currently joined to a voice
+        /// channel and the audio engine is running.
+        in_channel: bool,
+        /// Active transmit mode.
+        transmit_mode: BridgeTransmitMode,
+        /// True when the hard-mute clamp is engaged.
+        mute: bool,
+        /// Current release-tail in milliseconds (0..=500).
+        release_tail_ms: u32,
+    },
 }
 
 impl From<chanora_core::SessionEvent> for BridgeEvent {
@@ -612,6 +729,17 @@ impl From<chanora_core::SessionEvent> for BridgeEvent {
                 backend_id,
                 bound_input_class,
             },
+            chanora_core::SessionEvent::VoiceState {
+                in_channel,
+                transmit_mode,
+                mute,
+                release_tail_ms,
+            } => BridgeEvent::VoiceState {
+                in_channel,
+                transmit_mode: transmit_mode_from_u8(transmit_mode),
+                mute,
+                release_tail_ms,
+            },
         }
     }
 }

crates/chanora_bridge/src/frb_generated.rs

@@ -38,7 +38,7 @@ flutter_rust_bridge::frb_generated_boilerplate!(
     default_rust_auto_opaque = RustAutoOpaqueMoi,
 );
 pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_VERSION: &str = "2.12.0";
-pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_CONTENT_HASH: i32 = -427953414;
+pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_CONTENT_HASH: i32 = -330689763;
 
 // Section: executor
 
@@ -326,6 +326,77 @@ fn wire__crate__api__export_diagnostics_impl(
         },
     )
 }
+fn wire__crate__api__get_release_tail_ms_impl(
+    port_: flutter_rust_bridge::for_generated::MessagePort,
+    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
+    rust_vec_len_: i32,
+    data_len_: i32,
+) {
+    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
+        flutter_rust_bridge::for_generated::TaskInfo {
+            debug_name: "get_release_tail_ms",
+            port: Some(port_),
+            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
+        },
+        move || {
+            let message = unsafe {
+                flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
+                    ptr_,
+                    rust_vec_len_,
+                    data_len_,
+                )
+            };
+            let mut deserializer =
+                flutter_rust_bridge::for_generated::SseDeserializer::new(message);
+            deserializer.end();
+            move |context| async move {
+                transform_result_sse::<_, ()>(
+                    (move || async move {
+                        let output_ok =
+                            Result::<_, ()>::Ok(crate::api::get_release_tail_ms().await)?;
+                        Ok(output_ok)
+                    })()
+                    .await,
+                )
+            }
+        },
+    )
+}
+fn wire__crate__api__get_transmit_mode_impl(
+    port_: flutter_rust_bridge::for_generated::MessagePort,
+    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
+    rust_vec_len_: i32,
+    data_len_: i32,
+) {
+    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
+        flutter_rust_bridge::for_generated::TaskInfo {
+            debug_name: "get_transmit_mode",
+            port: Some(port_),
+            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
+        },
+        move || {
+            let message = unsafe {
+                flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
+                    ptr_,
+                    rust_vec_len_,
+                    data_len_,
+                )
+            };
+            let mut deserializer =
+                flutter_rust_bridge::for_generated::SseDeserializer::new(message);
+            deserializer.end();
+            move |context| async move {
+                transform_result_sse::<_, ()>(
+                    (move || async move {
+                        let output_ok = Result::<_, ()>::Ok(crate::api::get_transmit_mode().await)?;
+                        Ok(output_ok)
+                    })()
+                    .await,
+                )
+            }
+        },
+    )
+}
 fn wire__crate__api__init_storage_impl(
     port_: flutter_rust_bridge::for_generated::MessagePort,
     ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
@@ -505,6 +576,42 @@ fn wire__crate__api__ptt_descriptor_impl(
         },
     )
 }
+fn wire__crate__api__set_hard_mute_impl(
+    port_: flutter_rust_bridge::for_generated::MessagePort,
+    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
+    rust_vec_len_: i32,
+    data_len_: i32,
+) {
+    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
+        flutter_rust_bridge::for_generated::TaskInfo {
+            debug_name: "set_hard_mute",
+            port: Some(port_),
+            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
+        },
+        move || {
+            let message = unsafe {
+                flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
+                    ptr_,
+                    rust_vec_len_,
+                    data_len_,
+                )
+            };
+            let mut deserializer =
+                flutter_rust_bridge::for_generated::SseDeserializer::new(message);
+            let api_muted = <bool>::sse_decode(&mut deserializer);
+            deserializer.end();
+            move |context| async move {
+                transform_result_sse::<_, crate::BridgeError>(
+                    (move || async move {
+                        let output_ok = crate::api::set_hard_mute(api_muted).await?;
+                        Ok(output_ok)
+                    })()
+                    .await,
+                )
+            }
+        },
+    )
+}
 fn wire__crate__api__set_input_muted_impl(
     port_: flutter_rust_bridge::for_generated::MessagePort,
     ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
@@ -719,6 +826,78 @@ fn wire__crate__api__set_ptt_binding_impl(
         },
     )
 }
+fn wire__crate__api__set_release_tail_ms_impl(
+    port_: flutter_rust_bridge::for_generated::MessagePort,
+    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
+    rust_vec_len_: i32,
+    data_len_: i32,
+) {
+    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
+        flutter_rust_bridge::for_generated::TaskInfo {
+            debug_name: "set_release_tail_ms",
+            port: Some(port_),
+            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
+        },
+        move || {
+            let message = unsafe {
+                flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
+                    ptr_,
+                    rust_vec_len_,
+                    data_len_,
+                )
+            };
+            let mut deserializer =
+                flutter_rust_bridge::for_generated::SseDeserializer::new(message);
+            let api_ms = <u32>::sse_decode(&mut deserializer);
+            deserializer.end();
+            move |context| async move {
+                transform_result_sse::<_, crate::BridgeError>(
+                    (move || async move {
+                        let output_ok = crate::api::set_release_tail_ms(api_ms).await?;
+                        Ok(output_ok)
+                    })()
+                    .await,
+                )
+            }
+        },
+    )
+}
+fn wire__crate__api__set_transmit_mode_impl(
+    port_: flutter_rust_bridge::for_generated::MessagePort,
+    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
+    rust_vec_len_: i32,
+    data_len_: i32,
+) {
+    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
+        flutter_rust_bridge::for_generated::TaskInfo {
+            debug_name: "set_transmit_mode",
+            port: Some(port_),
+            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
+        },
+        move || {
+            let message = unsafe {
+                flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
+                    ptr_,
+                    rust_vec_len_,
+                    data_len_,
+                )
+            };
+            let mut deserializer =
+                flutter_rust_bridge::for_generated::SseDeserializer::new(message);
+            let api_mode = <crate::api::BridgeTransmitMode>::sse_decode(&mut deserializer);
+            deserializer.end();
+            move |context| async move {
+                transform_result_sse::<_, crate::BridgeError>(
+                    (move || async move {
+                        let output_ok = crate::api::set_transmit_mode(api_mode).await?;
+                        Ok(output_ok)
+                    })()
+                    .await,
+                )
+            }
+        },
+    )
+}
 fn wire__crate__api__snapshot_impl(
     port_: flutter_rust_bridge::for_generated::MessagePort,
     ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
@@ -754,41 +933,6 @@ fn wire__crate__api__snapshot_impl(
         },
     )
 }
-fn wire__crate__api__start_audio_impl(
-    port_: flutter_rust_bridge::for_generated::MessagePort,
-    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
-    rust_vec_len_: i32,
-    data_len_: i32,
-) {
-    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
-        flutter_rust_bridge::for_generated::TaskInfo {
-            debug_name: "start_audio",
-            port: Some(port_),
-            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
-        },
-        move || {
-            let message = unsafe {
-                flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
-                    ptr_,
-                    rust_vec_len_,
-                    data_len_,
-                )
-            };
-            let mut deserializer =
-                flutter_rust_bridge::for_generated::SseDeserializer::new(message);
-            deserializer.end();
-            move |context| async move {
-                transform_result_sse::<_, crate::BridgeError>(
-                    (move || async move {
-                        let output_ok = crate::api::start_audio().await?;
-                        Ok(output_ok)
-                    })()
-                    .await,
-                )
-            }
-        },
-    )
-}
 fn wire__crate__api__update_bookmark_impl(
     port_: flutter_rust_bridge::for_generated::MessagePort,
     ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
@@ -825,6 +969,79 @@ fn wire__crate__api__update_bookmark_impl(
         },
     )
 }
+fn wire__crate__api__voice_join_impl(
+    port_: flutter_rust_bridge::for_generated::MessagePort,
+    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
+    rust_vec_len_: i32,
+    data_len_: i32,
+) {
+    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
+        flutter_rust_bridge::for_generated::TaskInfo {
+            debug_name: "voice_join",
+            port: Some(port_),
+            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
+        },
+        move || {
+            let message = unsafe {
+                flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
+                    ptr_,
+                    rust_vec_len_,
+                    data_len_,
+                )
+            };
+            let mut deserializer =
+                flutter_rust_bridge::for_generated::SseDeserializer::new(message);
+            let api_channel_id = <u64>::sse_decode(&mut deserializer);
+            let api_password = <String>::sse_decode(&mut deserializer);
+            deserializer.end();
+            move |context| async move {
+                transform_result_sse::<_, crate::BridgeError>(
+                    (move || async move {
+                        let output_ok =
+                            crate::api::voice_join(api_channel_id, api_password).await?;
+                        Ok(output_ok)
+                    })()
+                    .await,
+                )
+            }
+        },
+    )
+}
+fn wire__crate__api__voice_leave_impl(
+    port_: flutter_rust_bridge::for_generated::MessagePort,
+    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
+    rust_vec_len_: i32,
+    data_len_: i32,
+) {
+    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
+        flutter_rust_bridge::for_generated::TaskInfo {
+            debug_name: "voice_leave",
+            port: Some(port_),
+            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
+        },
+        move || {
+            let message = unsafe {
+                flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
+                    ptr_,
+                    rust_vec_len_,
+                    data_len_,
+                )
+            };
+            let mut deserializer =
+                flutter_rust_bridge::for_generated::SseDeserializer::new(message);
+            deserializer.end();
+            move |context| async move {
+                transform_result_sse::<_, crate::BridgeError>(
+                    (move || async move {
+                        let output_ok = crate::api::voice_leave().await?;
+                        Ok(output_ok)
+                    })()
+                    .await,
+                )
+            }
+        },
+    )
+}
 
 // Section: dart2rust
 
@@ -1012,6 +1229,19 @@ impl SseDecode for crate::api::BridgeEvent {
                     bound_input_class: var_boundInputClass,
                 };
             }
+            8 => {
+                let mut var_inChannel = <bool>::sse_decode(deserializer);
+                let mut var_transmitMode =
+                    <crate::api::BridgeTransmitMode>::sse_decode(deserializer);
+                let mut var_mute = <bool>::sse_decode(deserializer);
+                let mut var_releaseTailMs = <u32>::sse_decode(deserializer);
+                return crate::api::BridgeEvent::VoiceState {
+                    in_channel: var_inChannel,
+                    transmit_mode: var_transmitMode,
+                    mute: var_mute,
+                    release_tail_ms: var_releaseTailMs,
+                };
+            }
             _ => {
                 unimplemented!("");
             }
@@ -1065,6 +1295,19 @@ impl SseDecode for crate::api::BridgeSnapshot {
     }
 }
 
+impl SseDecode for crate::api::BridgeTransmitMode {
+    // Codec=Sse (Serialization based), see doc to use other codecs
+    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
+        let mut inner = <i32>::sse_decode(deserializer);
+        return match inner {
+            0 => crate::api::BridgeTransmitMode::Ptt,
+            1 => crate::api::BridgeTransmitMode::Continuous,
+            2 => crate::api::BridgeTransmitMode::VoiceActivity,
+            _ => unreachable!("Invalid variant for BridgeTransmitMode: {}", inner),
+        };
+    }
+}
+
 impl SseDecode for f32 {
     // Codec=Sse (Serialization based), see doc to use other codecs
     fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
@@ -1186,19 +1429,25 @@ fn pde_ffi_dispatcher_primary_impl(
         5 => wire__crate__api__delete_bookmark_impl(port, ptr, rust_vec_len, data_len),
         6 => wire__crate__api__disconnect_impl(port, ptr, rust_vec_len, data_len),
         7 => wire__crate__api__events_stream_impl(port, ptr, rust_vec_len, data_len),
-        9 => wire__crate__api__init_storage_impl(port, ptr, rust_vec_len, data_len),
-        10 => wire__crate__api__is_connected_impl(port, ptr, rust_vec_len, data_len),
-        11 => wire__crate__api__list_bookmarks_impl(port, ptr, rust_vec_len, data_len),
-        12 => wire__crate__api__move_to_channel_impl(port, ptr, rust_vec_len, data_len),
-        13 => wire__crate__api__ptt_descriptor_impl(port, ptr, rust_vec_len, data_len),
-        14 => wire__crate__api__set_input_muted_impl(port, ptr, rust_vec_len, data_len),
-        16 => wire__crate__api__set_output_gain_impl(port, ptr, rust_vec_len, data_len),
-        17 => wire__crate__api__set_output_muted_impl(port, ptr, rust_vec_len, data_len),
-        18 => wire__crate__api__set_ptt_impl(port, ptr, rust_vec_len, data_len),
-        19 => wire__crate__api__set_ptt_binding_impl(port, ptr, rust_vec_len, data_len),
-        20 => wire__crate__api__snapshot_impl(port, ptr, rust_vec_len, data_len),
-        21 => wire__crate__api__start_audio_impl(port, ptr, rust_vec_len, data_len),
-        22 => wire__crate__api__update_bookmark_impl(port, ptr, rust_vec_len, data_len),
+        9 => wire__crate__api__get_release_tail_ms_impl(port, ptr, rust_vec_len, data_len),
+        10 => wire__crate__api__get_transmit_mode_impl(port, ptr, rust_vec_len, data_len),
+        11 => wire__crate__api__init_storage_impl(port, ptr, rust_vec_len, data_len),
+        12 => wire__crate__api__is_connected_impl(port, ptr, rust_vec_len, data_len),
+        13 => wire__crate__api__list_bookmarks_impl(port, ptr, rust_vec_len, data_len),
+        14 => wire__crate__api__move_to_channel_impl(port, ptr, rust_vec_len, data_len),
+        15 => wire__crate__api__ptt_descriptor_impl(port, ptr, rust_vec_len, data_len),
+        16 => wire__crate__api__set_hard_mute_impl(port, ptr, rust_vec_len, data_len),
+        17 => wire__crate__api__set_input_muted_impl(port, ptr, rust_vec_len, data_len),
+        19 => wire__crate__api__set_output_gain_impl(port, ptr, rust_vec_len, data_len),
+        20 => wire__crate__api__set_output_muted_impl(port, ptr, rust_vec_len, data_len),
+        21 => wire__crate__api__set_ptt_impl(port, ptr, rust_vec_len, data_len),
+        22 => wire__crate__api__set_ptt_binding_impl(port, ptr, rust_vec_len, data_len),
+        23 => wire__crate__api__set_release_tail_ms_impl(port, ptr, rust_vec_len, data_len),
+        24 => wire__crate__api__set_transmit_mode_impl(port, ptr, rust_vec_len, data_len),
+        25 => wire__crate__api__snapshot_impl(port, ptr, rust_vec_len, data_len),
+        26 => wire__crate__api__update_bookmark_impl(port, ptr, rust_vec_len, data_len),
+        27 => wire__crate__api__voice_join_impl(port, ptr, rust_vec_len, data_len),
+        28 => wire__crate__api__voice_leave_impl(port, ptr, rust_vec_len, data_len),
         _ => unreachable!(),
     }
 }
@@ -1212,7 +1461,7 @@ fn pde_ffi_dispatcher_sync_impl(
     // Codec=Pde (Serialization + dispatch), see doc to use other codecs
     match func_id {
         8 => wire__crate__api__export_diagnostics_impl(ptr, rust_vec_len, data_len),
-        15 => wire__crate__api__set_network_state_impl(ptr, rust_vec_len, data_len),
+        18 => wire__crate__api__set_network_state_impl(ptr, rust_vec_len, data_len),
         _ => unreachable!(),
     }
 }
@@ -1366,6 +1615,19 @@ impl flutter_rust_bridge::IntoDart for crate::api::BridgeEvent {
                 bound_input_class.into_into_dart().into_dart(),
             ]
             .into_dart(),
+            crate::api::BridgeEvent::VoiceState {
+                in_channel,
+                transmit_mode,
+                mute,
+                release_tail_ms,
+            } => [
+                8.into_dart(),
+                in_channel.into_into_dart().into_dart(),
+                transmit_mode.into_into_dart().into_dart(),
+                mute.into_into_dart().into_dart(),
+                release_tail_ms.into_into_dart().into_dart(),
+            ]
+            .into_dart(),
             _ => {
                 unimplemented!("");
             }
@@ -1442,6 +1704,28 @@ impl flutter_rust_bridge::IntoIntoDart<crate::api::BridgeSnapshot> for crate::ap
         self
     }
 }
+// Codec=Dco (DartCObject based), see doc to use other codecs
+impl flutter_rust_bridge::IntoDart for crate::api::BridgeTransmitMode {
+    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
+        match self {
+            Self::Ptt => 0.into_dart(),
+            Self::Continuous => 1.into_dart(),
+            Self::VoiceActivity => 2.into_dart(),
+            _ => unreachable!(),
+        }
+    }
+}
+impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
+    for crate::api::BridgeTransmitMode
+{
+}
+impl flutter_rust_bridge::IntoIntoDart<crate::api::BridgeTransmitMode>
+    for crate::api::BridgeTransmitMode
+{
+    fn into_into_dart(self) -> crate::api::BridgeTransmitMode {
+        self
+    }
+}
 
 impl SseEncode for flutter_rust_bridge::for_generated::anyhow::Error {
     // Codec=Sse (Serialization based), see doc to use other codecs
@@ -1591,6 +1875,18 @@ impl SseEncode for crate::api::BridgeEvent {
                 <String>::sse_encode(backend_id, serializer);
                 <String>::sse_encode(bound_input_class, serializer);
             }
+            crate::api::BridgeEvent::VoiceState {
+                in_channel,
+                transmit_mode,
+                mute,
+                release_tail_ms,
+            } => {
+                <i32>::sse_encode(8, serializer);
+                <bool>::sse_encode(in_channel, serializer);
+                <crate::api::BridgeTransmitMode>::sse_encode(transmit_mode, serializer);
+                <bool>::sse_encode(mute, serializer);
+                <u32>::sse_encode(release_tail_ms, serializer);
+            }
             _ => {
                 unimplemented!("");
             }
@@ -1644,6 +1940,23 @@ impl SseEncode for crate::api::BridgeSnapshot {
     }
 }
 
+impl SseEncode for crate::api::BridgeTransmitMode {
+    // Codec=Sse (Serialization based), see doc to use other codecs
+    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
+        <i32>::sse_encode(
+            match self {
+                crate::api::BridgeTransmitMode::Ptt => 0,
+                crate::api::BridgeTransmitMode::Continuous => 1,
+                crate::api::BridgeTransmitMode::VoiceActivity => 2,
+                _ => {
+                    unimplemented!("");
+                }
+            },
+            serializer,
+        );
+    }
+}
+
 impl SseEncode for f32 {
     // Codec=Sse (Serialization based), see doc to use other codecs
     fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {

crates/chanora_storage/Cargo.toml

@@ -19,6 +19,8 @@ zeroize = "1"
 # `base64` is needed to serialise the DEK as a string for the
 # keyring API (which is text-only on most platforms).
 base64 = "0.22"
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
 
 # Platform keyring abstraction: Secret Service / kernel keyutils on
 # Linux (DEC-013.2); macOS Keychain; Windows Credential Manager;

crates/chanora_storage/src/lib.rs

@@ -49,6 +49,7 @@ use chacha20poly1305::aead::{Aead, KeyInit, OsRng};
 use chacha20poly1305::{ChaCha20Poly1305, Key, Nonce};
 use rand::RngCore;
 use rusqlite::{params, Connection};
+use serde::{Deserialize, Serialize};
 use thiserror::Error;
 use tracing::{info, warn};
 use zeroize::Zeroize;
@@ -88,6 +89,34 @@ pub trait LocalDatabaseRepository: Send + Sync {}
 /// promoted from the secure-storage PoC.
 pub trait SecretStorageRepository: Send + Sync {}
 
+/// Audio-related per-identity settings persisted alongside the
+/// identity file as a small JSON blob (SDD-095 / SDD-096). These
+/// are *not* secrets; they sit beside the encrypted identity in
+/// app-private storage.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+struct AudioMeta {
+    /// Encoded [`chanora_audio::TransmitMode`]. Default is
+    /// `TransmitMode::Ptt as u8 == 0`.
+    #[serde(default)]
+    transmit_mode: u8,
+    /// Release-tail in milliseconds (SDD-096). Default 200.
+    #[serde(default = "default_release_tail_ms")]
+    release_tail_ms: u32,
+}
+
+fn default_release_tail_ms() -> u32 {
+    200
+}
+
+impl Default for AudioMeta {
+    fn default() -> Self {
+        Self {
+            transmit_mode: 0,
+            release_tail_ms: 200,
+        }
+    }
+}
+
 /// Beta identity store: a single ChaCha20-Poly1305-encrypted file
 /// containing the base64 TS3 identity string. The Data Encryption
 /// Key (DEK) is 32 random bytes stored in the platform keyring
@@ -410,6 +439,72 @@ impl IdentityFileStore {
         Ok(())
     }
 
+    /// Path to the small JSON metadata file that sits alongside
+    /// the identity. Holds audio settings (`transmit_mode`,
+    /// `release_tail_ms`) per SDD-095/096. Stored in plaintext —
+    /// these values are not secrets.
+    fn meta_path(&self) -> PathBuf {
+        let dir = self
+            .path
+            .parent()
+            .map(Path::to_path_buf)
+            .unwrap_or_else(|| PathBuf::from("."));
+        dir.join("audio_meta.json")
+    }
+
+    fn read_meta(&self) -> AudioMeta {
+        match fs::read_to_string(self.meta_path()) {
+            Ok(s) => serde_json::from_str(&s).unwrap_or_default(),
+            Err(_) => AudioMeta::default(),
+        }
+    }
+
+    fn write_meta(&self, m: &AudioMeta) -> Result<(), StorageError> {
+        let path = self.meta_path();
+        let tmp = path.with_extension("json.tmp");
+        let body = serde_json::to_vec_pretty(m)
+            .map_err(|e| StorageError::Io(format!("meta serialize: {e}")))?;
+        {
+            let mut f = fs::File::create(&tmp)
+                .map_err(|e| StorageError::Io(format!("open meta {tmp:?}: {e}")))?;
+            f.write_all(&body)
+                .map_err(|e| StorageError::Io(format!("write meta: {e}")))?;
+            f.sync_all()
+                .map_err(|e| StorageError::Io(format!("sync meta: {e}")))?;
+        }
+        fs::rename(&tmp, &path)
+            .map_err(|e| StorageError::Io(format!("rename meta {tmp:?} -> {path:?}: {e}")))?;
+        Ok(())
+    }
+
+    /// Persist the user's chosen transmit mode (SDD-095). The
+    /// encoding matches `chanora_audio::TransmitMode::as_u8()`.
+    pub fn set_transmit_mode(&self, mode: u8) -> Result<(), StorageError> {
+        let mut m = self.read_meta();
+        m.transmit_mode = mode;
+        self.write_meta(&m)
+    }
+
+    /// Read the persisted transmit mode. Defaults to `0`
+    /// (`TransmitMode::Ptt`) when no value has been written.
+    pub fn get_transmit_mode(&self) -> u8 {
+        self.read_meta().transmit_mode
+    }
+
+    /// Persist the user's chosen release-tail (SDD-096). Clamped
+    /// to `0..=500` ms inclusive on write.
+    pub fn set_release_tail_ms(&self, ms: u32) -> Result<(), StorageError> {
+        let mut m = self.read_meta();
+        m.release_tail_ms = ms.min(500);
+        self.write_meta(&m)
+    }
+
+    /// Read the persisted release-tail in milliseconds. Defaults
+    /// to `200` (SDD-096 default) when no value has been written.
+    pub fn get_release_tail_ms(&self) -> u32 {
+        self.read_meta().release_tail_ms
+    }
+
     /// Remove any persisted identity. No-op if none exists. Leaves
     /// the DEK in place so future saves don't generate a new one.
     pub fn clear(&self) -> Result<(), StorageError> {
@@ -1034,6 +1129,37 @@ mod tests {
         assert!(row.1.is_some(), "blob should be set after upgrade");
     }
 
+    #[test]
+    fn audio_meta_defaults_and_persists() {
+        force_keyring_off();
+        let tmp = tempdir();
+        let store = IdentityFileStore::new(&tmp).unwrap();
+        // Defaults before any write.
+        assert_eq!(store.get_transmit_mode(), 0);
+        assert_eq!(store.get_release_tail_ms(), 200);
+        // Persist values.
+        store.set_transmit_mode(1).unwrap();
+        store.set_release_tail_ms(75).unwrap();
+        assert_eq!(store.get_transmit_mode(), 1);
+        assert_eq!(store.get_release_tail_ms(), 75);
+        // Reopen the store — values survive.
+        drop(store);
+        let store2 = IdentityFileStore::new(&tmp).unwrap();
+        assert_eq!(store2.get_transmit_mode(), 1);
+        assert_eq!(store2.get_release_tail_ms(), 75);
+    }
+
+    #[test]
+    fn release_tail_ms_clamped_on_write() {
+        force_keyring_off();
+        let tmp = tempdir();
+        let store = IdentityFileStore::new(&tmp).unwrap();
+        store.set_release_tail_ms(9999).unwrap();
+        assert_eq!(store.get_release_tail_ms(), 500);
+        store.set_release_tail_ms(0).unwrap();
+        assert_eq!(store.get_release_tail_ms(), 0);
+    }
+
     fn tempdir() -> PathBuf {
         let p = std::env::temp_dir()
             .join("chanora_storage_test")