fix(capture): pass the measured 800ms inactivity window to the transport sensor

The sensor's own default is 400 ms — chosen to span a packet gap, not a speech
pause. Measured entry-timestamp staleness during real pauses is p50 550 ms, so
the MEDIAN natural pause already trips a synthesized deactivation and one speech
phase fragments. Re-measured against the current channelizer (5 x 30 min seeded
tapes): 400 ms gives 1.67 lane activations per real turn, 800 ms gives 1.13 —
the knee — for 1.8 pp more contamination; 1600 ms starts merging turns.

The value was raised once before and lost in the re-platform. It comes back as a
PARAMETER at the composition root, not as a forked constant in the sensor: the
sensor already exposes `inactiveMs`, and forking its file a second time is how
this was lost. Overridable via VEXA_CSRC_INACTIVE_MS.

Scope: this fixes fragmentation, not lane contamination — no value of
inactiveMs, lookbackMs or flickerHoldMs brings contamination into a usable range.

Closes #150
Refs #110, #103, #138

Signed-off-by: Jacob Weinhold <jacob@philflow.io>

Author: Jacob Weinhold

core/meetings/modules/mixed-capture-core/src/csrc-poll.test.ts

@@ -85,7 +85,11 @@ const receiver = (sources: () => ContributingSourceLike[]) => ({
   check('past inactiveMs the deactivation is SYNTHESIZED (the transport never sends this edge)',
     out.length === 2 && out[1].active === false && out[1].csrc === 7 && out[1].tMs === t,
     JSON.stringify(out));
-  check('the default inactivity window is 400ms', CSRC_INACTIVE_MS === 400);
+  // The module's own default spans a PACKET gap (jitter, DTX), not a speech PAUSE. It is only a
+  // default: the measured production window is longer and is passed in by the composition root
+  // (#150), so what this file owns is the SEAM, not the number production runs on.
+  check('the built-in window is the packet-gap default, and nothing more than a default',
+    CSRC_INACTIVE_MS === 400);
 
   // Speaking again is a NEW activation — turns are edges, not a level.
   speaking = true; lastSpoke = t; poll.poll();
@@ -100,6 +104,33 @@ const receiver = (sources: () => ContributingSourceLike[]) => ({
   check('a poll after destroy() emits nothing', out.length === after);
 }
 
+// ── the inactivity window is a PARAMETER, not a constant ─────────────────────────────────
+// A caller with a MEASURED window must be able to hand it over instead of forking this file. That
+// seam is what #150 turns on: a second fork is how the measured 800 ms was lost the first time.
+{
+  let t = 1_900_000_000_000;
+  const out: CsrcTransition[] = [];
+  let speaking = true;
+  let lastSpoke = t;
+  const poll = createCsrcPoll({
+    onTransition: (x) => out.push(x),
+    now: () => t,
+    timeOrigin: () => 0,
+    inactiveMs: 800,
+    receivers: () => [receiver(() => [{ source: 9, timestamp: speaking ? t : lastSpoke, audioLevel: 0.4 }])],
+  });
+  poll.poll();
+  check('override: the source opens a turn', out.length === 1 && out[0].active === true, JSON.stringify(out));
+  speaking = false;
+  t += 500; poll.poll();
+  check('override: 500ms of silence — past the 400ms default, inside the caller\'s 800ms — holds the turn OPEN',
+    out.length === 1, JSON.stringify(out));
+  t += 400; poll.poll();   // 900ms > 800ms
+  check('override: past the caller\'s window the deactivation is synthesized',
+    out.length === 2 && out[1].active === false, JSON.stringify(out));
+  poll.destroy();
+}
+
 // ── two concurrent sources ──────────────────────────────────────────────────────────────────────
 {
   let t = 1_900_000_000_000;

core/meetings/services/bot/src/capture-bridge.ts

@@ -381,6 +381,24 @@ const TEAMS_ENABLE_CAPTIONS = process.env.VEXA_TEAMS_ENABLE_CAPTIONS === '1';
 /** How many times to try the menu path before giving up (each attempt is ~3 s of UI waits). */
 const TEAMS_ENABLE_CAPTIONS_ATTEMPTS = Math.max(1, Number(process.env.VEXA_TEAMS_ENABLE_CAPTIONS_ATTEMPTS || 3));
 
+/**
+ * How long the transport sensor holds a source active after its last observed contribution.
+ *
+ * The sensor's own default is 400 ms (`CSRC_INACTIVE_MS` in @vexa/mixed-capture-core) — a value
+ * chosen to span a packet gap. Measured against real speech it is too short to span a PAUSE:
+ * entry-timestamp staleness during natural pauses came out at p50 550 ms, so the MEDIAN pause
+ * already trips a synthesized deactivation and one speech phase fragments into splinters. Re-measured
+ * against the current channelizer (5 × 30 min seeded tapes): 400 ms yields 1.67 lane activations per
+ * real turn (67 % over-splitting), 800 ms yields 1.13 — the knee — for 1.8 pp more contamination;
+ * 1600 ms starts merging distinct turns. So the production window is 800 ms.
+ *
+ * It lives HERE, at the composition root, and not as a forked constant in the sensor: the sensor
+ * already exposes `inactiveMs` as a parameter, and forking its file a second time is exactly how
+ * this value was lost once before (#150). Overridable per deployment — and therefore per platform,
+ * since each platform's bot is its own process — via VEXA_CSRC_INACTIVE_MS.
+ */
+const CSRC_INACTIVE_MS = Math.max(1, Number(process.env.VEXA_CSRC_INACTIVE_MS || 800));
+
 /** Outcome of one enable attempt. `already-on` and `clicked` are successes; `failed` carries WHY,
  *  because "captions never appeared" has two very different causes — the menu path changed, or the
  *  tenant blocks captions — and only the reason distinguishes them on the first live run. */
@@ -796,7 +814,7 @@ export async function startCaptureBridge(
   // ── Start the page-side capture (VexaBrowserUtils preferred; production inline fallback). ──
   // The body of this callback runs IN THE BROWSER (Playwright serializes it); DOM globals are
   // reached via globalThis (this file type-checks against the Node lib — no DOM types here).
-  await page.evaluate(async ({ isMixed, isPerTrack, isJitsi, isTeams, isZoom, botName, mainAudioGraceMs, mainAudioSilenceMs, mainAudioEnergyRms }) => {
+  await page.evaluate(async ({ isMixed, isPerTrack, isJitsi, isTeams, isZoom, botName, mainAudioGraceMs, mainAudioSilenceMs, mainAudioEnergyRms, csrcInactiveMs }) => {
     const w = (globalThis as any) as Record<string, any>;
     if (isMixed) {
       // Zoom/Teams/Jitsi ride the WebRTC hook (installRemoteAudioHook, installed pre-nav), which mirrors
@@ -1159,6 +1177,9 @@ export async function startCaptureBridge(
               w.logBot?.('[Csrc] observation ' + JSON.stringify(o));
               w.__vexaObservation?.('csrc', o, Date.now());
             },
+            // The MEASURED pause window, passed in rather than defaulted: the sensor's own 400 ms
+            // is shorter than the median natural speech pause (p50 550 ms) and fragments a turn.
+            inactiveMs: csrcInactiveMs,
             log: (m: string) => w.logBot?.('[Csrc] ' + m),
           });
         } catch (e: any) {
@@ -1287,7 +1308,9 @@ export async function startCaptureBridge(
       mainAudioGraceMs: Number(process.env.VEXA_TEAMS_MAIN_AUDIO_GRACE_MS || 15000),
       // How long a PICKED mix may stay wholly silent before the lane abandons it for every track.
       mainAudioSilenceMs: Number(process.env.VEXA_TEAMS_MAIN_AUDIO_SILENCE_MS || 20000),
-      mainAudioEnergyRms: Number(process.env.VEXA_TEAMS_MAIN_AUDIO_ENERGY_RMS || 0.006) }).catch((e) => {
+      mainAudioEnergyRms: Number(process.env.VEXA_TEAMS_MAIN_AUDIO_ENERGY_RMS || 0.006),
+      // The measured inactivity window (#150) — a parameter the sensor accepts, never a fork of it.
+      csrcInactiveMs: CSRC_INACTIVE_MS }).catch((e) => {
     console.error(`[bot] capture bridge: page-side start failed: ${String(e)}`); // L4: surfaces only on the VM
   });
 

core/meetings/services/bot/src/csrc-wiring.test.ts

@@ -138,6 +138,19 @@ const utils = g.VexaBrowserUtils as Record<string, unknown> | undefined;
 check('bundle: window.VexaBrowserUtils.createCsrcPoll is exported (RED at base — brick not bundled)',
   typeof utils?.createCsrcPoll === 'function', `keys: ${Object.keys(utils ?? {}).join(',')}`);
 
+// Capture the options the REAL bridge hands the REAL sensor factory. The window the production
+// path runs on is not observable from a transition alone (only from WHEN one is absent), and the
+// number itself is owned by the composition root, not by the sensor — so it is asserted here, on
+// the object that actually crosses. RED before #150: the bridge passed no `inactiveMs` at all.
+type CsrcPollOpts = { inactiveMs?: number; pollMs?: number; now?: () => number; timeOrigin?: () => number;
+  receivers?: () => unknown[]; onTransition: (t: { csrc: number; active: boolean; tMs: number }) => void };
+const realCreateCsrcPoll = utils!.createCsrcPoll as (o: CsrcPollOpts) => unknown;
+let productionCsrcOpts: CsrcPollOpts | undefined;
+(utils as Record<string, unknown>).createCsrcPoll = (o: CsrcPollOpts): unknown => {
+  productionCsrcOpts = o;
+  return realCreateCsrcPoll(o);
+};
+
 // ── Fake Playwright Page + the Node seams ───────────────────────────────────────────────────────
 const page = {
   async exposeFunction(name: string, fn: unknown): Promise<void> { g[name] = fn; },
@@ -213,6 +226,38 @@ check('the spine and the stored sidecar agree on WHEN each edge happened',
 check('isolation: NO transition reached pipeline.recordHint — a csrc is an id, never a name',
   hints.length === 0, JSON.stringify(hints));
 
+// ── the MEASURED inactivity window reaches the sensor (#150) ────────────────────────────────────
+// 400 ms — the sensor's own default — is shorter than the median natural speech pause (measured
+// p50 550 ms), so a turn fragments into 1.67 lane activations. The composition root passes the
+// measured 800 ms instead. Asserted twice: the value that crossed, and what that value DOES.
+check('the bridge passes an explicit inactivity window to the sensor (RED at base: undefined)',
+  productionCsrcOpts?.inactiveMs === 800, `inactiveMs=${String(productionCsrcOpts?.inactiveMs)}`);
+{
+  // Re-drive the sensor over the PRODUCTION options object — same `inactiveMs`, with only the
+  // clock and the receivers replaced, so the window is proven by behaviour and not by a number.
+  let t = 1_900_000_000_000;
+  const edges: Array<{ active: boolean }> = [];
+  let speaking = true;
+  let lastSpoke = t;
+  const poll = realCreateCsrcPoll({
+    ...productionCsrcOpts!,
+    onTransition: (x) => edges.push({ active: x.active }),
+    now: () => t,
+    timeOrigin: () => 0,
+    receivers: () => [{ track: { kind: 'audio' },
+      getContributingSources: () => [{ source: 5, timestamp: speaking ? t : lastSpoke, audioLevel: 0.4 }] }],
+  }) as { poll(): void; destroy(): void };
+  poll.poll();
+  speaking = false;
+  t += 500; poll.poll();
+  check('a 500ms pause — past the sensor default, inside the measured window — does NOT close the turn',
+    edges.length === 1 && edges[0].active === true, JSON.stringify(edges));
+  t += 400; poll.poll();
+  check('past the measured window the deactivation is synthesized',
+    edges.length === 2 && edges[1].active === false, JSON.stringify(edges));
+  poll.destroy();
+}
+
 (g as any).setInterval = realSetInterval;
 (g as any).clearInterval = realClearInterval;
 g.document = savedDocument;