존재 신호는 자기 통로로

  /// The presence goes up as the watch's own application context, never
  /// through the capture lane: latest wins, nothing queues while the phone is
  /// away, and nothing rings it awake. The phone reads it when a turn comes
  /// (`WristCommand.Action.watching` has the story). A word lost before the
  /// session activates is said again on the next beat, and a phone that heard
  /// none stops believing the last one after `watchingTrust`.
  private func announcePresence(_ live: Bool) {
    guard WCSession.isSupported(), WCSession.default.activationState == .activated,
      let sealed = try? WristEnvelope.seal(WristCommand(action: .watching(live)))
    else { return }
    try? WCSession.default.updateApplicationContext(sealed)
  }

  /// Whether the watch's session counts as live, from its last word.
  public static func watchLive(lastWatching: Date?, live: Bool, now: Date = Date()) -> Bool {
    guard live, let lastWatching else { return false }
    return now.timeIntervalSince(lastWatching) <= WristCommand.watchingTrust
  }

  /// The same, from the presence the watch published as its application
  /// context. That lane keeps only the latest, so its last word is its only
  /// word; anything but a presence counts as no word at all.
  public static func watchLive(presence: WristCommand?, now: Date = Date()) -> Bool {
    guard let presence, case .watching(let live) = presence.action else { return false }
    return watchLive(lastWatching: presence.issuedAt, live: live, now: now)
  }

import Foundation

// A minimal sketch: the same 30 s heartbeat on two lanes while the phone is
// away for six minutes, then what the phone believes when a turn asks.
// Times are seconds, passed in, so the run is deterministic.
struct Presence {
  let live: Bool
  let issuedAt: TimeInterval
}

let watchingEvery: TimeInterval = 30
let watchingTrust: TimeInterval = 75

// The capture lane: a durable queue that lets go only when a transfer lands.
var queue: [Presence] = []
// The application context: one slot, the latest replaces the last.
var context: Presence?

let away: TimeInterval = 360
for beat in stride(from: 0.0, to: away, by: watchingEvery) {
  let word = Presence(live: true, issuedAt: beat)
  queue.append(word)  // nothing lands while the phone is away
  context = word  // the slot just holds the newest
}
print("after \(Int(away / 60)) min away: queue holds \(queue.count), context holds \(context == nil ? 0 : 1)")
print("on reconnect the queue re-offers \(queue.count) transfers and \(queue.count) rings")

// The phone's question at a turn: is the watch's session live?
func watchLive(_ presence: Presence?, now: TimeInterval) -> Bool {
  guard let presence, presence.live else { return false }
  return now - presence.issuedAt <= watchingTrust
}
let last = context!.issuedAt
for gap in [20.0, 70.0, 120.0] {
  print("turn \(Int(gap)) s after the last beat: live = \(watchLive(context, now: last + gap))")
}
print("session ended (live: false), 1 s later: live = \(watchLive(Presence(live: false, issuedAt: last), now: last + 1))")

// Output:
// after 6 min away: queue holds 12, context holds 1
// on reconnect the queue re-offers 12 transfers and 12 rings
// turn 20 s after the last beat: live = true
// turn 70 s after the last beat: live = true
// turn 120 s after the last beat: live = false
// session ended (live: false), 1 s later: live = false