switchroom 0.18.31 → 0.18.33

package/telegram-plugin/tests/emission-authority-facade.test.ts

@@ -48,6 +48,39 @@ const gatewaySrc = readFileSync(
   resolve(__dirname, '..', 'gateway', 'gateway.ts'),
   'utf-8',
 )
+// #2996 P2: executeReply's body (the over-ping block + the lever-2 finalize)
+// moved VERBATIM to outbound-send-path.ts `sendReply()`. The façade call-site
+// assertions that used to grep the executeReply window grep the sendReply
+// window there instead — the wiring contract they pin is unchanged.
+const sendPathSrc = readFileSync(
+  resolve(__dirname, '..', 'gateway', 'outbound-send-path.ts'),
+  'utf-8',
+)
+// #2996 P4-A: `handleSessionEvent`'s body (the tool_label / sub-agent drains
+// and their `ea.mayDrain(turn)` single-flight guards) moved VERBATIM to
+// stream-render.ts. Drain-site assertions that grep for the full population of
+// façade call sites therefore scan gateway.ts + stream-render.ts combined —
+// the wiring contract they pin is unchanged, only its file home split.
+const streamRenderSrc = readFileSync(
+  resolve(__dirname, '..', 'gateway', 'stream-render.ts'),
+  'utf-8',
+)
+// #2996 P4-B: the narrative/activity lane (showNarrativeStep,
+// openLivenessFeedIfDue, feedHeartbeatTick, drainActivitySummary,
+// clearActivitySummary + the cardDrainGate-wrapped drains inside them) moved
+// VERBATIM into narrative-lane.ts (factory scope, bodies indented +2).
+// gateway.ts keeps thin same-name wrappers, so lane-body assertions must read
+// the MODULE source, not the wrapper.
+const laneSrc = readFileSync(
+  resolve(__dirname, '..', 'gateway', 'narrative-lane.ts'),
+  'utf-8',
+)
+const gatewayAndStreamSrc = gatewaySrc + '\n' + streamRenderSrc + '\n' + laneSrc
+/** The sendReply window: from the function decl to the next export. */
+function sendReplyWindow(): string {
+  const after = sendPathSrc.split('export async function sendReply(')[1] ?? ''
+  return after.split('\nexport ')[0] ?? after
+}
 
 /** Source of a named gateway function up to the next top-level definition. */
 function fnSrc(name: string): string {
@@ -55,6 +88,13 @@ function fnSrc(name: string): string {
   return after.split('\nasync function ')[0]?.split('\nfunction ')[0] ?? after
 }
 
+/** Source of a named narrative-lane function (factory scope, indented +2) up
+ *  to the next lane function definition (#2996 P4-B). */
+function laneFnSrc(name: string): string {
+  const after = laneSrc.split(`function ${name}(`)[1] ?? ''
+  return after.split('\n  async function ')[0]?.split('\n  function ')[0] ?? after
+}
+
 describe('SWITCHROOM_EMISSION_AUTHORITY kill-switch (default OFF)', () => {
   it('parses with `=== "1"` semantic so an unset env var is OFF (default off)', () => {
     expect(facadeSrc).toMatch(
@@ -243,15 +283,15 @@ describe('claimOrDowngradePing — PR-4c over-ping decision moves into the faça
     // The relocation must NOT split the #2562 pair across the façade boundary:
     // the façade decides; the call-site thunk sets firstPingAt AND
     // firstPingWasSubstantive on two adjacent lines, no await between.
-    expect(gatewaySrc).toMatch(
+    expect(sendPathSrc).toMatch(
       /turn\.firstPingAt = now\s*\n\s*turn\.firstPingWasSubstantive = replySubstantive/,
     )
     // No await anywhere in the executeReply over-ping block (the decide→apply→
     // pair-set synchronous chain). Bound to the block, BEFORE the Telegraph
     // block below (which legitimately awaits).
-    const blockStart = gatewaySrc.indexOf('const applyOverPingDecision')
-    const telegraphIdx = gatewaySrc.indexOf('// Telegraph publish (#579)', blockStart)
-    const block = gatewaySrc.slice(blockStart, telegraphIdx)
+    const blockStart = sendPathSrc.indexOf('const applyOverPingDecision')
+    const telegraphIdx = sendPathSrc.indexOf('// Telegraph publish (#579)', blockStart)
+    const block = sendPathSrc.slice(blockStart, telegraphIdx)
     const blockCode = block
       .split('\n')
       .filter((l) => {
@@ -267,17 +307,14 @@ describe('claimOrDowngradePing — PR-4c over-ping decision moves into the faça
     // The over-ping net exists ONLY in executeReply. The retired stream_reply
     // tool (executeStreamReply) had no decideOverPing / firstPingAt /
     // wasOverPingSuppressed and never called claimOrDowngradePing.
-    const calls = [...gatewaySrc.matchAll(/\.claimOrDowngradePing\(/g)]
+    // #2996 P2: the single call now lives in the extracted sendReply body;
+    // gateway.ts must have ZERO (the wrapper delegates).
+    const gwCalls = [...gatewaySrc.matchAll(/\.claimOrDowngradePing\(/g)]
+    expect(gwCalls).toHaveLength(0)
+    const calls = [...sendPathSrc.matchAll(/\.claimOrDowngradePing\(/g)]
     expect(calls).toHaveLength(1)
-    const callIdx = gatewaySrc.indexOf('.claimOrDowngradePing(')
-    const execReplyIdx = gatewaySrc.indexOf('async function executeReply(')
-    // Upper bound: the next top-level function after executeReply.
-    const nextFnIdx = gatewaySrc.indexOf('\nasync function ', execReplyIdx + 1)
-    expect(execReplyIdx).toBeGreaterThan(-1)
-    expect(nextFnIdx).toBeGreaterThan(execReplyIdx)
-    // The single call is inside executeReply.
-    expect(callIdx).toBeGreaterThan(execReplyIdx)
-    expect(callIdx).toBeLessThan(nextFnIdx)
+    // The single call is inside the sendReply window.
+    expect(sendReplyWindow()).toMatch(/\.claimOrDowngradePing\(/)
   })
 })
 
@@ -299,7 +336,8 @@ describe('façade delegates to the existing emission primitives (call-site liter
   it('finalizeCard wraps clearActivitySummary at the call sites (not CALLED inside the façade)', () => {
     expect(facadeSrc).not.toMatch(/import .*clearActivitySummary/)
     expect(facadeCode).not.toMatch(/clearActivitySummary\(/)
-    expect(gatewaySrc).toMatch(/finalizeCard\(\(\) => \{\s*\n\s*clearActivitySummary\(/)
+    // #2996 P2: the lever-2 call site moved (verbatim) into sendReply.
+    expect(sendPathSrc).toMatch(/finalizeCard\(\(\) => \{\s*\n\s*clearActivitySummary\(/)
   })
 
   it('claimOrDowngradePing — the call-site disabled thunk STILL contains a literal decideOverPing( (disabled-path proof)', () => {
@@ -308,16 +346,16 @@ describe('façade delegates to the existing emission primitives (call-site liter
     // its OWN literal `decideOverPing(` call inside the call-site thunk, VERBATIM
     // from PR-4b-base — so the disabled path is provably byte-identical (never
     // depends on the façade for the decision).
-    const pingIdx = gatewaySrc.indexOf('claimOrDowngradePing(')
+    const pingIdx = sendPathSrc.indexOf('claimOrDowngradePing(')
     expect(pingIdx).toBeGreaterThan(-1)
-    const window = gatewaySrc.slice(pingIdx, pingIdx + 1600)
+    const window = sendPathSrc.slice(pingIdx, pingIdx + 1600)
     expect(window).toMatch(/decideOverPing\(/)
   })
 })
 
 describe('the drain sites route through the façade with producers preserved verbatim', () => {
   it('the narrative SHOW site routes via openOrEditCard("narrative") + the producer-"narrative" drain', () => {
-    const body = fnSrc('showNarrativeStep')
+    const body = laneFnSrc('showNarrativeStep')
     expect(body).toMatch(/openOrEditCard\('narrative'/)
     // The drain literal (producer arg verbatim) is preserved in the delegate.
     expect(body).toMatch(/drainActivitySummary\(turn,\s*'narrative'\)/)
@@ -337,8 +375,8 @@ describe('the drain sites route through the façade with producers preserved ver
     //   - feedHeartbeatTick:     the 0-label CLIMB of an already-open card
     //                            (Phase 1) + the labelled-feed stale-step maintain.
     // All must still route via the façade with the producer arg verbatim.
-    const earlyOpen = fnSrc('openLivenessFeedIfDue')
-    const heartbeat = fnSrc('feedHeartbeatTick')
+    const earlyOpen = laneFnSrc('openLivenessFeedIfDue')
+    const heartbeat = laneFnSrc('feedHeartbeatTick')
     const opens = [
       ...earlyOpen.matchAll(/openOrEditCard\('liveness'/g),
       ...heartbeat.matchAll(/openOrEditCard\('liveness'/g),
@@ -361,15 +399,20 @@ describe('the drain sites route through the façade with producers preserved ver
   it('both foreground sub-agent drains route via openOrEditCard("tool") with producer made EXPLICIT', () => {
     // Previously these called drainActivitySummary(turn) with the implicit
     // 'tool' default; PR-4a makes 'tool' explicit at both, per the plan.
-    const opens = [...gatewaySrc.matchAll(/ea\.openOrEditCard\('tool', \(\) => \{\s*\n\s*turn\.activityInFlight = drainActivitySummary\(turn, 'tool'\)/g)]
+    // #2996 P4-A: these sites now live in stream-render.ts (tool_label + the
+    // sub-agent drains moved with handleSessionEvent), so scan the combined src.
+    const opens = [...gatewayAndStreamSrc.matchAll(/ea\.openOrEditCard\('tool', \(\) => \{\s*\n\s*turn\.activityInFlight = drainActivitySummary\(turn, 'tool'\)/g)]
     // tool_label site (1) + the two sub-agent drains (2) = 3 'tool' openers.
     expect(opens.length).toBeGreaterThanOrEqual(3)
     // No foreground drain still uses the bare implicit-producer form.
-    expect(gatewaySrc).not.toMatch(/turn\.activityInFlight = drainActivitySummary\(turn\)\n/)
+    expect(gatewayAndStreamSrc).not.toMatch(/turn\.activityInFlight = drainActivitySummary\(turn\)\n/)
   })
 
   it('every routed drain site guards the single-flight via ea.mayDrain(turn), not a bare activityInFlight read', () => {
-    const mayDrainGuards = [...gatewaySrc.matchAll(/if \(ea\.mayDrain\(turn\)\)/g)]
+    // #2996 P4-A: the tool / sub-agent / post-answer bg-liveness guards moved
+    // to stream-render.ts with handleSessionEvent; the narrative + liveness
+    // guards stay in gateway.ts. The full population (8) spans both files.
+    const mayDrainGuards = [...gatewayAndStreamSrc.matchAll(/if \(ea\.mayDrain\(turn\)\)/g)]
     // narrative SHOW + narrative RETRACT (timer-flush early-paint retract,
     // narrative-flush.ts) + 2 liveness + tool + 2 sub-agent + 1 post-answer
     // bg-liveness (Fix 2) = 8. The Phase-1 0-label climb
@@ -379,14 +422,13 @@ describe('the drain sites route through the façade with producers preserved ver
     // gateway call site — pinned by feed-heartbeat-liveness-open.test.ts +
     // silent-turn-climb-transport.test.ts.
     expect(mayDrainGuards).toHaveLength(8)
-    expect(gatewaySrc).toMatch(/mayDrain:\s*\(\)\s*=>\s*ea\.mayDrain\(turn\)/)
+    expect(gatewayAndStreamSrc).toMatch(/mayDrain:\s*\(\)\s*=>\s*ea\.mayDrain\(turn\)/)
   })
 })
 
 describe('the lever-2 finalize block routes through the façade', () => {
   it('executeReply finalize routes via markSubstantiveFinalDelivered + finalizeCard (latch + clear preserved)', () => {
-    const after = gatewaySrc.split('async function executeReply(')[1] ?? ''
-    const body = after.split('\nasync function ')[0]?.split('\nfunction ')[0] ?? after
+    const body = sendReplyWindow()
     expect(body).toMatch(/markSubstantiveFinalDelivered\(\(\) => \{\s*\n\s*finalizeTurn\.finalAnswerEverDelivered = true/)
     expect(body).toMatch(/finalizeCard\(\(\) => \{\s*\n\s*clearActivitySummary\(finalizeTurn\)/)
   })
@@ -396,7 +438,9 @@ describe('per-turn construction — one façade per turn, explicit chat/thread k
   it('the turn ctor constructs a fresh EmissionAuthority with the explicit statusKey', () => {
     // Per-turn: born in the CurrentTurn object literal so it is discarded with
     // the turn and never persists across turns.
-    expect(gatewaySrc).toMatch(/emissionAuthority: new EmissionAuthority\(\s*\n\s*statusKey\(/)
+    // #2996 P4-A: the turn ctor lives in handleSessionEvent's `enqueue` branch,
+    // which moved to stream-render.ts.
+    expect(gatewayAndStreamSrc).toMatch(/emissionAuthority: new EmissionAuthority\(\s*\n\s*statusKey\(/)
   })
 
   it('the façade constructor takes the chat/thread key EXPLICITLY (the PR-4e map seam)', () => {
@@ -504,12 +548,15 @@ describe('mayDrainCardNow — PR-4d card-drain gate (pure read; gateway holds th
     // thunks stay byte-identical, wrapped by the centralized helper.
     // 6 original + 1 post-answer background-agent liveness drain (Fix 2) + 1
     // narrative-retract drain (timer-flush early-paint retract, narrative-flush.ts).
-    const wraps = [...gatewaySrc.matchAll(/cardDrainGate\(turn, ea, \(\) => \{/g)]
+    // #2996 P4-A: one of these guarded drains (the post-answer bg-liveness
+    // drain) moved to stream-render.ts with handleSessionEvent; the population
+    // of 8 now spans gateway.ts + stream-render.ts.
+    const wraps = [...gatewayAndStreamSrc.matchAll(/cardDrainGate\(turn, ea, \(\) => \{/g)]
     expect(wraps).toHaveLength(8)
     // The Phase-1 0-label climb (deterministic-turn-liveness.md) routes through
     // the SAME helper via an injected thunk — its call lives in the extracted
     // tick body (feed-heartbeat-climb.ts), wired at the gateway call site as
     // `cardDrainGate: (run) => cardDrainGate(turn, ea, run)`.
-    expect(gatewaySrc).toMatch(/cardDrainGate:\s*\(run\)\s*=>\s*cardDrainGate\(turn, ea, run\)/)
+    expect(gatewayAndStreamSrc).toMatch(/cardDrainGate:\s*\(run\)\s*=>\s*cardDrainGate\(turn, ea, run\)/)
   })
 })

package/telegram-plugin/tests/emission-authority-ping-gate.test.ts

@@ -354,8 +354,11 @@ describe('claimOrDowngradePing — no await in the synchronous decide→apply→
     resolve(__dirname, '..', 'gateway', 'emission-authority.ts'),
     'utf-8',
   )
+  // #2996 P2: the over-ping call site moved VERBATIM (with executeReply's
+  // body) into outbound-send-path.ts `sendReply()`; the await-free window
+  // assertion reads there. Contract unchanged.
   const gatewaySrc = readFileSync(
-    resolve(__dirname, '..', 'gateway', 'gateway.ts'),
+    resolve(__dirname, '..', 'gateway', 'outbound-send-path.ts'),
     'utf-8',
   )
 

package/telegram-plugin/tests/emission-determinism-wiring.test.ts

@@ -17,25 +17,50 @@ const gatewaySrc = readFileSync(
   resolve(__dirname, '..', 'gateway', 'gateway.ts'),
   'utf-8',
 )
+// #2996 P2: executeReply's body (incl. the lever-2 finalize + the latch sets)
+// moved VERBATIM to outbound-send-path.ts `sendReply()`; the assertions that
+// pinned that body now read it there. The wiring contract is unchanged.
+const sendPathSrc = readFileSync(
+  resolve(__dirname, '..', 'gateway', 'outbound-send-path.ts'),
+  'utf-8',
+)
+// #2996 P4-A: the per-turn CurrentTurn object literal (which initialises the
+// sticky `finalAnswerEverDelivered: false` latch) is constructed in
+// handleSessionEvent's `enqueue` branch, which moved VERBATIM to
+// stream-render.ts. The init-latch assertions scan gateway.ts + that module.
+const streamSrc = readFileSync(
+  resolve(__dirname, '..', 'gateway', 'stream-render.ts'),
+  'utf-8',
+)
+// #2996 P4-B: the narrative/activity lane (drainActivitySummary,
+// showNarrativeStep, feedHeartbeatTick, clearActivitySummary) moved VERBATIM
+// into narrative-lane.ts (factory scope, bodies indented +2); gateway keeps
+// thin same-name wrappers. Lane-body windows read the module source.
+const laneSrc = readFileSync(
+  resolve(__dirname, '..', 'gateway', 'narrative-lane.ts'),
+  'utf-8',
+)
+const gatewayAndStreamSrc = gatewaySrc + '\n' + streamSrc + '\n' + laneSrc
 
 /** Source of `drainActivitySummary` up to the next top-level function. */
 function drainSrc(): string {
-  const after = gatewaySrc.split('async function drainActivitySummary(')[1] ?? ''
-  return after.split('\nasync function ')[0]?.split('\nfunction ')[0] ?? after
+  // #2996 P4-B: reads the lane module (factory scope — next fn at 2-space indent).
+  const after = laneSrc.split('async function drainActivitySummary(')[1] ?? ''
+  return after.split('\n  async function ')[0]?.split('\n  function ')[0] ?? after
 }
 
 describe('sticky finalAnswerEverDelivered latch (lever 1 precondition / R0)', () => {
   it('is initialised false in the turn object literal (per-turn reset at turn start)', () => {
-    expect(gatewaySrc).toMatch(/finalAnswerEverDelivered:\s*false/)
+    expect(gatewayAndStreamSrc).toMatch(/finalAnswerEverDelivered:\s*false/)
   })
 
   it('is reset to false in exactly ONE place — the turn initialiser (never cleared by reopen)', () => {
     // Mirrors activityEverOpened's sticky-true contract: the only `false` is the
     // per-turn init. A standalone `= false` reassignment would let reopen clear
     // the latch and reintroduce the reorder (the R0 correction).
-    const initFalse = [...gatewaySrc.matchAll(/finalAnswerEverDelivered:\s*false/g)]
+    const initFalse = [...gatewayAndStreamSrc.matchAll(/finalAnswerEverDelivered:\s*false/g)]
     expect(initFalse).toHaveLength(1)
-    const resetFalse = [...gatewaySrc.matchAll(/finalAnswerEverDelivered\s*=\s*false/g)]
+    const resetFalse = [...gatewayAndStreamSrc.matchAll(/finalAnswerEverDelivered\s*=\s*false/g)]
     expect(resetFalse).toHaveLength(0)
   })
 
@@ -51,20 +76,23 @@ describe('sticky finalAnswerEverDelivered latch (lever 1 precondition / R0)', ()
   it('every site that sets the sticky latch true gates on finalAnswerSubstantive', () => {
     // The latch is set true only at the points that set finalAnswerDelivered=true,
     // and only when the reply was substantive — so an ack never latches it.
-    const setTrue = [...gatewaySrc.matchAll(/finalAnswerEverDelivered\s*=\s*true/g)]
-    // executeReply, silent-anchor merge, + the lever-2 finalize block
+    // #2996 P2: all three latch-set sites live in the extracted sendReply body.
+    const setTrue = [...sendPathSrc.matchAll(/finalAnswerEverDelivered\s*=\s*true/g)]
+    // sendReply post-send, silent-anchor merge, + the lever-2 finalize block
     // (which is itself substantive-gated).
     expect(setTrue.length).toBeGreaterThanOrEqual(3)
+    // And gateway.ts has none left (the wrapper delegates).
+    expect(gatewaySrc).not.toMatch(/finalAnswerEverDelivered\s*=\s*true/)
     // Each `finalAnswerEverDelivered = true` must sit in a substantive context:
     // either guarded by `if (turn.finalAnswerSubstantive)` or inside an
     // `isSubstantiveFinalReply(...)` branch. Assert the substantive-gating
     // token co-occurs (no bare unconditional latch set).
     const bareUnconditional = [
-      ...gatewaySrc.matchAll(/\n\s*(?:turn|finalizeTurn)\.finalAnswerEverDelivered\s*=\s*true/g),
+      ...sendPathSrc.matchAll(/\n\s*(?:turn|finalizeTurn)\.finalAnswerEverDelivered\s*=\s*true/g),
     ]
     for (const m of bareUnconditional) {
       const idx = m.index ?? 0
-      const window = gatewaySrc.slice(Math.max(0, idx - 600), idx)
+      const window = sendPathSrc.slice(Math.max(0, idx - 600), idx)
       expect(
         /finalAnswerSubstantive/.test(window) || /isSubstantiveFinalReply/.test(window),
       ).toBe(true)
@@ -108,14 +136,14 @@ describe('drainActivitySummary OPEN gate (levers 1 + 5, heartbeat-covered)', ()
 
 describe('drain producers — narrative may not OPEN, liveness + tool may', () => {
   it('showNarrativeStep drains with producer "narrative" (lever 5 base case)', () => {
-    const after = gatewaySrc.split('function showNarrativeStep(')[1] ?? ''
-    const body = after.split('\nfunction ')[0] ?? after
+    const after = laneSrc.split('function showNarrativeStep(')[1] ?? ''
+    const body = after.split('\n  function ')[0] ?? after
     expect(body).toMatch(/drainActivitySummary\(turn,\s*'narrative'\)/)
   })
 
   it('the liveness-open path drains with producer "liveness" (producer C preserved)', () => {
-    const after = gatewaySrc.split('function feedHeartbeatTick(')[1] ?? ''
-    const body = after.split('\nfunction ')[0] ?? after
+    const after = laneSrc.split('function feedHeartbeatTick(')[1] ?? ''
+    const body = after.split('\n  function ')[0] ?? after
     expect(body).toMatch(/drainActivitySummary\(turn,\s*'liveness'\)/)
   })
 
@@ -125,10 +153,11 @@ describe('drain producers — narrative may not OPEN, liveness + tool may', () =
 })
 
 describe('lever 2 — finalize the card BEFORE a substantive reply send', () => {
-  /** executeReply body up to the next top-level function. */
+  /** The extracted reply-orchestration body (#2996 P2): the sendReply window
+   *  in outbound-send-path.ts, up to the next export. */
   function executeReplySrc(): string {
-    const after = gatewaySrc.split('async function executeReply(')[1] ?? ''
-    return after.split('\nasync function ')[0]?.split('\nfunction ')[0] ?? after
+    const after = sendPathSrc.split('export async function sendReply(')[1] ?? ''
+    return after.split('\nexport ')[0] ?? after
   }
 
   // #2996 step 1: the chunk send loop was relocated verbatim from executeReply

package/telegram-plugin/tests/feed-heartbeat-liveness-open.test.ts

@@ -43,18 +43,41 @@ const gatewaySrc = readFileSync(
   resolve(__dirname, '..', 'gateway', 'gateway.ts'),
   'utf-8',
 )
+// #2996 P4-A: the enqueue-time `scheduleEarlyLivenessOpen(next)` moved with
+// handleSessionEvent into stream-render.ts; the turn-end teardown stays in
+// gateway.ts. The timer-lifecycle assertion spans both files.
+const streamSrc = readFileSync(
+  resolve(__dirname, '..', 'gateway', 'stream-render.ts'),
+  'utf-8',
+)
+// #2996 P4-B: feedHeartbeatTick / openLivenessFeedIfDue (and the whole
+// activity lane) moved VERBATIM into narrative-lane.ts (factory scope, bodies
+// indented +2); gateway keeps thin same-name wrappers, so the body helpers
+// below read the module source.
+const laneSrc = readFileSync(
+  resolve(__dirname, '..', 'gateway', 'narrative-lane.ts'),
+  'utf-8',
+)
+// #2996 P8 PR-B: the turn-end funnel (incl. the `stopEarlyLivenessOpen(key as
+// string)` teardown inside purgeReactionTracking) moved verbatim to turn-end.ts.
+const turnEndSrc = readFileSync(
+  resolve(__dirname, '..', 'gateway', 'turn-end.ts'),
+  'utf-8',
+)
+const gatewayAndStreamSrc = gatewaySrc + '\n' + streamSrc + '\n' + laneSrc + '\n' + turnEndSrc
 
 /** Return the source text of `feedHeartbeatTick` (everything up to the next top-level function). */
 function feedHeartbeatTickSrc(): string {
-  const after = gatewaySrc.split('function feedHeartbeatTick(): void {')[1] ?? ''
-  // Stop at the next top-level function definition.
-  return after.split('\nfunction ')[0] ?? after
+  // #2996 P4-B: reads narrative-lane.ts; next lane fn sits at 2-space indent.
+  const after = laneSrc.split('function feedHeartbeatTick(): void {')[1] ?? ''
+  return after.split('\n  async function ')[0]?.split('\n  function ')[0] ?? after
 }
 
 /** Return the source text of `openLivenessFeedIfDue` (the shared open helper). */
 function openLivenessFeedIfDueSrc(): string {
-  const after = gatewaySrc.split('function openLivenessFeedIfDue(turn: CurrentTurn): void {')[1] ?? ''
-  return after.split('\nfunction ')[0] ?? after
+  // #2996 P4-B: reads narrative-lane.ts; next lane fn sits at 2-space indent.
+  const after = laneSrc.split('function openLivenessFeedIfDue(turn: CurrentTurn): void {')[1] ?? ''
+  return after.split('\n  async function ')[0]?.split('\n  function ')[0] ?? after
 }
 
 describe('H-1: feedHeartbeatTick liveness-open threshold', () => {
@@ -121,8 +144,8 @@ describe('H-1: feedHeartbeatTick liveness-open threshold', () => {
     // The enqueue-time early-open (the dead-air fix): a one-shot timer fires the
     // shared open helper at turn start, and it is cancelled at the canonical
     // turn-end so a leaked timer can never fire against a successor turn.
-    expect(gatewaySrc).toMatch(/scheduleEarlyLivenessOpen\(next\)/)
-    expect(gatewaySrc).toMatch(/stopEarlyLivenessOpen\(key as string\)/)
+    expect(gatewayAndStreamSrc).toMatch(/scheduleEarlyLivenessOpen\(next\)/)
+    expect(gatewayAndStreamSrc).toMatch(/stopEarlyLivenessOpen\(key as string\)/)
   })
 })