한 번 누르면 한 턴: 다시 열릴 수 없는 손목 마이크

import Foundation

/// One voice turn on the wrist. Nothing opens the microphone but `audioUp` with the token a
/// `begin` handed out, and every way a turn ends is .off or .stopped, never .listening.
struct VoiceTurn: Equatable {
    enum Phase: Equatable { case off, listening, thinking, speaking, stopped(String) }

    private(set) var phase: Phase = .off
    private(set) var pending: String?          // the utterance this turn waits on
    private var generation = 0                 // every end voids every start still on its way
    private var launch: Int?

    var micOpen: Bool { phase == .listening }
    private var idle: Bool {
        if case .stopped = phase { return true }
        return phase == .off
    }

    /// A press. nil while a turn is already up or starting: on a cold launch the control,
    /// a launch request and a URL can all ask at once.
    mutating func begin() -> Int? {
        guard launch == nil, idle else { return nil }
        generation += 1
        launch = generation
        return generation
    }

    /// The audio session is up. False if the turn was stopped meanwhile: then nothing opens.
    mutating func audioUp(_ token: Int) -> Bool {
        guard launch == token, token == generation else { return false }
        launch = nil
        phase = .listening
        return true
    }

    /// The utterance left for the phone: the microphone is closed for the rest of this turn.
    mutating func sent(_ id: String) {
        guard phase == .listening else { return }
        pending = id
        phase = .thinking
    }

    mutating func replyPlaying(_ id: String) {
        guard phase == .thinking, id == pending else { return }
        phase = .speaking                      // pending keeps the id: only this reply can end the turn
    }

    /// This turn's reply played out, the phone finished reading it, or a fallback timer ran out.
    /// An older reply's end, arriving late, is not this turn's end.
    mutating func replyOver(_ id: String) {
        guard id == pending, phase == .thinking || phase == .speaking else { return }
        end()
    }

    /// Stop, Close, or leaving the app.
    mutating func stop() { end() }

    mutating func halt(_ reason: String) {
        end()
        phase = .stopped(reason)
    }

    private mutating func end() {
        generation += 1
        launch = nil
        pending = nil
        phase = .off                           // never .listening: the next turn is another press
    }
}

import Foundation

/// Fed one meter reading (in dB) every 100 ms while the turn records.
struct EndOfSpeech {
    var quiet: TimeInterval = 3          // silence after speech that ends the utterance
    var calibrate = 5                    // the first half second measures the room
    var margin = 10.0                    // speech is this far above the room...
    var minimum = -45.0                  // ...and never quieter than this

    private(set) var speechSeconds: TimeInterval = 0
    private var readings: [Double] = []
    private var floor: Double?
    private var lastSpeech: TimeInterval?
    private var lastReading: TimeInterval?

    /// true when the utterance is over. Under 0.4 s of speech, the caller sends nothing.
    mutating func feed(_ db: Double, at t: TimeInterval) -> Bool {
        let step = lastReading.map { max(0, t - $0) } ?? 0
        lastReading = t
        guard let room = floor else {
            readings.append(db)
            if readings.count >= calibrate { floor = readings.sorted()[readings.count / 2] }
            return false
        }
        if db > max(room + margin, minimum) {
            speechSeconds += step
            lastSpeech = t
            return false
        }
        floor = room * 0.95 + db * 0.05     // quiet readings keep the floor honest as the room drifts
        if let last = lastSpeech, t - last >= quiet - 0.001 { return true }   // 100 ms steps sum to 2.999...
        return false
    }
}