botium-connector-voip 0.0.29 → 0.0.31

package/dist/botium-connector-voip-cjs.js

@@ -26,6 +26,12 @@ const debug$3 = debug__default["default"]('botium-connector-voip');
 // debug = high-frequency diagnostics (DEBUG=botium-connector-voip). warn = degraded but continuing.
 // error = abort/failure. No secrets in info; STT text only as length or truncated in info.
 
+/** WS frame types logged only at start/end handlers — not per-chunk (hundreds per call). */
+const WS_DEBUG_SILENT_TYPES = new Set(['audioStreamChunk', 'fullRecordChunk']);
+const AGENT_SPEECH_RMS_WINDOW_MS = 100;
+const DEFAULT_AGENT_SPEECH_RMS_THRESHOLD = 500;
+const DEFAULT_AGENT_SPEECH_SUSTAINED_WINDOWS = 2;
+const WS_DEBUG_BASE64_FIELD_NAMES = new Set(['chunk', 'buffer', 'base64', 'fullRecord', 'full_record', 'audio', 'audioData', 'b64_buffer']);
 const _info = (event, data) => {
   const parts = Object.entries({
     event,
@@ -39,17 +45,40 @@ const sanitizeDtmfDigits = raw => {
   if (raw == null) return '';
   return String(raw).replace(/[^0-9*#ABCDabcd]/g, '').toUpperCase();
 };
+
+// Matches voipcall.generate_dtmf_sequence defaults (100 ms tone, 50 ms pause between digits).
+const DTMF_TONE_MS = 100;
+const DTMF_PAUSE_MS = 50;
+const DTMF_MS_PER_DIGIT = 200;
+const DEFAULT_AUDIO_STREAM_INTERVAL_MS = 250;
+const audioStreamIntervalMs = () => {
+  const n = Number(process.env.VOIP_AUDIO_STREAM_INTERVAL_MS || process.env.AUDIO_STREAM_INTERVAL_MS);
+  return Number.isFinite(n) && n > 0 ? n : DEFAULT_AUDIO_STREAM_INTERVAL_MS;
+};
+const dtmfPlaybackMs = digitCount => {
+  if (!digitCount || digitCount <= 0) return 0;
+  return digitCount * DTMF_TONE_MS + Math.max(0, digitCount - 1) * DTMF_PAUSE_MS;
+};
+
+/** Wait before turn-audio slice so DTMF PCM is flushed through audioStream (250 ms default). */
+const dtmfTurnAudioWaitMs = digitCount => {
+  const playbackMs = dtmfPlaybackMs(digitCount);
+  const streamMs = audioStreamIntervalMs();
+  return Math.max(digitCount * DTMF_MS_PER_DIGIT, playbackMs + streamMs + 50);
+};
 const Capabilities = {
   VOIP_STT_URL_STREAM: 'VOIP_STT_URL_STREAM',
   VOIP_STT_PARAMS_STREAM: 'VOIP_STT_PARAMS_STREAM',
   VOIP_STT_METHOD_STREAM: 'VOIP_STT_METHOD_STREAM',
   VOIP_STT_BODY_STREAM: 'VOIP_STT_BODY_STREAM',
   VOIP_STT_BODY: 'VOIP_STT_BODY',
+  VOIP_STT_AZURE_SEGMENTATION_SILENCE_TIMEOUT_MS: 'VOIP_STT_AZURE_SEGMENTATION_SILENCE_TIMEOUT_MS',
   VOIP_STT_HEADERS: 'VOIP_STT_HEADERS',
   VOIP_STT_TIMEOUT: 'VOIP_STT_TIMEOUT',
   VOIP_STT_MESSAGE_HANDLING: 'VOIP_STT_MESSAGE_HANDLING',
   VOIP_STT_MESSAGE_HANDLING_TIMEOUT: 'VOIP_STT_MESSAGE_HANDLING_TIMEOUT',
   VOIP_STT_MESSAGE_HANDLING_TIMEOUT_SUBSEQUENT: 'VOIP_STT_MESSAGE_HANDLING_TIMEOUT_SUBSEQUENT',
+  VOIP_STT_MESSAGE_HANDLING_LATENCY_GRACE_MS: 'VOIP_STT_MESSAGE_HANDLING_LATENCY_GRACE_MS',
   VOIP_JOIN_SILENCE_DURATION_BY_SUBSTRING: 'VOIP_JOIN_SILENCE_DURATION_BY_SUBSTRING',
   VOIP_STT_DICTIONARY_REPLACEMENTS: 'VOIP_STT_DICTIONARY_REPLACEMENTS',
   VOIP_STT_MESSAGE_HANDLING_DELIMITER: 'VOIP_STT_MESSAGE_HANDLING_DELIMITER',
@@ -84,6 +113,8 @@ const Capabilities = {
   VOIP_ICE_TURN_PROTOCOL: 'VOIP_ICE_TURN_PROTOCOL',
   VOIP_WEBSOCKET_CONNECT_MAXRETRIES: 'VOIP_WEBSOCKET_CONNECT_MAXRETRIES',
   VOIP_WEBSOCKET_CONNECT_TIMEOUT: 'VOIP_WEBSOCKET_CONNECT_TIMEOUT',
+  VOIP_CALL_SETUP_RETRY_487_MAXRETRIES: 'VOIP_CALL_SETUP_RETRY_487_MAXRETRIES',
+  VOIP_CALL_SETUP_RETRY_487_TIMEOUT: 'VOIP_CALL_SETUP_RETRY_487_TIMEOUT',
   VOIP_SILENCE_DURATION_TIMEOUT_ENABLE: 'VOIP_SILENCE_DURATION_TIMEOUT_ENABLE',
   VOIP_SILENCE_DURATION_TIMEOUT: 'VOIP_SILENCE_DURATION_TIMEOUT',
   VOIP_SILENCE_DURATION_TIMEOUT_START_ENABLE: 'VOIP_SILENCE_DURATION_TIMEOUT_START_ENABLE',
@@ -92,7 +123,10 @@ const Capabilities = {
   VOIP_USE_GLOBAL_VOIP_WORKER: 'VOIP_USE_GLOBAL_VOIP_WORKER',
   VOIP_USER_INPUT_PREFER_VOICE: 'VOIP_USER_INPUT_PREFER_VOICE',
   VOIP_EMIT_SPECULATIVE_TEXT: 'VOIP_EMIT_SPECULATIVE_TEXT',
-  VOIP_SDP_MEDIA_TYPE_TEXT_ENABLE: 'VOIP_SDP_MEDIA_TYPE_TEXT_ENABLE'
+  VOIP_SDP_MEDIA_TYPE_TEXT_ENABLE: 'VOIP_SDP_MEDIA_TYPE_TEXT_ENABLE',
+  VOIP_TURN_AUDIO_ENABLE: 'VOIP_TURN_AUDIO_ENABLE',
+  VOIP_TURN_AUDIO_PADDING_MS: 'VOIP_TURN_AUDIO_PADDING_MS',
+  VOIP_TURN_AUDIO_OFFSET_MS: 'VOIP_TURN_AUDIO_OFFSET_MS'
 };
 const Defaults = {
   VOIP_STT_METHOD: 'POST',
@@ -104,19 +138,62 @@ const Defaults = {
   VOIP_TTS_PREFETCH_ENABLE: true,
   VOIP_STT_MESSAGE_HANDLING: 'ORIGINAL',
   VOIP_STT_MESSAGE_HANDLING_TIMEOUT: 2500,
+  // Extra wall-clock grace added to the JOIN/PSST flush window when the last buffered final was
+  // cut mid-utterance (no Azure-detected end-of-speech silence). Absorbs STT delivery latency so a
+  // paused-then-resumed prompt is joined instead of split. Set to 0 to disable. See _getPsstLatencyGraceMs.
+  VOIP_STT_MESSAGE_HANDLING_LATENCY_GRACE_MS: 1500,
   VOIP_STT_MESSAGE_HANDLING_DELIMITER: '. ',
   VOIP_STT_MESSAGE_HANDLING_PUNCTUATION: '.!?',
   VOIP_WEBSOCKET_CONNECT_TIMEOUT: 4000,
   VOIP_WEBSOCKET_CONNECT_MAXRETRIES: 5,
+  // Retry the whole call setup when the SIP peer terminates the INVITE with a
+  // transient '487 Request Terminated' before the call connects.
+  VOIP_CALL_SETUP_RETRY_487_MAXRETRIES: 2,
+  VOIP_CALL_SETUP_RETRY_487_TIMEOUT: 2000,
   VOIP_SILENCE_DURATION_TIMEOUT: 2500,
   VOIP_SILENCE_DURATION_TIMEOUT_ENABLE: false,
   VOIP_SILENCE_DURATION_TIMEOUT_START: 1000,
   VOIP_SILENCE_DURATION_TIMEOUT_START_ENABLE: false,
   VOIP_STT_CONFIDENCE_THRESHOLD: 0.5,
+  VOIP_STT_AZURE_SEGMENTATION_SILENCE_TIMEOUT_MS: 500,
   VOIP_USE_GLOBAL_VOIP_WORKER: false,
   VOIP_SIP_PROTOCOL: 'TCP',
   VOIP_USER_INPUT_PREFER_VOICE: true,
-  VOIP_SDP_MEDIA_TYPE_TEXT_ENABLE: false
+  VOIP_SDP_MEDIA_TYPE_TEXT_ENABLE: false,
+  VOIP_TURN_AUDIO_ENABLE: true,
+  VOIP_TURN_AUDIO_PADDING_MS: 150,
+  VOIP_TURN_AUDIO_OFFSET_MS: 0
+};
+
+// Inject the Azure end-of-speech segmentation timeout into the STT body. botium-speech-processing
+// applies azure.config.properties via SpeechConfig.setProperty(), so this controls how long Azure
+// waits after the last word before emitting final=true. Only applied for the Azure engine, never
+// overrides a value already present in the profile config, and clones so the capability object stays
+// untouched. Set the capability to 0/empty to disable injection.
+const injectAzureSegmentationTimeout = (body, sttParams, timeoutMs) => {
+  const ms = Number(timeoutMs);
+  if (!lodash__default["default"].isFinite(ms) || ms <= 0) return body;
+  const isAzure = sttParams && sttParams.stt === 'azure' || body && typeof body === 'object' && body.azure || typeof body === 'string' && body.indexOf('azure') !== -1;
+  if (!isAzure) return body;
+  let next;
+  if (body == null) {
+    next = {};
+  } else if (typeof body === 'string') {
+    try {
+      next = JSON.parse(body);
+    } catch (err) {
+      return body;
+    }
+  } else {
+    next = lodash__default["default"].cloneDeep(body);
+  }
+  if (!lodash__default["default"].isObject(next.azure)) next.azure = {};
+  if (!lodash__default["default"].isObject(next.azure.config)) next.azure.config = {};
+  if (!lodash__default["default"].isObject(next.azure.config.properties)) next.azure.config.properties = {};
+  if (next.azure.config.properties.Speech_SegmentationSilenceTimeoutMs == null) {
+    next.azure.config.properties.Speech_SegmentationSilenceTimeoutMs = String(Math.round(ms));
+  }
+  return next;
 };
 const TTS_HTTP_AGENT = new http__default["default"].Agent({
   keepAlive: true
@@ -145,6 +222,8 @@ class BotiumConnectorVoip {
     // For debugging latency between incoming STT (bot says) and outgoing audio (sendAudio)
     this._lastBotSaysQueuedAt = null;
     this._lastBotSaysText = null;
+    this._replyTrace = null;
+    this._activeUserSaysVoipAgent = null;
     this._speculativeTurnToken = 0;
   }
   async Validate() {
@@ -193,6 +272,27 @@ class BotiumConnectorVoip {
     this.convoStep = null;
     this._lastBotSaysQueuedAt = null;
     this._lastBotSaysText = null;
+    this._replyTrace = null;
+    this._activeUserSaysVoipAgent = null;
+    this.audioStream = {
+      format: null,
+      pcmParts: [],
+      totalBytes: 0,
+      complete: false
+    };
+    this._turnAudioCounter = 0;
+    this._meTurnAudioOrdinal = -1; // 0-based ordinal of REAL user turns this session
+    this._lastBotTurnStartSec = null;
+    // Per-turn audio is NOT sliced inline (that would force UserSays to wait for the
+    // recording to catch up with playback). Instead each turn records a lightweight
+    // descriptor here; slices are cut and emitted as MESSAGE_ATTACHMENT progressively,
+    // as soon as the recording buffer has reached each turn's playback end (so the live
+    // UI can show them mid-run), with a forced flush at session end for any remainder.
+    // Zero added latency for TTS and DTMF turns.
+    this._pendingTurnAudio = [];
+    this._turnAudioPrevEndSec = null;
+    this._turnAudioForceDone = false;
+    this._trailingBotAudioEmitted = false;
     if (this.ttsCache) {
       this.ttsCache.clear();
     }
@@ -200,6 +300,7 @@ class BotiumConnectorVoip {
       const queuedAt = Date.now();
       this._lastBotSaysQueuedAt = queuedAt;
       this._lastBotSaysText = botMsg && botMsg.messageText ? String(botMsg.messageText) : null;
+      this._captureBotQueuedForReplyTrace(queuedAt);
       // Stamp the wall-clock instant at which the connector released the bot
       // utterance to botium-core's queue. Paired with `_receivedAtMs` (last
       // STT final frame) this gives the true "join silence" the connector
@@ -207,8 +308,33 @@ class BotiumConnectorVoip {
       // message up with WaitBotSays().
       if (botMsg && botMsg.sourceData) {
         const head = Array.isArray(botMsg.sourceData) ? botMsg.sourceData[0] : botMsg.sourceData;
-        if (head && typeof head === 'object' && !('flushedAtMs' in head)) {
-          head.flushedAtMs = queuedAt;
+        if (head && typeof head === 'object') {
+          if (!('flushedAtMs' in head)) head.flushedAtMs = queuedAt;
+          if (this._replyTrace) {
+            if (lodash__default["default"].isFinite(this._replyTrace.psstFireDelayMs)) head.psstFireDelayMs = this._replyTrace.psstFireDelayMs;
+            if (lodash__default["default"].isFinite(this._replyTrace.psstScheduledMs)) head.psstScheduledMs = this._replyTrace.psstScheduledMs;
+          }
+        }
+      }
+      // A turn = bot speaks first, then me responds.
+      // Save the bot's audio start so UserSays can slice the full exchange
+      // (bot + me) once me has finished speaking.
+      if (this.caps[Capabilities.VOIP_TURN_AUDIO_ENABLE] && botMsg && !(botMsg instanceof Error)) {
+        try {
+          const sd = botMsg.sourceData;
+          let startSec = null;
+          if (Array.isArray(sd) && sd.length > 0) {
+            startSec = lodash__default["default"].get(sd, '[0].data.start', null);
+          } else if (sd && typeof sd === 'object') {
+            startSec = lodash__default["default"].get(sd, 'data.start', null);
+          }
+          // Only record the FIRST bot message's start; if several bot messages
+          // arrive before the next UserSays they all belong to the same turn.
+          if (lodash__default["default"].isFinite(startSec) && this._lastBotTurnStartSec === null) {
+            this._lastBotTurnStartSec = startSec;
+          }
+        } catch (err) {
+          debug$3(`${this.sessionId} - sendBotMsg: saving turn start error: ${err && err.message}`);
         }
       }
       setTimeout(() => this.queueBotSays(botMsg), 0);
@@ -229,6 +355,10 @@ class BotiumConnectorVoip {
         botMsg.sourceData[0].silenceDuration = lodash__default["default"].isFinite(firstStart) ? firstStart : null;
         botMsg.sourceData[0].voiceDuration = lodash__default["default"].isFinite(firstStart) && lodash__default["default"].isFinite(lastEnd) ? lastEnd - firstStart : null;
       }
+      const lastSpeechEnd = lodash__default["default"].get(botMsgs, `[${botMsgs.length - 1}].sourceData.data.speechEndSec`, null);
+      if (lodash__default["default"].isFinite(lastSpeechEnd) && botMsg.sourceData[0] && botMsg.sourceData[0].data) {
+        botMsg.sourceData[0].data.speechEndSec = lastSpeechEnd;
+      }
       return botMsg;
     };
 
@@ -258,25 +388,41 @@ class BotiumConnectorVoip {
       const isJoinMethod = sttHandling === 'JOIN' || sttHandling === 'PSST' || sttHandling === 'CONCAT' || this._hasJoinLogicHookOrRule(this.convoStep);
       if (!isJoinMethod) return;
       const joinTimeoutMs = this._getEffectiveJoinTimeoutMs(this.convoStep, this.botMsgs);
+      // Variant-3 latency grace: when the last buffered final was cut mid-utterance (no
+      // Azure-detected end-of-speech silence) a continuation is plausible but its STT delivery
+      // lags behind the audio by ~1s. Extend the wall-clock flush window by the grace so the
+      // resumed segment's partial/final (or a worker speechResumed event) can re-arm this timer
+      // and be joined, instead of flushing the first fragment on its own. A natural-ended final
+      // keeps the base window and flushes fast.
+      const graceMs = this._getPsstLatencyGraceMs();
+      const graceApplied = graceMs > 0 && lodash__default["default"].isFinite(joinTimeoutMs) && joinTimeoutMs > 0 && !this._isLastFinalNaturalEnd();
+      const effectiveWindowMs = graceApplied ? joinTimeoutMs + graceMs : joinTimeoutMs || 0;
       if (this.silenceTimeout) {
         clearTimeout(this.silenceTimeout);
         this.silenceTimeout = null;
       }
       const bufferedAtArm = this.botMsgs.length;
       const armedAt = Date.now();
+      this._markReplyTrace({
+        psstTimerArmedAtMs: armedAt,
+        psstScheduledMs: effectiveWindowMs || 0
+      });
       _info('psst_timer_armed', {
         sessionId: this.sessionId,
-        joinTimeoutMs: joinTimeoutMs || 0,
+        joinTimeoutMs: effectiveWindowMs || 0,
+        baseTimeoutMs: joinTimeoutMs || 0,
+        graceMs: graceApplied ? graceMs : 0,
+        graceApplied,
         bufferedChunks: bufferedAtArm,
         stopCalled: !!this.stopCalled
       });
-      // Emit the authoritative join timeout so downstream consumers (e.g.
+      // Emit the authoritative flush window so downstream consumers (e.g.
       // SpeculationBuffer) can size their quiet threshold relative to it.
-      if (this.eventEmitter && lodash__default["default"].isFinite(joinTimeoutMs) && joinTimeoutMs > 0) {
+      if (this.eventEmitter && lodash__default["default"].isFinite(effectiveWindowMs) && effectiveWindowMs > 0) {
         try {
           this.eventEmitter.emit('voip.psstTimerArmed', {
             sessionId: this.sessionId,
-            joinTimeoutMs,
+            joinTimeoutMs: effectiveWindowMs,
             bufferedChunks: bufferedAtArm,
             armedAt
           });
@@ -287,15 +433,20 @@ class BotiumConnectorVoip {
       }
       this.silenceTimeout = setTimeout(() => {
         const fireDelay = Date.now() - armedAt;
+        this._markReplyTrace({
+          psstTimerFiredAtMs: Date.now(),
+          psstFireDelayMs: fireDelay
+        });
         if (this.botMsgs.length > 0) {
           _info('psst_timer_fired', {
             sessionId: this.sessionId,
             bufferedChunks: this.botMsgs.length,
             actualDelayMs: fireDelay,
-            scheduledDelayMs: joinTimeoutMs || 0,
+            scheduledDelayMs: effectiveWindowMs || 0,
+            graceApplied,
             outcome: 'emit'
           });
-          debug$3('Silence Duration Timeout (JOIN/PSST):', joinTimeoutMs, 'ms');
+          debug$3('Silence Duration Timeout (JOIN/PSST):', effectiveWindowMs, 'ms');
           sendBotMsg(joinBotMsg(this.botMsgs, this.joinLastPrevMsg));
           this.firstMsg = false;
           this.joinLastPrevMsg = this.botMsgs[this.botMsgs.length - 1];
@@ -308,11 +459,11 @@ class BotiumConnectorVoip {
             sessionId: this.sessionId,
             bufferedChunks: 0,
             actualDelayMs: fireDelay,
-            scheduledDelayMs: joinTimeoutMs || 0,
+            scheduledDelayMs: effectiveWindowMs || 0,
             outcome: 'noop_empty_buffer'
           });
         }
-      }, joinTimeoutMs || 0);
+      }, effectiveWindowMs || 0);
     };
 
     // Flush buffered STT chunks on teardown so a late final is not lost when
@@ -438,15 +589,17 @@ class BotiumConnectorVoip {
         await connectHttp(retryIndex + 1);
       }
     };
-    await connectHttp();
-    if (httpInitRetries > 0) {
-      _info('connected_after_retries', {
-        phase: 'initCall',
-        retries: httpInitRetries
-      });
-    }
     return new Promise((resolve, reject) => {
-      const wsEndpoint = `${this.caps[Capabilities.VOIP_USE_GLOBAL_VOIP_WORKER] ? process.env.BOTIUM_VOIP_WORKER_URL : this.caps[Capabilities.VOIP_WORKER_URL]}/ws/${data.port}`;
+      // Worker session details (port) come from connectHttp() and are recomputed
+      // on every (re)try, since each setup attempt gets a fresh worker session.
+      let wsEndpoint = null;
+      const computeWsEndpoint = () => `${this.caps[Capabilities.VOIP_USE_GLOBAL_VOIP_WORKER] ? process.env.BOTIUM_VOIP_WORKER_URL : this.caps[Capabilities.VOIP_WORKER_URL]}/ws/${data.port}`;
+      // 487-retry bookkeeping: a transient '487 Request Terminated' that arrives
+      // before the call connects re-runs the whole setup (fresh initCall -> ws
+      // -> SIP INVITE) up to max487Retries times.
+      let setup487Retries = 0;
+      let convoStepListenerAttached = false;
+      const max487Retries = this.caps[Capabilities.VOIP_CALL_SETUP_RETRY_487_MAXRETRIES];
       const connectWs = retryIndex => {
         retryIndex = retryIndex || 0;
         return new Promise((resolve, reject) => {
@@ -480,7 +633,7 @@ class BotiumConnectorVoip {
           });
         });
       };
-      connectWs().then(wsRetries => {
+      const onWsConnected = wsRetries => {
         if (wsRetries > 0) {
           _info('connected_after_retries', {
             phase: 'websocket',
@@ -494,26 +647,32 @@ class BotiumConnectorVoip {
             this.caps[Capabilities.VOIP_ICE_STUN_SERVERS] = this.caps[Capabilities.VOIP_ICE_STUN_SERVERS].split(',');
           }
         }
-        this.eventEmitter.on('CONVO_STEP_NEXT', (container, convoStep) => {
-          this.convoStep = convoStep;
-          this._maybePrefetchTts(convoStep);
-          // For PSST: send join silence duration per step to VOIP worker (controls PSST silence trigger)
-          try {
-            if (this.caps[Capabilities.VOIP_STT_MESSAGE_HANDLING] === 'PSST' && this.ws && this.ws.readyState === ws__default["default"].OPEN) {
-              const silenceMs = this._getEffectiveJoinTimeoutMs(convoStep, this.botMsgs);
-              if (lodash__default["default"].isFinite(silenceMs) && silenceMs > 0 && this.sessionId) {
-                debug$3(`PSST: sending silenceDurationMs=${silenceMs} for sessionId=${this.sessionId}`);
-                this.ws.send(JSON.stringify({
-                  METHOD: 'setSttSilenceDuration',
-                  sessionId: this.sessionId,
-                  silenceDurationMs: silenceMs
-                }));
+
+        // Attach this once: the listener reads this.ws dynamically, so it keeps
+        // working across 487 setup retries that swap out the websocket.
+        if (!convoStepListenerAttached) {
+          convoStepListenerAttached = true;
+          this.eventEmitter.on('CONVO_STEP_NEXT', (container, convoStep) => {
+            this.convoStep = convoStep;
+            this._maybePrefetchTts(convoStep);
+            // For PSST: send join silence duration per step to VOIP worker (controls PSST silence trigger)
+            try {
+              if (this.caps[Capabilities.VOIP_STT_MESSAGE_HANDLING] === 'PSST' && this.ws && this.ws.readyState === ws__default["default"].OPEN) {
+                const silenceMs = this._getEffectiveJoinTimeoutMs(convoStep, this.botMsgs);
+                if (lodash__default["default"].isFinite(silenceMs) && silenceMs > 0 && this.sessionId) {
+                  debug$3(`PSST: sending silenceDurationMs=${silenceMs} for sessionId=${this.sessionId}`);
+                  this.ws.send(JSON.stringify({
+                    METHOD: 'setSttSilenceDuration',
+                    sessionId: this.sessionId,
+                    silenceDurationMs: silenceMs
+                  }));
+                }
               }
+            } catch (err) {
+              debug$3(`Failed sending PSST silence duration to VOIP worker: ${err.message || err}`);
             }
-          } catch (err) {
-            debug$3(`Failed sending PSST silence duration to VOIP worker: ${err.message || err}`);
-          }
-        });
+          });
+        }
         this.silence = null;
         this.msgCount = 0;
         this.sttPartialCount = 0;
@@ -561,11 +720,12 @@ class BotiumConnectorVoip {
           ICE_TURN_PROTOCOL: this.caps[Capabilities.VOIP_ICE_TURN_PROTOCOL] || 'TCP',
           MIN_SILENCE_DURATION: this.caps[Capabilities.VOIP_SILENCE_DURATION_TIMEOUT_ENABLE] ? this.caps[Capabilities.VOIP_SILENCE_DURATION_TIMEOUT] : null,
           SDP_MEDIA_TYPE_TEXT_ENABLE: !!this.caps[Capabilities.VOIP_SDP_MEDIA_TYPE_TEXT_ENABLE],
+          AUDIO_STREAM: !!this.caps[Capabilities.VOIP_TURN_AUDIO_ENABLE],
           STT_LEGACY: sttLegacy,
           STT_CONFIG: {
             stt_url: sttUrl,
             stt_params: this.caps[Capabilities.VOIP_STT_PARAMS_STREAM],
-            stt_body: this.caps[Capabilities.VOIP_STT_BODY_STREAM] || null
+            stt_body: injectAzureSegmentationTimeout(this.caps[Capabilities.VOIP_STT_BODY_STREAM] || null, this.caps[Capabilities.VOIP_STT_PARAMS_STREAM], this.caps[Capabilities.VOIP_STT_AZURE_SEGMENTATION_SILENCE_TIMEOUT_MS])
           },
           TTS_CONFIG: {
             tts_url: this.caps[Capabilities.VOIP_TTS_URL],
@@ -630,7 +790,7 @@ class BotiumConnectorVoip {
           // (fullRecord*) and hard errors so `full_record.wav` is delivered
           // on early-completion hangups. Post-Stop STT frames remain blocked.
           if (this.stopCalled) {
-            const allowedPostStopTypes = ['fullRecord', 'fullRecordStart', 'fullRecordChunk', 'fullRecordEnd', 'error'];
+            const allowedPostStopTypes = ['fullRecord', 'fullRecordStart', 'fullRecordChunk', 'fullRecordEnd', 'error', 'audioStreamStart', 'audioStreamChunk', 'audioStreamEnd'];
             if (!parsedData || !allowedPostStopTypes.includes(parsedData.type)) {
               debug$3(`${this.sessionId} - Stop already called, ignoring incoming message`);
               return;
@@ -642,7 +802,7 @@ class BotiumConnectorVoip {
             if (!obj || typeof obj !== 'object') return;
             for (const key of Object.keys(obj)) {
               const val = obj[key];
-              if (typeof val === 'string' && val.length > 500) {
+              if (typeof val === 'string' && val.length > 0 && (WS_DEBUG_BASE64_FIELD_NAMES.has(key) || val.length > 500)) {
                 obj[key] = `<base64:${val.length}chars>`;
               } else if (val && typeof val === 'object' && !Array.isArray(val)) {
                 sanitizeBase64Fields(val, `${prefix}${key}.`);
@@ -650,7 +810,9 @@ class BotiumConnectorVoip {
             }
           };
           sanitizeBase64Fields(parsedDataLog);
-          debug$3(JSON.stringify(parsedDataLog, null, 2));
+          if (!WS_DEBUG_SILENT_TYPES.has(parsedData?.type)) {
+            debug$3(JSON.stringify(parsedDataLog, null, 2));
+          }
           const _extractFullRecordBase64 = pd => {
             if (!pd) return null;
             // Different VOIP workers may put the payload in various fields - search all string fields
@@ -754,6 +916,9 @@ class BotiumConnectorVoip {
             reject(new Error('Error: Sip Registration failed'));
           }
           if (parsedData && parsedData.type === 'callinfo' && parsedData.status === 'connected') {
+            // Mark connected so a later terminal error is delivered to the bot
+            // conversation instead of triggering a (now pointless) setup retry.
+            this.connected = true;
             _info('callinfo_connected', {
               sessionId: this.sessionId
             });
@@ -788,6 +953,23 @@ class BotiumConnectorVoip {
             });
           }
           if (parsedData && parsedData.type === 'error') {
+            const errMsg = parsedData.message || '';
+            // The worker reports the SIP code inside the message string
+            // ("Disconnected because of error - Reason: 487 Request Terminated")
+            // and does not set a dedicated `code` field, so detect 487 from both.
+            const is487 = parsedData.code === 487 || parsedData.code === '487' || /\b487\b/.test(errMsg) || /request terminated/i.test(errMsg);
+            // A transient '487 Request Terminated' that arrives before the call
+            // connects: retry the whole call setup instead of failing the test.
+            if (is487 && !this.connected && setup487Retries < max487Retries) {
+              _info('ws_error_msg', {
+                sessionId: this.sessionId,
+                message: parsedData.message || null,
+                code: parsedData.code || null,
+                retrying487: true
+              });
+              retryCallSetup487(errMsg);
+              return;
+            }
             flushPendingBotMsgs('error');
             // Ensure buffered recording is not lost on terminal worker errors.
             this._emitBufferedFullRecordIfAny('error_buffered');
@@ -801,6 +983,46 @@ class BotiumConnectorVoip {
             sendBotMsg(new Error(`Error: ${parsedData.message}`));
           }
 
+          // Per-turn audio stream: continuous PCM chunks received during the call.
+          // The connector buffers them so _sliceTurnAudio() can extract per-turn segments.
+          if (parsedData && parsedData.type === 'audioStreamStart') {
+            this.audioStream = {
+              format: {
+                sampleRate: parsedData.sampleRate,
+                channels: parsedData.channels,
+                bitsPerSample: parsedData.bitsPerSample,
+                dataOffset: parsedData.dataOffset
+              },
+              pcmParts: [],
+              totalBytes: 0,
+              complete: false
+            };
+            debug$3(`${this.sessionId} - audioStreamStart sampleRate=${parsedData.sampleRate} channels=${parsedData.channels} bitsPerSample=${parsedData.bitsPerSample}`);
+          }
+          if (parsedData && parsedData.type === 'audioStreamChunk') {
+            if (this.audioStream && parsedData.chunk) {
+              try {
+                const buf = Buffer.from(parsedData.chunk, 'base64');
+                this.audioStream.pcmParts.push(buf);
+                this.audioStream.totalBytes += buf.length;
+                this._maybeDetectAgentAudibleOnRecording(this._activeUserSaysVoipAgent);
+                // Emit any per-turn audio whose playback the recording has now caught up to,
+                // so the live transcript can show it mid-run (no UserSays latency).
+                this._emitReadyTurnAudio('audioStreamChunk', false);
+              } catch (e) {
+                debug$3(`${this.sessionId} - audioStreamChunk decode error: ${e && e.message}`);
+              }
+            }
+          }
+          if (parsedData && parsedData.type === 'audioStreamEnd') {
+            if (this.audioStream) {
+              this.audioStream.complete = true;
+            }
+            debug$3(`${this.sessionId} - audioStreamEnd totalBytes=${parsedData.totalBytes}`);
+            // Buffer is complete — cut and emit the per-turn audio now.
+            this._flushPendingTurnAudio('audioStreamEnd');
+          }
+
           // Full record streaming support:
           // - some VOIP workers send the recording in chunks and an end marker
           if (parsedData && parsedData.type === 'fullRecordStart') {
@@ -820,11 +1042,49 @@ class BotiumConnectorVoip {
               source: 'fullRecordEnd',
               base64Len
             });
+            // Emit per-turn audio before `this.end = true` so it is captured by the
+            // worker before Stop() resolves (no-op if audioStreamEnd already flushed).
+            this._flushPendingTurnAudio('fullRecordEnd');
             // Flush before `this.end = true` so the buffered final STT is not
             // dropped when Stop() clears the PSST silence timer on teardown.
             flushPendingBotMsgs('fullRecordEnd');
             this.end = true;
           }
+          if (parsedData && parsedData.type === 'agentPlaybackStarted') {
+            const playbackData = parsedData.data || {};
+            const playedSec = playbackData.playedRecordingStartSec;
+            const active = this._activeUserSaysVoipAgent;
+            if (active && lodash__default["default"].isFinite(playedSec)) {
+              active.playedRecordingStartSec = playedSec;
+              active.playbackAtMs = playbackData.playbackAtMs;
+              if (lodash__default["default"].isFinite(playbackData.requestedDurationMs)) {
+                active.playbackRequestedDurationMs = playbackData.requestedDurationMs;
+              }
+              if (lodash__default["default"].isFinite(playbackData.digitCount)) {
+                active.digitCount = playbackData.digitCount;
+              }
+              this._markReplyTrace({
+                playedRecordingStartSec: playedSec,
+                playbackAtMs: playbackData.playbackAtMs
+              });
+              const heardSec = playbackData.wireKind === 'dtmf' ? playedSec : this._applyAgentHeardRecordingStartSec(active);
+              if (lodash__default["default"].isFinite(heardSec)) {
+                if (playbackData.wireKind === 'dtmf') {
+                  active.heardRecordingStartSec = heardSec;
+                  this._markReplyTrace({
+                    heardRecordingStartSec: heardSec
+                  });
+                }
+                debug$3(`${this.sessionId} - agent audible on recording at ${heardSec}s (played=${playedSec}s)`);
+              }
+              // Log the heard reply-trace now that playback is audible — earlier than the
+              // old turn-audio callback and free of the next-turn _replyTrace race. The
+              // agent's end on the recording = played + playback length.
+              const playbackSec = lodash__default["default"].isFinite(active.playbackRequestedDurationMs) && active.playbackRequestedDurationMs > 0 ? active.playbackRequestedDurationMs / 1000 : playbackData.wireKind === 'dtmf' ? this._dtmfPlaybackSec(active, active.digitCount || 1) : null;
+              const agentEndSec = lodash__default["default"].isFinite(playbackSec) ? playedSec + playbackSec : undefined;
+              this._logReplyTraceHeard(agentEndSec);
+            }
+          }
           if (parsedData && parsedData.type === 'silence') {
             if (lodash__default["default"].isNil(this._getIgnoreSilenceDurationAsserterLogicHook(this.convoStep))) {
               if (!this._hasJoinLogicHookOrRule(this.convoStep) && parsedData.data.silence.length > 0) {
@@ -834,6 +1094,36 @@ class BotiumConnectorVoip {
               }
             }
           }
+          if (parsedData && parsedData.type === 'speech' && parsedData.event === 'onSpeechResumed') {
+            // Positive VAD signal from the worker: the bot started speaking again after a pause.
+            // It arrives ~1s before the resumed segment's first STT partial, so when we are
+            // buffering finals (PSST/JOIN) we re-arm the flush timer now — keeping the buffered
+            // fragment open to be joined instead of flushed on its own. Bounded by the same
+            // extension budget as partial-driven re-arms to prevent infinite stranding.
+            _info('speech_resumed', {
+              sessionId: this.sessionId
+            });
+            const sttHandling = this.caps[Capabilities.VOIP_STT_MESSAGE_HANDLING];
+            const isJoinMethod = sttHandling === 'JOIN' || sttHandling === 'PSST' || sttHandling === 'CONCAT' || this._hasJoinLogicHookOrRule(this.convoStep);
+            if (isJoinMethod && this.botMsgs && this.botMsgs.length > 0) {
+              const MAX_EXTENSION_MS = 60000;
+              const now = Date.now();
+              const withinCap = this.psstFirstRearmAt == null || now - this.psstFirstRearmAt < MAX_EXTENSION_MS;
+              if (withinCap) {
+                if (this.psstFirstRearmAt == null) this.psstFirstRearmAt = now;
+                this.psstRearmCount++;
+                _info('psst_timer_extended', {
+                  sessionId: this.sessionId,
+                  rearmCount: this.psstRearmCount,
+                  msSinceFirstRearm: now - this.psstFirstRearmAt,
+                  bufferedChunks: this.botMsgs.length,
+                  reason: 'speech_resumed',
+                  silenceDurationMs: lodash__default["default"].get(parsedData, 'data.silenceDurationMs', null)
+                });
+                armJoinSilenceTimer();
+              }
+            }
+          }
           if (parsedData && parsedData.type === 'fullRecord') {
             // Non-chunked full record
             const base64 = _extractFullRecordBase64(parsedData);
@@ -953,8 +1243,13 @@ class BotiumConnectorVoip {
               messageLength: msgLen,
               confidence: this._getConfidenceScore(parsedData),
               threshold: confidenceThreshold,
-              accepted: successfulConfidenceScore
+              accepted: successfulConfidenceScore,
+              segmentEndSec: lodash__default["default"].isFinite(lodash__default["default"].get(parsedData, 'data.end')) ? parsedData.data.end : null,
+              speechEndSec: lodash__default["default"].isFinite(lodash__default["default"].get(parsedData, 'data.speechEndSec')) ? parsedData.data.speechEndSec : null
             });
+            if (successfulConfidenceScore) {
+              this._captureSttFinalForReplyTrace(parsedData, msgPreview);
+            }
             // ORIGINAL: always emit final message immediately (ignore JOIN hooks/rules).
             if (this.caps[Capabilities.VOIP_STT_MESSAGE_HANDLING] === 'ORIGINAL') {
               let botMsg = {
@@ -1051,9 +1346,49 @@ class BotiumConnectorVoip {
             }
           }
         });
-      }).catch(err => {
-        reject(new Error('Error: ' + err));
-      });
+      };
+      const retryCallSetup487 = reasonMessage => {
+        setup487Retries++;
+        _info('call_setup_retry_487', {
+          sessionId: this.sessionId,
+          attempt: setup487Retries,
+          max: max487Retries,
+          reason: reasonMessage || null
+        });
+        debug$3(`Call setup 487 retry ${setup487Retries}/${max487Retries}: ${reasonMessage}`);
+        // Tear down the dead websocket so its stale handlers cannot fire while
+        // the next attempt establishes a fresh worker session.
+        try {
+          if (this.ws) {
+            this.ws.removeAllListeners();
+            this.ws.terminate();
+          }
+        } catch (err) {
+          debug$3(`Call setup 487 retry: websocket teardown failed: ${err && err.message}`);
+        }
+        this.ws = null;
+        this.wsOpened = false;
+        this.end = false;
+        setTimeout(() => {
+          establishCall().catch(err => reject(new Error('Error: ' + err)));
+        }, this.caps[Capabilities.VOIP_CALL_SETUP_RETRY_487_TIMEOUT]);
+      };
+      const establishCall = async () => {
+        // Each (re)try gets a fresh worker session: new initCall -> new port ->
+        // new websocket -> new SIP INVITE.
+        httpInitRetries = 0;
+        await connectHttp();
+        if (httpInitRetries > 0) {
+          _info('connected_after_retries', {
+            phase: 'initCall',
+            retries: httpInitRetries
+          });
+        }
+        wsEndpoint = computeWsEndpoint();
+        const wsRetries = await connectWs();
+        onWsConnected(wsRetries);
+      };
+      establishCall().catch(err => reject(new Error('Error: ' + err)));
     });
   }
   async UserSays(msg) {
@@ -1063,6 +1398,10 @@ class BotiumConnectorVoip {
     const hasDtmf = !!(msg && msg.buttons && msg.buttons.length > 0);
     const dtmfMatch = msg && msg.messageText && msg.messageText.match(/<DTMF>([^<]+)<\/DTMF>/i);
     const inputType = hasDtmf || dtmfMatch ? 'dtmf' : hasText && hasVoiceMedia ? 'mixed' : hasText ? 'text' : hasVoiceMedia ? 'media' : 'unknown';
+    // A real user turn is one that sends content (text/media/dtmf). 'unknown' turns send nothing and
+    // surface server-side as skippable me-steps, so they must NOT consume an ordinal slot - this keeps
+    // meTurnIndex aligned with the server's non-skippable me-step indices when placing turn audio.
+    const meTurnIndex = inputType !== 'unknown' ? this._meTurnAudioOrdinal = (this._meTurnAudioOrdinal ?? -1) + 1 : null;
     const msgPreview = hasText && msg.messageText ? String(msg.messageText).trim().substring(0, 80) : '';
     _info('user_says', {
       sessionId: this.sessionId,
@@ -1071,6 +1410,7 @@ class BotiumConnectorVoip {
       messageLength: hasText && msg.messageText ? msg.messageText.length : undefined,
       mediaSize: hasVoiceMedia && msg.media[0] && Buffer.isBuffer(msg.media[0].buffer) ? msg.media[0].buffer.length : undefined
     });
+    this._captureUserSaysStart(msgPreview);
     // Avoid logging large buffers/base64 (can break job logs and overwhelm stdout)
     try {
       const safeLog = {
@@ -1105,17 +1445,45 @@ class BotiumConnectorVoip {
           // the coach can place the agent turn on the recording timeline.
           // `requestedDurationMs` is the best estimate of on-wire playback
           // length (DTMF tones × digits, TTS synth output, parsed media duration).
+          const recordingSecNow = () => this._recordingSecNow();
           const stampAgentWire = (wireKind, requestedDurationMs, extras = {}) => {
+            const wireRecordingStartSec = recordingSecNow();
             msg.voipAgent = {
               wireSentAtMs: Date.now(),
               inputType,
               wireKind,
               requestedDurationMs: Math.max(0, Math.round(requestedDurationMs || 0)),
+              ...(wireRecordingStartSec != null ? {
+                wireRecordingStartSec
+              } : {}),
+              // Carry the coach's reply-decision trace (set on the outgoing message before UserSays)
+              // into voipAgent here, while we own the object and before MESSAGE_SENTTOBOT fires — so
+              // the LIVE transcript snapshot (a deep copy taken at that event) already has it, not
+              // just the final result. Lets the UI split "Tester reply decision" live.
+              ...(msg && msg.coachTrace && typeof msg.coachTrace === 'object' ? {
+                coachTrace: msg.coachTrace
+              } : {}),
               ...extras
             };
+            this._activeUserSaysVoipAgent = msg.voipAgent;
+            this._captureAgentWire(msg.voipAgent, inputType);
+          };
+          const sendAgentWire = request => {
+            this._sendUserSaysWs(request);
+            this._markReplyTrace({
+              sendAudioAtMs: Date.now()
+            });
+            this._logReplyTrace('wire_sent');
+            // Finalize the wall pipeline NOW, while _replyTrace still holds this turn's data
+            // (userSaysAtMs / ttsStartAtMs / ttsEndAtMs / wireAtMs / sendAudioAtMs are all set by
+            // this point). The deferred turn-audio callback runs only after the agent audio is
+            // "heard" on the recording, which nulls _replyTrace (_logReplyTraceHeard); finalizing
+            // there would drop wallPipeline entirely and collapse the reply-delay breakdown into a
+            // single "Audio send" bucket on the UI.
+            this._finalizeWallPipeline(msg.voipAgent);
           };
           // Twilio default: 100 ms tone + 100 ms gap per digit. Drives agent-bar width only.
-          const DTMF_MS_PER_DIGIT = 200;
+          const DTMF_AGENT_BAR_MS_PER_DIGIT = DTMF_MS_PER_DIGIT;
           if (msg && msg.buttons && msg.buttons.length > 0) {
             const digits = sanitizeDtmfDigits(msg.buttons[0].payload);
             if (!digits) {
@@ -1128,10 +1496,13 @@ class BotiumConnectorVoip {
               digits,
               sessionId: this.sessionId
             });
-            stampAgentWire('dtmf', digits.length * DTMF_MS_PER_DIGIT, {
-              digitCount: digits.length
+            stampAgentWire('dtmf', digits.length * DTMF_AGENT_BAR_MS_PER_DIGIT, {
+              digitCount: digits.length,
+              dtmfDigits: digits
             });
-            this._sendUserSaysWs(request);
+            sendAgentWire(request);
+            // Wait for DTMF playback plus at least one audioStream flush before slicing turn audio.
+            duration = dtmfTurnAudioWaitMs(digits.length) / 1000;
           } else if (msg && msg.messageText) {
             // Check for DTMF tag in messageText: <DTMF>1234</DTMF>
             const dtmfMatch = msg.messageText.match(/<DTMF>([^<]+)<\/DTMF>/i);
@@ -1152,13 +1523,14 @@ class BotiumConnectorVoip {
                 digits,
                 sessionId: this.sessionId
               });
-              stampAgentWire('dtmf', digits.length * DTMF_MS_PER_DIGIT, {
-                digitCount: digits.length
+              stampAgentWire('dtmf', digits.length * DTMF_AGENT_BAR_MS_PER_DIGIT, {
+                digitCount: digits.length,
+                dtmfDigits: digits
               });
-              this._sendUserSaysWs(request);
-              return resolve();
-            }
-            if (!skipTtsForMixedInput) {
+              sendAgentWire(request);
+              // Wait for DTMF playback plus at least one audioStream flush before slicing turn audio.
+              duration = dtmfTurnAudioWaitMs(digits.length) / 1000;
+            } else if (!skipTtsForMixedInput) {
               if (!this.axiosTtsParams) {
                 if (!(msg.media && msg.media.length > 0 && msg.media[0].buffer)) {
                   return reject(new Error('TTS not configured, only audio input supported'));
@@ -1170,10 +1542,17 @@ class BotiumConnectorVoip {
                 msg.sourceData = ttsRequest;
                 let ttsResult = null;
                 const ttsStartedAt = Date.now();
+                this._markReplyTrace({
+                  ttsStartAtMs: ttsStartedAt
+                });
                 let ttsSynthMs = 0;
                 try {
                   ttsResult = await this._getTtsAudio(ttsRequest, msg.messageText);
                   ttsSynthMs = Date.now() - ttsStartedAt;
+                  this._markReplyTrace({
+                    ttsEndAtMs: Date.now(),
+                    ttsSynthMs
+                  });
                 } catch (err) {
                   return reject(new Error(`TTS "${msg.messageText}" failed - ${this._getAxiosErrOutput(err)}`));
                 }
@@ -1209,7 +1588,7 @@ class BotiumConnectorVoip {
                     ttsSynthMs,
                     textLength: msg.messageText ? msg.messageText.length : 0
                   });
-                  this._sendUserSaysWs(request);
+                  sendAgentWire(request);
                 } else {
                   return reject(new Error('TTS failed, response is empty'));
                 }
@@ -1234,7 +1613,7 @@ class BotiumConnectorVoip {
             stampAgentWire('media', 0, {
               mediaUri: msg.media[0].mediaUri || null
             });
-            this._sendUserSaysWs(request);
+            sendAgentWire(request);
             msg.attachments.push({
               name: msg.media[0].mediaUri,
               mimeType: msg.media[0].mimeType,
@@ -1256,16 +1635,514 @@ class BotiumConnectorVoip {
             }
           }
           const requestedDurationMs = Math.max(0, Math.round((duration || 0) * 1000));
-          if (requestedDurationMs <= 0) {
-            return resolve();
-          }
-          setTimeout(resolve, requestedDurationMs);
+
+          // Record this turn's slice bounds and resolve immediately — the actual
+          // slice is cut from the complete buffer at session end (see
+          // _flushPendingTurnAudio). This keeps UserSays from waiting for the
+          // recording to catch up with playback (no latency for TTS or DTMF). The
+          // heard-trace telemetry (voip_reply_trace_heard) is logged from the
+          // agentPlaybackStarted handler once playback is audible on the recording.
+          this._recordPendingTurnAudio(msg.voipAgent, requestedDurationMs, meTurnIndex);
+          resolve();
         } catch (err) {
           reject(err);
         }
       }, 0);
     });
   }
+  _recordingSecNow() {
+    const fmt = this.audioStream && this.audioStream.format;
+    const bytesPerSec = fmt ? fmt.sampleRate * fmt.channels * (fmt.bitsPerSample / 8) : null;
+    if (!bytesPerSec || !this.audioStream || !(this.audioStream.totalBytes > 0)) return null;
+    return this.audioStream.totalBytes / bytesPerSec;
+  }
+
+  /** Expected on-recording playback length of a DTMF turn (worker-reported, else estimated). */
+  _dtmfPlaybackSec(voipAgent, digitCount) {
+    const playbackMs = voipAgent && voipAgent.playbackRequestedDurationMs;
+    if (lodash__default["default"].isFinite(playbackMs) && playbackMs > 0) return playbackMs / 1000;
+    return dtmfPlaybackMs(digitCount) / 1000;
+  }
+
+  /**
+   * Snapshot the bounds needed to slice this turn's audio later, then return.
+   * `_lastBotTurnStartSec` is the bot-speech anchor; it is consumed here so the
+   * next bot message sets a fresh one. The end of the agent's playback is read
+   * from voipAgent.playedRecordingStartSec (filled asynchronously by the
+   * agentPlaybackStarted handler) at flush time. Consecutive agent turns with no
+   * bot message in between (anchor null) chain off the previous turn's end.
+   */
+  _recordPendingTurnAudio(voipAgent, requestedDurationMs, meTurnIndex) {
+    if (!this.caps[Capabilities.VOIP_TURN_AUDIO_ENABLE]) return;
+    const botAnchorSec = lodash__default["default"].isFinite(this._lastBotTurnStartSec) ? this._lastBotTurnStartSec : null;
+    this._lastBotTurnStartSec = null;
+    this._pendingTurnAudio.push({
+      botAnchorSec,
+      voipAgent: voipAgent || null,
+      requestedDurationMs: Math.max(0, requestedDurationMs || 0),
+      meTurnIndex: Number.isInteger(meTurnIndex) && meTurnIndex >= 0 ? meTurnIndex : null
+    });
+    _info('turn_audio_recorded', {
+      sessionId: this.sessionId,
+      meTurnIndex,
+      botAnchorSec,
+      wireKind: voipAgent && voipAgent.wireKind,
+      pending: this._pendingTurnAudio.length
+    });
+  }
+
+  /**
+   * Emit per-turn audio (turn_N.wav) for every pending turn whose playback end the
+   * recording buffer has already reached, slicing from the live buffer and emitting a
+   * MESSAGE_ATTACHMENT carrying meTurnIndex. Turns are processed in order (the chain
+   * start of a follow-up turn with no bot anchor depends on the previous turn's end), so
+   * a not-yet-ready turn stops the pass until more audio streams in. With force=true
+   * (session end) the remainder is emitted even if the buffer is incomplete.
+   */
+  _emitReadyTurnAudio(reason, force) {
+    if (!this.caps[Capabilities.VOIP_TURN_AUDIO_ENABLE]) return;
+    const pending = this._pendingTurnAudio || [];
+    if (!pending.length) return;
+    if (!this.audioStream || !this.audioStream.format) return; // no PCM yet
+    const slackSec = (audioStreamIntervalMs() + 50) / 1000;
+    const recNow = this._recordingSecNow();
+    for (const t of pending) {
+      if (t.emitted) continue;
+      try {
+        const va = t.voipAgent || {};
+        const playbackSec = va.wireKind === 'dtmf' ? this._dtmfPlaybackSec(va, va.digitCount || 1) : lodash__default["default"].isFinite(va.playbackRequestedDurationMs) && va.playbackRequestedDurationMs > 0 ? va.playbackRequestedDurationMs / 1000 : t.requestedDurationMs / 1000;
+        const startSec = lodash__default["default"].isFinite(t.botAnchorSec) ? t.botAnchorSec : this._turnAudioPrevEndSec;
+        // End = where the agent's playback finished on the recording. _sliceTurnAudio
+        // adds the configured padding on top.
+        const anchorSec = lodash__default["default"].isFinite(va.playedRecordingStartSec) ? va.playedRecordingStartSec : lodash__default["default"].isFinite(va.heardRecordingStartSec) ? va.heardRecordingStartSec : lodash__default["default"].isFinite(va.wireRecordingStartSec) ? va.wireRecordingStartSec : null;
+        let endSec = lodash__default["default"].isFinite(anchorSec) ? anchorSec + playbackSec : null;
+        if (!lodash__default["default"].isFinite(endSec) && lodash__default["default"].isFinite(startSec)) endSec = startSec + playbackSec;
+
+        // Progressive: only emit once the recording has reached this turn's end (plus a
+        // stream-flush slack). Stop the pass otherwise — later turns must wait their turn.
+        if (!force) {
+          if (!lodash__default["default"].isFinite(anchorSec) || !lodash__default["default"].isFinite(endSec)) break;
+          if (!lodash__default["default"].isFinite(recNow) || recNow < endSec + slackSec) break;
+        }
+        if (!lodash__default["default"].isFinite(startSec) || !lodash__default["default"].isFinite(endSec) || endSec <= startSec) {
+          debug$3(`${this.sessionId} - turnAudio: skip turn (start=${startSec} end=${endSec} reason=${reason})`);
+          t.emitted = true;
+          if (lodash__default["default"].isFinite(endSec)) this._turnAudioPrevEndSec = endSec;
+          continue;
+        }
+        const audioBase64 = this._sliceTurnAudio(startSec, endSec);
+        t.emitted = true;
+        this._turnAudioPrevEndSec = endSec;
+        if (!audioBase64) continue;
+        this._turnAudioCounter = (this._turnAudioCounter || 0) + 1;
+        this.eventEmitter.emit('MESSAGE_ATTACHMENT', this.container, {
+          name: `turn_${this._turnAudioCounter}.wav`,
+          mimeType: 'audio/wav',
+          base64: audioBase64,
+          meTurnIndex: t.meTurnIndex,
+          // 0-based real-user-turn ordinal (authoritative for placement)
+          sessionContext: {
+            testSessionId: this.caps.VOIP_TEST_SESSION_ID || null,
+            testSessionJobId: this.caps.VOIP_TEST_SESSION_JOB_ID || null
+          }
+        });
+        _info('turn_audio_emitted', {
+          sessionId: this.sessionId,
+          name: `turn_${this._turnAudioCounter}.wav`,
+          meTurnIndex: t.meTurnIndex,
+          startSec: Number(startSec.toFixed(2)),
+          endSec: Number(endSec.toFixed(2)),
+          reason
+        });
+      } catch (err) {
+        debug$3(`${this.sessionId} - emitReadyTurnAudio: turn slice error: ${err && err.message}`);
+      }
+    }
+  }
+
+  /**
+   * Force-emit any per-turn audio not yet sent (session end). Idempotent.
+   */
+  _flushPendingTurnAudio(reason) {
+    if (this._turnAudioForceDone) return;
+    this._turnAudioForceDone = true;
+    const pending = this._pendingTurnAudio || [];
+    _info('turn_audio_flush_enter', {
+      sessionId: this.sessionId,
+      reason,
+      pending: pending.length,
+      emittedAlready: pending.filter(t => t.emitted).length,
+      hasFormat: !!(this.audioStream && this.audioStream.format),
+      totalBytes: this.audioStream && this.audioStream.totalBytes,
+      turnAudioEnable: !!this.caps[Capabilities.VOIP_TURN_AUDIO_ENABLE]
+    });
+    this._emitReadyTurnAudio(reason, true);
+    this._emitTrailingBotAudio(reason);
+    _info('turn_audio_flush_done', {
+      sessionId: this.sessionId,
+      reason,
+      emitted: this._turnAudioCounter || 0,
+      pending: pending.length
+    });
+  }
+
+  /**
+   * If the call ended on a bot turn (a bot message arrived with no me-response after it),
+   * `_lastBotTurnStartSec` was never consumed by a turn. Slice that trailing bot audio
+   * (bot start → end of recording) and emit it as a turn clip flagged `trailingBot` so the
+   * UI/server place it on the final bot step.
+   */
+  _emitTrailingBotAudio(reason) {
+    if (!this.caps[Capabilities.VOIP_TURN_AUDIO_ENABLE]) return;
+    if (this._trailingBotAudioEmitted) return;
+    const startSec = lodash__default["default"].isFinite(this._lastBotTurnStartSec) ? this._lastBotTurnStartSec : null;
+    if (!lodash__default["default"].isFinite(startSec)) return;
+    if (!this.audioStream || !this.audioStream.format) return;
+    const endSec = this._recordingSecNow();
+    if (!lodash__default["default"].isFinite(endSec) || endSec <= startSec) return;
+    let audioBase64 = null;
+    try {
+      audioBase64 = this._sliceTurnAudio(startSec, endSec);
+    } catch (err) {
+      debug$3(`${this.sessionId} - emitTrailingBotAudio: slice error: ${err && err.message}`);
+      return;
+    }
+    if (!audioBase64) return;
+    this._trailingBotAudioEmitted = true;
+    this._lastBotTurnStartSec = null;
+    this._turnAudioCounter = (this._turnAudioCounter || 0) + 1;
+    this.eventEmitter.emit('MESSAGE_ATTACHMENT', this.container, {
+      name: `turn_${this._turnAudioCounter}.wav`,
+      mimeType: 'audio/wav',
+      base64: audioBase64,
+      trailingBot: true,
+      // place on the final bot step (no me-response followed)
+      sessionContext: {
+        testSessionId: this.caps.VOIP_TEST_SESSION_ID || null,
+        testSessionJobId: this.caps.VOIP_TEST_SESSION_JOB_ID || null
+      }
+    });
+    _info('turn_audio_trailing_emitted', {
+      sessionId: this.sessionId,
+      name: `turn_${this._turnAudioCounter}.wav`,
+      startSec: Number(startSec.toFixed(2)),
+      endSec: Number(endSec.toFixed(2)),
+      reason
+    });
+  }
+  _agentSpeechRmsThreshold() {
+    const raw = process.env.VOIP_AGENT_SPEECH_RMS_THRESHOLD;
+    const n = raw != null ? Number(raw) : DEFAULT_AGENT_SPEECH_RMS_THRESHOLD;
+    return Number.isFinite(n) && n > 0 ? n : DEFAULT_AGENT_SPEECH_RMS_THRESHOLD;
+  }
+  _agentSpeechSustainedWindows() {
+    const raw = process.env.VOIP_AGENT_SPEECH_SUSTAINED_WINDOWS;
+    const n = raw != null ? parseInt(raw, 10) : DEFAULT_AGENT_SPEECH_SUSTAINED_WINDOWS;
+    return Number.isFinite(n) && n > 0 ? n : DEFAULT_AGENT_SPEECH_SUSTAINED_WINDOWS;
+  }
+  _audioStreamBytesPerSec() {
+    const fmt = this.audioStream && this.audioStream.format;
+    if (!fmt) return null;
+    return fmt.sampleRate * fmt.channels * (fmt.bitsPerSample / 8);
+  }
+  _pcmBufferRms(pcm, bitsPerSample) {
+    if (!pcm || pcm.length < 2 || bitsPerSample !== 16) return 0;
+    let sum = 0;
+    let count = 0;
+    for (let i = 0; i + 1 < pcm.length; i += 2) {
+      const sample = pcm.readInt16LE(i);
+      sum += sample * sample;
+      count += 1;
+    }
+    return count > 0 ? Math.sqrt(sum / count) : 0;
+  }
+  _readWavPcmInfo(wavBuffer) {
+    if (!wavBuffer || wavBuffer.length < 44) return null;
+    if (wavBuffer.toString('ascii', 0, 4) !== 'RIFF' || wavBuffer.toString('ascii', 8, 12) !== 'WAVE') {
+      return null;
+    }
+    let offset = 12;
+    let sampleRate = null;
+    let channels = null;
+    let bitsPerSample = null;
+    let dataOffset = null;
+    let dataLength = null;
+    while (offset + 8 <= wavBuffer.length) {
+      const chunkId = wavBuffer.toString('ascii', offset, offset + 4);
+      const chunkSize = wavBuffer.readUInt32LE(offset + 4);
+      const chunkStart = offset + 8;
+      if (chunkId === 'fmt ' && chunkSize >= 16) {
+        channels = wavBuffer.readUInt16LE(chunkStart + 2);
+        sampleRate = wavBuffer.readUInt32LE(chunkStart + 4);
+        bitsPerSample = wavBuffer.readUInt16LE(chunkStart + 14);
+      } else if (chunkId === 'data') {
+        dataOffset = chunkStart;
+        dataLength = chunkSize;
+        break;
+      }
+      offset = chunkStart + chunkSize + chunkSize % 2;
+    }
+    if (!sampleRate || !channels || !bitsPerSample || dataOffset == null) return null;
+    const bytesPerSec = sampleRate * channels * (bitsPerSample / 8);
+    if (!bytesPerSec) return null;
+    const pcmLength = dataLength != null ? Math.min(dataLength, wavBuffer.length - dataOffset) : wavBuffer.length - dataOffset;
+    return {
+      pcmOffset: dataOffset,
+      pcmLength,
+      bytesPerSec,
+      bitsPerSample,
+      sampleRate,
+      channels
+    };
+  }
+  _findAudibleLeadInSecFromPcm(pcm, bytesPerSec, bitsPerSample) {
+    if (!pcm || !bytesPerSec) return null;
+    const threshold = this._agentSpeechRmsThreshold();
+    const sustainedWindows = this._agentSpeechSustainedWindows();
+    const windowBytes = Math.max(2, Math.floor(bytesPerSec * (AGENT_SPEECH_RMS_WINDOW_MS / 1000)));
+    const hopBytes = Math.max(2, Math.floor(windowBytes / 2));
+    let streak = 0;
+    let onsetPos = null;
+    for (let pos = 0; pos + windowBytes <= pcm.length; pos += hopBytes) {
+      const rms = this._pcmBufferRms(pcm.subarray(pos, pos + windowBytes), bitsPerSample);
+      if (rms >= threshold) {
+        if (streak === 0) onsetPos = pos;
+        streak += 1;
+        if (streak >= sustainedWindows) {
+          return onsetPos / bytesPerSec;
+        }
+      } else {
+        streak = 0;
+        onsetPos = null;
+      }
+    }
+    return null;
+  }
+  _findAudibleLeadInSecFromWavBuffer(wavBuffer) {
+    const info = this._readWavPcmInfo(wavBuffer);
+    if (!info) return null;
+    const pcm = wavBuffer.subarray(info.pcmOffset, info.pcmOffset + info.pcmLength);
+    return this._findAudibleLeadInSecFromPcm(pcm, info.bytesPerSec, info.bitsPerSample);
+  }
+  _findAudibleRecordingStartSecOnStream(playedSec, wireSec) {
+    if (!lodash__default["default"].isFinite(playedSec)) return null;
+    const bytesPerSec = this._audioStreamBytesPerSec();
+    const stream = this.audioStream;
+    if (!bytesPerSec || !stream || !stream.pcmParts.length) return null;
+    const startByte = Math.max(0, Math.floor(playedSec * bytesPerSec));
+    const pcm = Buffer.concat(stream.pcmParts);
+    if (startByte >= pcm.length) return null;
+    const bitsPerSample = stream.format.bitsPerSample;
+    const leadInSec = this._findAudibleLeadInSecFromPcm(pcm.subarray(startByte), bytesPerSec, bitsPerSample);
+    if (!lodash__default["default"].isFinite(leadInSec)) return null;
+    let heardSec = playedSec + leadInSec;
+    if (lodash__default["default"].isFinite(wireSec)) heardSec = Math.max(wireSec, heardSec);
+    return heardSec;
+  }
+  _findAudibleRecordingStartSecFromAttachments(playedSec, wireSec, attachments) {
+    if (!lodash__default["default"].isFinite(playedSec) || !lodash__default["default"].isArray(attachments)) return null;
+    const tts = attachments.find(a => a && a.name === 'tts.wav' && a.base64);
+    if (!tts) return null;
+    try {
+      const wavBuffer = Buffer.from(tts.base64, 'base64');
+      const leadInSec = this._findAudibleLeadInSecFromWavBuffer(wavBuffer);
+      if (!lodash__default["default"].isFinite(leadInSec)) return null;
+      let heardSec = playedSec + leadInSec;
+      if (lodash__default["default"].isFinite(wireSec)) heardSec = Math.max(wireSec, heardSec);
+      return heardSec;
+    } catch (err) {
+      debug$3(`${this.sessionId} - TTS lead-in scan failed: ${err && err.message}`);
+      return null;
+    }
+  }
+  _resolveAgentHeardRecordingStartSec(voipAgent, attachments) {
+    if (!voipAgent || !lodash__default["default"].isFinite(voipAgent.playedRecordingStartSec)) return null;
+    const playedSec = voipAgent.playedRecordingStartSec;
+    const wireSec = voipAgent.wireRecordingStartSec;
+    const fromTts = this._findAudibleRecordingStartSecFromAttachments(playedSec, wireSec, attachments);
+    const fromStream = this._findAudibleRecordingStartSecOnStream(playedSec, wireSec);
+    const candidates = [fromTts, fromStream].filter(s => lodash__default["default"].isFinite(s));
+    if (!candidates.length) return null;
+    // Prefer the later onset — mixed recording can spike before clear TTS speech.
+    return Math.max(...candidates);
+  }
+  _applyAgentHeardRecordingStartSec(voipAgent, attachments) {
+    if (!voipAgent || !lodash__default["default"].isFinite(voipAgent.playedRecordingStartSec)) return null;
+    const heardSec = this._resolveAgentHeardRecordingStartSec(voipAgent, attachments);
+    if (!lodash__default["default"].isFinite(heardSec) || heardSec <= voipAgent.playedRecordingStartSec) {
+      return lodash__default["default"].isFinite(voipAgent.heardRecordingStartSec) ? voipAgent.heardRecordingStartSec : null;
+    }
+    const prev = voipAgent.heardRecordingStartSec;
+    if (lodash__default["default"].isFinite(prev) && prev >= heardSec) return prev;
+    voipAgent.heardRecordingStartSec = heardSec;
+    this._markReplyTrace({
+      heardRecordingStartSec: heardSec
+    });
+    return heardSec;
+  }
+  _maybeDetectAgentAudibleOnRecording(voipAgent) {
+    if (!voipAgent || !lodash__default["default"].isFinite(voipAgent.playedRecordingStartSec)) return;
+    this._applyAgentHeardRecordingStartSec(voipAgent);
+  }
+  _markReplyTrace(patch) {
+    if (!this._replyTrace || !patch) return;
+    Object.assign(this._replyTrace, patch);
+  }
+  _captureSttFinalForReplyTrace(parsedData, msgPreview) {
+    const data = parsedData && parsedData.data;
+    const atMs = parsedData._receivedAtMs || Date.now();
+    const recordingAtSttFinalSec = this._recordingSecNow();
+    if (parsedData && lodash__default["default"].isFinite(recordingAtSttFinalSec)) {
+      parsedData.recordingAtSttFinalSec = recordingAtSttFinalSec;
+    }
+    // Dedicated, self-documenting anchor for the downstream "STT transport" sub-phase
+    // (receivedAtMs - finalEmittedWallMs). Unlike the generic _receivedAtMs (stamped on
+    // every WS frame), this is set only on the accepted STT-final.
+    if (parsedData && lodash__default["default"].isFinite(atMs)) {
+      parsedData.sttFinalReceivedAtMs = atMs;
+    }
+    this._replyTrace = {
+      sessionId: this.sessionId,
+      botMessagePreview: msgPreview || undefined,
+      sttFinalAtMs: atMs,
+      sttRecordingStartSec: lodash__default["default"].isFinite(lodash__default["default"].get(data, 'start')) ? data.start : null,
+      sttRecordingEndSec: lodash__default["default"].isFinite(lodash__default["default"].get(data, 'end')) ? data.end : null,
+      sttSpeechEndSec: lodash__default["default"].isFinite(lodash__default["default"].get(data, 'speechEndSec')) ? data.speechEndSec : null,
+      recordingAtSttFinalSec: lodash__default["default"].isFinite(recordingAtSttFinalSec) ? recordingAtSttFinalSec : null,
+      queueAtMs: null,
+      recordingAtQueueSec: null,
+      psstTimerArmedAtMs: null,
+      psstScheduledMs: null,
+      psstTimerFiredAtMs: null,
+      psstFireDelayMs: null,
+      userSaysAtMs: null,
+      coachWaitMs: null,
+      ttsStartAtMs: null,
+      ttsEndAtMs: null,
+      ttsSynthMs: null,
+      wireAtMs: null,
+      wireRecordingStartSec: null,
+      sendAudioAtMs: null,
+      playedRecordingStartSec: null,
+      playbackAtMs: null,
+      heardRecordingStartSec: null,
+      agentEndRecordingSec: null,
+      wireKind: null,
+      inputType: null,
+      requestedDurationMs: null,
+      meMessagePreview: null
+    };
+  }
+  _captureBotQueuedForReplyTrace(queuedAt) {
+    if (!this._replyTrace) return;
+    this._replyTrace.queueAtMs = queuedAt;
+    this._replyTrace.recordingAtQueueSec = this._recordingSecNow();
+  }
+  _captureUserSaysStart(msgPreview) {
+    if (!this._replyTrace) return;
+    const now = Date.now();
+    this._replyTrace.userSaysAtMs = now;
+    this._replyTrace.meMessagePreview = msgPreview || undefined;
+    const queueAt = this._replyTrace.queueAtMs || this._lastBotSaysQueuedAt;
+    if (lodash__default["default"].isFinite(queueAt)) {
+      if (!this._replyTrace.queueAtMs) this._replyTrace.queueAtMs = queueAt;
+      this._replyTrace.coachWaitMs = now - queueAt;
+    }
+  }
+  _captureAgentWire(voipAgent, inputType) {
+    if (!this._replyTrace || !voipAgent) return;
+    this._replyTrace.wireAtMs = voipAgent.wireSentAtMs;
+    this._replyTrace.wireRecordingStartSec = voipAgent.wireRecordingStartSec;
+    this._replyTrace.wireKind = voipAgent.wireKind;
+    this._replyTrace.inputType = inputType;
+    this._replyTrace.requestedDurationMs = voipAgent.requestedDurationMs;
+    if (lodash__default["default"].isFinite(voipAgent.ttsSynthMs)) this._replyTrace.ttsSynthMs = voipAgent.ttsSynthMs;
+  }
+  _finalizeWallPipeline(voipAgent) {
+    const t = this._replyTrace;
+    if (!voipAgent || !t) return;
+    voipAgent.wallPipeline = {
+      psstScheduledMs: lodash__default["default"].isFinite(t.psstScheduledMs) ? t.psstScheduledMs : null,
+      psstFireDelayMs: lodash__default["default"].isFinite(t.psstFireDelayMs) ? t.psstFireDelayMs : null,
+      coachWaitMs: lodash__default["default"].isFinite(t.coachWaitMs) ? t.coachWaitMs : null,
+      userSaysAtMs: lodash__default["default"].isFinite(t.userSaysAtMs) ? t.userSaysAtMs : null,
+      ttsStartAtMs: lodash__default["default"].isFinite(t.ttsStartAtMs) ? t.ttsStartAtMs : null,
+      ttsEndAtMs: lodash__default["default"].isFinite(t.ttsEndAtMs) ? t.ttsEndAtMs : null,
+      ttsSynthMs: lodash__default["default"].isFinite(t.ttsSynthMs) ? t.ttsSynthMs : null,
+      wireAtMs: lodash__default["default"].isFinite(t.wireAtMs) ? t.wireAtMs : null,
+      sendAudioAtMs: lodash__default["default"].isFinite(t.sendAudioAtMs) ? t.sendAudioAtMs : null
+    };
+  }
+  _replyTraceMsFromSttFinal(atMs) {
+    const anchor = this._replyTrace && this._replyTrace.sttFinalAtMs;
+    if (!lodash__default["default"].isFinite(anchor) || !lodash__default["default"].isFinite(atMs)) return null;
+    return Math.round(atMs - anchor);
+  }
+  _replyTraceRecMs(fromSec, toSec) {
+    if (!lodash__default["default"].isFinite(fromSec) || !lodash__default["default"].isFinite(toSec)) return null;
+    return Math.round((toSec - fromSec) * 1000);
+  }
+  _logReplyTrace(trigger) {
+    const t = this._replyTrace;
+    if (!t || !lodash__default["default"].isFinite(t.sttFinalAtMs)) return;
+    _info('voip_reply_trace', {
+      sessionId: t.sessionId,
+      trigger,
+      botPreview: t.botMessagePreview,
+      mePreview: t.meMessagePreview,
+      sttRecordingStartSec: t.sttRecordingStartSec,
+      sttRecordingEndSec: t.sttRecordingEndSec,
+      sttSpeechEndSec: t.sttSpeechEndSec,
+      recordingAtSttFinalSec: t.recordingAtSttFinalSec,
+      recordingAtQueueSec: t.recordingAtQueueSec,
+      wireRecordingStartSec: t.wireRecordingStartSec,
+      wireKind: t.wireKind,
+      inputType: t.inputType,
+      requestedDurationMs: t.requestedDurationMs,
+      ttsSynthMs: t.ttsSynthMs,
+      coachWaitMs: t.coachWaitMs,
+      psstScheduledMs: t.psstScheduledMs,
+      psstFireDelayMs: t.psstFireDelayMs,
+      ms_sttFinal_to_queue: this._replyTraceMsFromSttFinal(t.queueAtMs),
+      ms_sttFinal_to_psstFire: this._replyTraceMsFromSttFinal(t.psstTimerFiredAtMs),
+      ms_sttFinal_to_userSays: this._replyTraceMsFromSttFinal(t.userSaysAtMs),
+      ms_sttFinal_to_ttsStart: this._replyTraceMsFromSttFinal(t.ttsStartAtMs),
+      ms_sttFinal_to_ttsEnd: this._replyTraceMsFromSttFinal(t.ttsEndAtMs),
+      ms_sttFinal_to_wire: this._replyTraceMsFromSttFinal(t.wireAtMs),
+      ms_sttFinal_to_sendAudio: this._replyTraceMsFromSttFinal(t.sendAudioAtMs),
+      ms_userSays_to_ttsStart: lodash__default["default"].isFinite(t.userSaysAtMs) && lodash__default["default"].isFinite(t.ttsStartAtMs) ? Math.round(t.ttsStartAtMs - t.userSaysAtMs) : null,
+      ms_userSays_to_wire: lodash__default["default"].isFinite(t.userSaysAtMs) && lodash__default["default"].isFinite(t.wireAtMs) ? Math.round(t.wireAtMs - t.userSaysAtMs) : null,
+      ms_queue_to_userSays: t.coachWaitMs,
+      recMs_sttEnd_to_queue: this._replyTraceRecMs(t.sttRecordingEndSec, t.recordingAtQueueSec),
+      recMs_sttEnd_to_wire: this._replyTraceRecMs(t.sttRecordingEndSec, t.wireRecordingStartSec),
+      recMs_speechEnd_to_wire: this._replyTraceRecMs(t.sttSpeechEndSec, t.wireRecordingStartSec)
+    });
+  }
+  _logReplyTraceHeard(agentEndRecordingSec) {
+    const t = this._replyTrace;
+    if (!t || !lodash__default["default"].isFinite(t.sttFinalAtMs)) return;
+    const heardSec = t.heardRecordingStartSec;
+    const playedSec = t.playedRecordingStartSec;
+    if (lodash__default["default"].isFinite(agentEndRecordingSec)) {
+      t.agentEndRecordingSec = agentEndRecordingSec;
+    }
+    _info('voip_reply_trace_heard', {
+      sessionId: t.sessionId,
+      playedRecordingStartSec: playedSec,
+      heardRecordingStartSec: heardSec,
+      agentEndRecordingSec: t.agentEndRecordingSec,
+      wireRecordingStartSec: t.wireRecordingStartSec,
+      sttRecordingEndSec: t.sttRecordingEndSec,
+      sttSpeechEndSec: t.sttSpeechEndSec,
+      recMs_sttEnd_to_played: this._replyTraceRecMs(t.sttRecordingEndSec, playedSec),
+      recMs_speechEnd_to_played: this._replyTraceRecMs(t.sttSpeechEndSec, playedSec),
+      recMs_sttEnd_to_heard: this._replyTraceRecMs(t.sttRecordingEndSec, heardSec),
+      recMs_sttEnd_to_wire: this._replyTraceRecMs(t.sttRecordingEndSec, t.wireRecordingStartSec),
+      recMs_wire_to_played: this._replyTraceRecMs(t.wireRecordingStartSec, playedSec),
+      recMs_wire_to_heard: this._replyTraceRecMs(t.wireRecordingStartSec, heardSec)
+    });
+    this._replyTrace = null;
+  }
   _voipWsCanSend() {
     return !this.stopCalled && this.ws && this.ws.readyState === ws__default["default"].OPEN;
   }
@@ -1318,6 +2195,8 @@ class BotiumConnectorVoip {
       if (typeof this._emitBufferedFullRecordIfAny === 'function') {
         this._emitBufferedFullRecordIfAny('stop_final_guard');
       }
+      // Last-resort flush in case neither audioStreamEnd nor fullRecordEnd fired.
+      this._flushPendingTurnAudio('stop_final_guard');
     }
     this._emitBufferedFullRecordIfAny = null;
   }
@@ -1627,6 +2506,21 @@ class BotiumConnectorVoip {
     if (!lodash__default["default"].isFinite(parsed) || parsed <= 0) return null;
     return isPsst ? Math.max(0, parsed - 500) : parsed;
   }
+
+  // Extra grace (ms) added to the JOIN/PSST flush window when the last buffered final was cut
+  // mid-utterance. Returns 0 when unset/invalid (feature off). See _isLastFinalNaturalEnd.
+  _getPsstLatencyGraceMs() {
+    const parsed = parseInt(this.caps[Capabilities.VOIP_STT_MESSAGE_HANDLING_LATENCY_GRACE_MS], 10);
+    if (!lodash__default["default"].isFinite(parsed) || parsed <= 0) return 0;
+    return parsed;
+  }
+
+  // A final that carries a finite silenceStartedSec ended on Azure-detected end-of-speech silence
+  // (bot genuinely stopped) => flush at the base window, no grace. A final without it was cut
+  // mid-utterance (forced/segmented) => a continuation is plausible => apply the latency grace.
+  _isLastFinalNaturalEnd() {
+    return lodash__default["default"].isFinite(lodash__default["default"].get(this.prevData, 'data.silenceStartedSec'));
+  }
   _getEffectiveJoinTimeoutMs(convoStep, botMsgs) {
     const sttHandling = this.caps[Capabilities.VOIP_STT_MESSAGE_HANDLING];
     const isPsst = sttHandling === 'PSST';
@@ -1662,6 +2556,100 @@ class BotiumConnectorVoip {
     }
     return null;
   }
+
+  /**
+   * Build a well-formed WAV Buffer from raw PCM bytes and a format descriptor.
+   * @param {Buffer} pcm   raw PCM bytes (no header)
+   * @param {{ sampleRate: number, channels: number, bitsPerSample: number }} fmt
+   * @returns {Buffer}
+   */
+  _buildWavBuffer(pcm, fmt) {
+    const {
+      sampleRate,
+      channels,
+      bitsPerSample
+    } = fmt;
+    const byteRate = sampleRate * channels * (bitsPerSample / 8);
+    const blockAlign = channels * (bitsPerSample / 8);
+    const dataSize = pcm.length;
+    const header = Buffer.alloc(44);
+    header.write('RIFF', 0);
+    header.writeUInt32LE(36 + dataSize, 4);
+    header.write('WAVE', 8);
+    header.write('fmt ', 12);
+    header.writeUInt32LE(16, 16); // fmt chunk size
+    header.writeUInt16LE(1, 20); // PCM format
+    header.writeUInt16LE(channels, 22);
+    header.writeUInt32LE(sampleRate, 24);
+    header.writeUInt32LE(byteRate, 28);
+    header.writeUInt16LE(blockAlign, 32);
+    header.writeUInt16LE(bitsPerSample, 34);
+    header.write('data', 36);
+    header.writeUInt32LE(dataSize, 40);
+    return Buffer.concat([header, pcm]);
+  }
+
+  /**
+   * Slice a segment of the continuously buffered PCM audio stream and return
+   * it as a base64-encoded WAV string.
+   *
+   * @param {number} startSec  start of the segment (seconds from call connect)
+   * @param {number} endSec    end of the segment (seconds from call connect)
+   * @returns {string|null}    base64 WAV or null if the stream is not ready
+   */
+  _sliceTurnAudio(startSec, endSec) {
+    const stream = this.audioStream;
+    if (!stream || !stream.format || !stream.pcmParts || !stream.pcmParts.length) return null;
+    if (!lodash__default["default"].isFinite(startSec) || !lodash__default["default"].isFinite(endSec) || endSec <= startSec) return null;
+    const {
+      sampleRate,
+      channels,
+      bitsPerSample
+    } = stream.format;
+    const bytesPerSec = sampleRate * channels * (bitsPerSample / 8);
+    const frameBytes = channels * (bitsPerSample / 8);
+    const offsetSec = (this.caps[Capabilities.VOIP_TURN_AUDIO_OFFSET_MS] || 0) / 1000;
+    const paddingSec = (this.caps[Capabilities.VOIP_TURN_AUDIO_PADDING_MS] || 0) / 1000;
+    const adjStart = Math.max(0, startSec + offsetSec);
+    const adjEnd = endSec + paddingSec;
+
+    // Frame-align the byte boundaries.
+    const startByte = Math.floor(adjStart * bytesPerSec / frameBytes) * frameBytes;
+    const endByte = Math.ceil(adjEnd * bytesPerSec / frameBytes) * frameBytes;
+    if (startByte >= stream.totalBytes) {
+      debug$3(`${this.sessionId} - _sliceTurnAudio: startByte ${startByte} >= totalBytes ${stream.totalBytes}, skipping`);
+      return null;
+    }
+    const clampedEnd = Math.min(endByte, stream.totalBytes);
+    const sliceLen = clampedEnd - startByte;
+    if (sliceLen <= 0) return null;
+
+    // Materialise only the bytes we need from the part list.
+    const pcm = Buffer.allocUnsafe(sliceLen);
+    let written = 0;
+    let offset = 0;
+    for (const part of stream.pcmParts) {
+      const partEnd = offset + part.length;
+      if (partEnd <= startByte) {
+        offset += part.length;
+        continue;
+      }
+      if (offset >= clampedEnd) break;
+      const copyFrom = Math.max(0, startByte - offset);
+      const copyTo = Math.min(part.length, clampedEnd - offset);
+      part.copy(pcm, written, copyFrom, copyTo);
+      written += copyTo - copyFrom;
+      offset += part.length;
+    }
+    if (written === 0) return null;
+    const slicedPcm = written < sliceLen ? pcm.slice(0, written) : pcm;
+    const wavBuf = this._buildWavBuffer(slicedPcm, {
+      sampleRate,
+      channels,
+      bitsPerSample
+    });
+    return wavBuf.toString('base64');
+  }
 }
 var connector = BotiumConnectorVoip;
 
@@ -1745,6 +2733,24 @@ var botiumConnectorVoip = {
       type: 'boolean',
       required: false,
       advanced: true
+    }, {
+      name: 'VOIP_TURN_AUDIO_ENABLE',
+      label: 'Attach per-turn audio to each transcript message',
+      type: 'boolean',
+      required: false,
+      advanced: true
+    }, {
+      name: 'VOIP_TURN_AUDIO_PADDING_MS',
+      label: 'Extra milliseconds appended after each turn audio slice (absorbs STT boundary jitter)',
+      type: 'int',
+      required: false,
+      advanced: true
+    }, {
+      name: 'VOIP_TURN_AUDIO_OFFSET_MS',
+      label: 'Millisecond offset applied to every turn audio start time (positive = shift right)',
+      type: 'int',
+      required: false,
+      advanced: true
     }]
   },
   PluginLogicHooks: {