test(rig): two-endpoint call on one Mac — honest cross-process end-to-end measurement

Single-process loopback confounded every metric and repeatedly produced broken-ruler
results: sent and recv were the SAME node's counters (delivery ratios >100% from
timing offsets, waves #26/#33/#37), jitter==0 meant "no stream" not "clean link"
(#24), and a cross-thread crash-race hid until it fired (#33). There was no way to
verify the UI or a real MITM either. Fix: run TWO independent TriNetMonitor instances
that dial each other over real UDP.

Three dev-only env hooks (no-ops in a shipping run):
  TRINET_LOG=<path>          per-instance log (LogBus) so each process's counters read apart
  TRINET_LISTEN=<port>       this instance's UDP listen port
  TRINET_AUTOCALL=host:port  auto-dial a 1-1 call on launch (INVITE bypassed)
CallManager.startCall now honors a distinct listen port so two locals don't collide.
smoke/two_endpoint_rig.sh orchestrates A(:8000) <-> B(:8100) and reports the CROSS-process
delivery A->B = (B received)/(A sent) — the honest number a single process cannot give.

Verified live: two real windowed processes establish a bidirectional call (macOS shares
the camera, so both send AND receive). Clean link: A->B 98.7%, B->A 93.4%. With 25%
induced packet loss on B: A->B still 96.7% -- i.e. the layered loss-recovery stack
(grouped FEC + whole-NAL NACK + per-fragment NACK from #31-33) recovers 25% loss to ~97%
frame delivery, now proven over two genuine processes instead of a self-loopback.

Mac-only (the rig runs two Mac instances); the env hooks are inert dev tooling.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: 2 people

phone/desktop/TriNetVideo/CallManager.swift

@@ -200,6 +200,26 @@ class CallManager: ObservableObject {
         selectedCameraID = AVCaptureDevice.default(for: .video)?.uniqueID ?? cameras.first?.uniqueID ?? ""
         discovery.start()   // advertise + browse from launch
         startIdleListener() // listen on :7000 for incoming calls while idle
+        autoCallIfConfigured()   // two-endpoint test rig hook (no-op in a real run)
+    }
+
+    // TEST RIG ONLY: TRINET_AUTOCALL=<host>:<peerPort> + TRINET_LISTEN=<myPort> auto-dials a
+    // 1-1 call on launch with distinct local ports, so two instances on one machine can talk
+    // over real UDP (INVITE bypassed). Never set in a shipping run.
+    private var autoListenPort: UInt16?
+    private func autoCallIfConfigured() {
+        let env = ProcessInfo.processInfo.environment
+        guard let peer = env["TRINET_AUTOCALL"], !peer.isEmpty else { return }
+        let parts = peer.split(separator: ":")
+        guard parts.count == 2, let peerPort = UInt16(parts[1]) else { NSLog("TRINET: bad TRINET_AUTOCALL"); return }
+        remoteIP = String(parts[0])
+        port = String(peerPort)
+        autoListenPort = env["TRINET_LISTEN"].flatMap { UInt16($0) }
+        NSLog("TRINET: RIG autocall -> \(remoteIP):\(peerPort) listen \(autoListenPort.map(String.init) ?? "same")")
+        DispatchQueue.main.asyncAfter(deadline: .now() + 2.0) { [weak self] in
+            guard let self = self, !self.isInCall else { return }
+            self.startCall()
+        }
     }
 
     // MARK: - Incoming call ("take the call")
@@ -979,7 +999,8 @@ class CallManager: ObservableObject {
             NSLog("TRINET: group call — \(hosts.count) peers")
         } else {
             isGroup = false
-            transport.connect(peerHost: remoteIP, peerPort: p, listenPort: p)
+            let listenP = autoListenPort ?? p   // rig: two local instances need distinct listen ports
+            transport.connect(peerHost: remoteIP, peerPort: p, listenPort: listenP)
         }
         let hostStrs = hosts.map { String($0) }
         sendInvite(to: hostStrs, participants: [localIP] + hostStrs)   // ring the callee(s); carry the full roster

phone/desktop/TriNetVideo/LinkStatus.swift

@@ -29,6 +29,11 @@ final class LogBus: ObservableObject {
     // Persistent log FILE, so the detailed log survives quitting (the in-memory `lines` does not).
     // Standard macOS location -> visible in Console.app and Finder.
     let logURL: URL = {
+        // TRINET_LOG lets a second instance write its own log — needed by the two-endpoint
+        // test rig so each process's counters can be read independently (never set in a real run).
+        if let p = ProcessInfo.processInfo.environment["TRINET_LOG"], !p.isEmpty {
+            return URL(fileURLWithPath: (p as NSString).expandingTildeInPath)
+        }
         let dir = FileManager.default.homeDirectoryForCurrentUser
             .appendingPathComponent("Library/Logs/TriNetMonitor", isDirectory: true)
         try? FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)

smoke/two_endpoint_rig.sh

@@ -0,0 +1,45 @@
+#!/usr/bin/env bash
+# two_endpoint_rig.sh — a REAL two-process video call on one Mac, for HONEST end-to-end
+# measurement. Single-process loopback confounds every metric (sent and recv are the same
+# node's counters; jitter==0 can mean "no stream", not "clean link" — the broken-ruler traps
+# that bit waves #24, #26, #33, #37). Here two independent TriNetMonitor instances dial each
+# other over real UDP (INVITE bypassed via TRINET_AUTOCALL), each writes its own log, and we
+# read the CROSS-process delivery: A->B = (B received) / (A sent).
+#
+# Enabled by three env hooks (all no-ops in a shipping run):
+#   TRINET_LOG=<path>          per-instance log file (LogBus)
+#   TRINET_LISTEN=<port>       this instance's UDP listen port
+#   TRINET_AUTOCALL=host:port  auto-dial a 1-1 call to the peer on launch
+#
+# Usage:  smoke/two_endpoint_rig.sh [seconds] [dropPercentOnB]
+set -u
+SECS="${1:-30}"
+DROP="${2:-0}"
+APP=/Applications/TriNetMonitor.app
+A=/tmp/rigA.log; B=/tmp/rigB.log
+pkill -9 -f "TriNetMonitor.app/Contents/MacOS" 2>/dev/null; sleep 2
+defaults delete com.trinet.monitor trinetRoom 2>/dev/null   # open lobby: both instances share the empty room
+rm -f "$A" "$B"
+
+echo "launching A (:8000) <-> B (:8100)${DROP:+, ${DROP}% induced loss on B}"
+open -n --env TRINET_LOG="$A" --env TRINET_LISTEN=8000 --env TRINET_AUTOCALL=127.0.0.1:8100 "$APP"
+sleep 1
+open -n --env TRINET_LOG="$B" --env TRINET_LISTEN=8100 --env TRINET_AUTOCALL=127.0.0.1:8000 ${DROP:+--env TRINET_DROP=$DROP} "$APP"
+
+END=$(( $(date +%s) + SECS )); while [ "$(date +%s)" -lt "$END" ]; do sleep 5; done
+
+# Last STATS line from each: "video sent=<framesSent> recv=<framesReceived>"
+read AS AR < <(grep -aoE "video sent=[0-9]+ recv=[0-9]+" "$A" 2>/dev/null | tail -1 | grep -oE "[0-9]+" | tr '\n' ' ')
+read BS BR < <(grep -aoE "video sent=[0-9]+ recv=[0-9]+" "$B" 2>/dev/null | tail -1 | grep -oE "[0-9]+" | tr '\n' ' ')
+pkill -9 -f "TriNetMonitor.app/Contents/MacOS" 2>/dev/null
+
+echo
+if [ -z "${AS:-}" ] || [ -z "${BR:-}" ]; then
+  echo "RIG FAILED — no STATS in one log (call did not establish). Tail of A/B:"
+  tail -3 "$A" 2>/dev/null; echo "---"; tail -3 "$B" 2>/dev/null
+  exit 1
+fi
+echo "A sent $AS video, recv $AR   |   B sent $BS video, recv $BR"
+python3 -c "print(f'A->B video delivery = {100*$BR/max(1,$AS):.1f}%  (B received / A sent)')"
+python3 -c "print(f'B->A video delivery = {100*$AR/max(1,$BS):.1f}%  (A received / B sent)')"
+echo "(cross-process ratios — the honest end-to-end numbers a single loopback process cannot give)"