switchroom 0.18.31 → 0.18.33

package/telegram-plugin/tests/gateway-secret-detect.test.ts

@@ -26,10 +26,12 @@ import { readFileSync } from 'node:fs'
  * rather than live.
  */
 describe('gateway secret-detect intercept — structural wiring', () => {
-  const src = readFileSync(
-    new URL('../gateway/gateway.ts', import.meta.url),
-    'utf8',
-  )
+  const src =
+    readFileSync(new URL('../gateway/gateway.ts', import.meta.url), 'utf8') +
+    '\n' +
+    // P7 PR-8 (#2996): the vault pending-op intercept (incl. the deferred-
+    // secret passphrase branch) moved into gateway/inbound-interceptors.ts.
+    readFileSync(new URL('../gateway/inbound-interceptors.ts', import.meta.url), 'utf8')
 
   it('imports the pipeline + staging modules', () => {
     expect(src).toMatch(/from '\.\.\/secret-detect\/pipeline\.js'/)
@@ -54,7 +56,9 @@ describe('gateway secret-detect intercept — structural wiring', () => {
   })
 
   it('runPipeline call sits BEFORE recordInbound() and ipcServer.broadcast(inboundMsg)', () => {
-    const pipelineIdx = src.indexOf('runPipeline({')
+    // P7 PR-9: runPipeline lives in interceptSecretDetectPipeline; the
+    // gateway CALL SITE is the ordering anchor against the sinks.
+    const pipelineIdx = src.indexOf('await interceptSecretDetectPipeline(')
     const recordIdx = src.indexOf('recordInbound(', pipelineIdx)
     const broadcastIdx = src.indexOf('ipcServer.broadcast(inboundMsg)', pipelineIdx)
     expect(pipelineIdx).toBeGreaterThan(0)
@@ -74,7 +78,7 @@ describe('gateway secret-detect intercept — structural wiring', () => {
     // swallowed. See
     // tests/secret-detect-delete-must-surface-failures.test.ts for
     // the full contract pin.
-    expect(tail).toMatch(/deleteSensitiveMessage\(chat_id, msgId, 'detected secret'\)/)
+    expect(tail).toMatch(/deleteSensitiveMessage\((?:p\.)?chat_id, (?:p\.)?msgId, 'detected secret'\)/)
     // Tells the user what was captured (masked).
     expect(tail).toMatch(/captured \$\{pipeRes\.stored\.length\} secret/)
     // Surfaces the masked form (s.masked is computed via maskToken in the pipeline).
@@ -102,7 +106,7 @@ describe('gateway secret-detect intercept — structural wiring', () => {
     //    migrated to deleteSensitiveMessage so failures surface to the
     //    operator via in-chat warning. See
     //    tests/secret-detect-delete-must-surface-failures.test.ts.
-    expect(tail).toMatch(/deleteSensitiveMessage\(chat_id, msgId, 'detected secret'\)/)
+    expect(tail).toMatch(/deleteSensitiveMessage\((?:p\.)?chat_id, (?:p\.)?msgId, 'detected secret'\)/)
     // 4. The new inline keyboard helper is used in lieu of the legacy
     //    plain-text "run /vault list" warning.
     expect(tail).toMatch(/buildDeferredSecretKeyboard\(/)
@@ -134,9 +138,15 @@ describe('gateway secret-detect intercept — structural wiring', () => {
     // pre-staging body, not a precise offset — it has grown before (#3020's
     // stop-keyword block pushed it past the old 30k) and may grow again;
     // bump it when new early-return branches land above the staging block.
-    const handleInboundIdx = src.indexOf('async function handleInbound(')
-    const tail = src.slice(handleInboundIdx, handleInboundIdx + 50000)
+    // P7 PR-9: the parser moved to interceptSecretStagingCommand
+    // (inbound-interceptors.ts), still invoked from handleInbound's
+    // inbound-text path (same allowFrom gating) — anchor on the function.
+    const stagingFnIdx = src.indexOf('export async function interceptSecretStagingCommand(')
+    expect(stagingFnIdx).toBeGreaterThan(0)
+    const tail = src.slice(stagingFnIdx, stagingFnIdx + 6000)
     expect(tail).toMatch(/\(stash\|ignore\|rename\|forget\)/)
-    expect(tail).toMatch(/secretStaging\.latestForChat\(chat_id\)/)
+    expect(tail).toMatch(/secretStaging\.latestForChat\((?:p\.)?chat_id\)/)
+    // And handleInbound must actually delegate to it.
+    expect(src).toMatch(/await interceptSecretStagingCommand\(/)
   })
 })

package/telegram-plugin/tests/gateway-session-model-relaunch.test.ts

@@ -122,9 +122,15 @@ describe('gateway: the live callback dispatcher routes every switch tap to the h
   })
 
   it('the typed dispatcher relays the handler reply directly (no recordTypedModelSwitch)', () => {
-    const idx = GATEWAY_SRC.indexOf('const reply = await handleModelCommand(parsed, deps)')
+    // #2996 P6: the typed /model handler moved to bot-commands-model-effort.ts
+    // (registerModelEffortCommands); scrape the extracted module instead.
+    const MODULE_SRC = readFileSync(
+      resolve(__dirname, '..', 'gateway', 'bot-commands-model-effort.ts'),
+      'utf8',
+    )
+    const idx = MODULE_SRC.indexOf('const reply = await handleModelCommand(parsed, cmdDeps)')
     expect(idx).toBeGreaterThan(0)
-    const win = GATEWAY_SRC.slice(idx, idx + 400)
+    const win = MODULE_SRC.slice(idx, idx + 400)
     expect(win).not.toContain('recordTypedModelSwitch')
     expect(win).toContain('switchroomReply(ctx, reply.text')
   })

package/telegram-plugin/tests/inbound-delivery-cutover-flip.test.ts

@@ -1,37 +1,25 @@
 /**
- * PR3c cutover flip (#2794 / #2996 item 1) — the inbound-routing flip.
+ * Machine-authoritative inbound routing (#2794 cutover; kill switch
+ * removed in #2996 P1).
  *
- * `handleInbound` now dispatches the machine's captured `inbound` effects
+ * `handleInbound` dispatches the machine's captured `inbound` effects
  * through `dispatchEffects` as the AUTHORITATIVE deliver-vs-buffer routing.
- * These tests pin the two contract halves the flip rests on:
+ * These tests pin the delivery outcomes that routing rests on: fresh turn →
+ * setTurnStarted + deliverToBridge (real send); mid-turn → buffer (no send,
+ * drainable); steer mid-turn → deliverToBridge without setTurnStarted.
  *
- *   1. DEFAULT ON — with no env override, both the cutover gate
- *      (`isDeliveryCutoverEnabled`) and the dispatcher (`isDispatchEnabled`)
- *      are enabled, and the machine's effect sequences execute real I/O
- *      (fresh turn → setTurnStarted + deliverToBridge; mid-turn → buffer).
+ * Plus the `onDeliverResult` observer: the gateway's machine-deliver path
+ * branches on the send outcome (delivered → steer-ack + delivery-confirm
+ * tracking; miss → durable-buffer + restart notice), so the callback
+ * contract (fires once per deliverToBridge, with the real ok, and never
+ * breaks delivery when the observer throws) is load-bearing.
  *
- *   2. KILL SWITCH — `SWITCHROOM_DELIVERY_MACHINE_CUTOVER=0` restores
- *      legacy behavior: the gate reads legacy claudeBusyKeys (gate returns
- *      false from `isDeliveryCutoverEnabled`) and `dispatchEffects` is a
- *      total no-op, so the imperative twin in gateway.ts is the only
- *      executor. Env is read at module load, so the kill-switch tests use
- *      vi.resetModules + a fresh dynamic import.
- *
- * Plus the `onDeliverResult` observer added for the flip: the gateway's
- * machine-deliver path branches on the send outcome (delivered → busy-mark
- * + delivery-confirm tracking; miss → release + durable-buffer + restart
- * notice), so the callback contract (fires once per deliverToBridge, with
- * the real ok, and never breaks delivery when the observer throws) is
- * load-bearing.
+ * The `SWITCHROOM_DELIVERY_MACHINE_CUTOVER=0` kill-switch subprocess suite
+ * and its fixture probe were deleted in #2996 P1 with the switch itself.
  */
 
 import { describe, expect, it, vi } from 'vitest'
-import { spawnSync } from 'node:child_process'
-import { join } from 'node:path'
-import {
-  dispatchEffects,
-  isDispatchEnabled,
-} from '../gateway/inbound-delivery-machine-dispatch'
+import { dispatchEffects } from '../gateway/inbound-delivery-machine-dispatch'
 import type { DispatchCtx } from '../gateway/inbound-delivery-machine-dispatch'
 import { createPendingInboundBuffer } from '../gateway/pending-inbound-buffer'
 import { createPendingPermissionBuffer } from '../gateway/pending-permission-decisions'
@@ -41,9 +29,6 @@ import {
   type ChatKey,
   type State,
 } from '../gateway/inbound-delivery-machine'
-import {
-  isDeliveryCutoverEnabled,
-} from '../gateway/inbound-delivery-machine-shadow'
 
 const KEY = '111:_' as ChatKey
 
@@ -87,13 +72,7 @@ function aliveIdle(): State {
   return transition(initialState(), { kind: 'bridgeUp', at: 1000 }).state
 }
 
-describe('cutover default — ON without env override', () => {
-  it('dispatcher and gate are enabled by default (no kill-switch in test env)', () => {
-    expect(process.env.SWITCHROOM_DELIVERY_MACHINE_CUTOVER).toBeUndefined()
-    expect(isDispatchEnabled()).toBe(true)
-    expect(isDeliveryCutoverEnabled()).toBe(true)
-  })
-
+describe('machine-authoritative routing — delivery outcomes', () => {
   it('fresh-turn inbound: machine effects execute setTurnStarted + deliverToBridge', () => {
     const state = aliveIdle()
     const msg = ipcMsg()
@@ -240,79 +219,71 @@ describe('onDeliverResult observer contract (the flip’s post-send branch sourc
   })
 })
 
-describe('machine deliver path — send-miss busy-key handling (review fix, PR #3012)', () => {
-  // Mirrors the gateway's machine-deliver wiring: onSetTurnStarted stamps
-  // the busy mirror AND records the key; the miss branch releases ONLY a
-  // key THIS dispatch stamped. A steer-miss must keep the original turn's
-  // key (the twin never reserves for steers), else the wiped key fires a
-  // false machine_over_holds parity drift and the pending-restart gate
-  // (claudeBusyKeys.size) could green-light a mid-turn restart.
-  function runMissHarness(
-    effects: ReturnType<typeof transition>['effects'],
-    busyKeys: Set<string>,
-  ): { stamped: string | null } {
+describe('machine deliver path — steer vs fresh-turn setTurnStarted contract', () => {
+  // The gateway's machine-deliver wiring keys "was this a fresh turn?" off
+  // the setTurnStarted effect: a mid-turn steer emits deliverToBridge
+  // WITHOUT setTurnStarted (it amends the running turn, it does not open
+  // one). A machine change that started emitting setTurnStarted for steers
+  // would mis-classify steers as fresh turns at the live call site.
+  it('steer mid-turn emits NO setTurnStarted even on a send-miss', () => {
+    const s1 = transition(aliveIdle(), {
+      kind: 'inbound',
+      key: KEY,
+      msg: machineMsg(ipcMsg()),
+      at: 2000,
+    }).state
+    const { effects } = transition(s1, {
+      kind: 'inbound',
+      key: KEY,
+      msg: machineMsg(ipcMsg(), true),
+      at: 3000,
+    })
+    expect(effects.some((e) => e.kind === 'setTurnStarted')).toBe(false)
     let stamped: string | null = null
-    let delivered = false
+    let delivered = true
     const { ctx } = makeCtx({ ipcServer: { sendToAgent: vi.fn(() => false) } as never })
     dispatchEffects(effects, {
       ...ctx,
       onSetTurnStarted: (k) => {
         stamped = k
-        busyKeys.add(k)
       },
       onDeliverResult: (_k, ok) => {
         delivered = ok
       },
     })
+    expect(stamped).toBeNull()
     expect(delivered).toBe(false)
-    // Gateway miss branch (guarded release):
-    if (stamped != null) busyKeys.delete(stamped)
-    return { stamped }
-  }
+  })
 
-  it('fresh-turn miss: the key THIS dispatch stamped is released', () => {
-    const busyKeys = new Set<string>()
+  it('fresh turn fires setTurnStarted exactly once, before the send', () => {
     const { effects } = transition(aliveIdle(), {
       kind: 'inbound',
       key: KEY,
       msg: machineMsg(ipcMsg()),
       at: 2000,
     })
-    const { stamped } = runMissHarness(effects, busyKeys)
-    expect(stamped).toBe(KEY)
-    expect(busyKeys.has(KEY)).toBe(false)
-  })
-
-  it('steer miss: no setTurnStarted fired, the ORIGINAL turn\'s key survives', () => {
-    // Original fresh turn holds the busy key.
-    const busyKeys = new Set<string>([KEY])
-    const s1 = transition(aliveIdle(), {
-      kind: 'inbound',
-      key: KEY,
-      msg: machineMsg(ipcMsg()),
-      at: 2000,
-    }).state
-    const { effects } = transition(s1, {
-      kind: 'inbound',
-      key: KEY,
-      msg: machineMsg(ipcMsg(), true),
-      at: 3000,
+    const order: string[] = []
+    const sendToAgent = vi.fn(() => {
+      order.push('send')
+      return true
     })
-    expect(effects.some((e) => e.kind === 'setTurnStarted')).toBe(false)
-    const { stamped } = runMissHarness(effects, busyKeys)
-    expect(stamped).toBeNull()
-    // The in-flight turn's key was NOT wiped by the steer's send-miss.
-    expect(busyKeys.has(KEY)).toBe(true)
+    const { ctx } = makeCtx({ ipcServer: { sendToAgent } as never })
+    dispatchEffects(effects, {
+      ...ctx,
+      onSetTurnStarted: () => order.push('setTurnStarted'),
+    })
+    expect(order).toEqual(['setTurnStarted', 'send'])
   })
 })
 
 describe('carve-out routing anchors (gateway keys off these machine facts)', () => {
   it('PIN: bridge-dead inbound emits the exact `inbound_bridge_dead_buffer` trace stage', () => {
     // gateway.ts's machineBridgeDead carve-out matches this string verbatim
-    // to route bridge-dead inbounds to the imperative twin. A rename here
-    // silently reroutes them to the machine's buffer+persist (losing the
-    // twin's shouldTrackDelivery drop semantics + restart notice) — this
-    // pin makes the rename loud. Deleted in PR4 with the twin.
+    // to route bridge-dead inbounds to the imperative delivery body. A
+    // rename here silently reroutes them to the machine's buffer+persist
+    // (losing the shouldTrackDelivery drop semantics + restart notice) —
+    // this pin makes the rename loud. Deleted with the carve-out when the
+    // machine grows bridge_dead send semantics (#2794 PR4 remainder).
     const dead = initialState() // bridge_dead is the initial global state
     const { effects } = transition(dead, {
       kind: 'inbound',
@@ -349,70 +320,3 @@ describe('carve-out routing anchors (gateway keys off these machine facts)', ()
     expect(effects.some((e) => e.kind === 'deliverToBridge')).toBe(false)
   })
 })
-
-// The env var is read at MODULE LOAD in the dispatch + shadow modules, and
-// bun's `vi` shim has no resetModules/stubEnv — so the kill-switch/default
-// assertions run the fixture probe in a SUBPROCESS with a controlled env
-// (same pattern as bridge-anonymous-refuse.test.ts).
-describe('kill switch — SWITCHROOM_DELIVERY_MACHINE_CUTOVER=0 restores legacy (subprocess)', () => {
-  const PROBE = join(__dirname, 'fixtures', 'cutover-killswitch-probe.ts')
-
-  function bunBin(): string | null {
-    const r = spawnSync('which', ['bun'], { encoding: 'utf-8' })
-    const p = r.status === 0 ? r.stdout.trim() : ''
-    return p !== '' ? p : null
-  }
-
-  function runProbe(env: Record<string, string | undefined>) {
-    const bun = bunBin()
-    if (bun == null) return null
-    const r = spawnSync(bun, ['run', PROBE], {
-      encoding: 'utf-8',
-      env: { ...process.env, ...env },
-      timeout: 30_000,
-    })
-    expect(r.status).toBe(0)
-    const line = r.stdout.trim().split('\n').pop() ?? ''
-    return JSON.parse(line) as {
-      dispatchEnabled: boolean
-      cutoverEnabled: boolean
-      shadowEnabled: boolean
-      sendCalls: number
-      buffered: number
-      setTurnStartedCalls: number
-      deliverResults: boolean[]
-    }
-  }
-
-  it('default (no env): machine authoritative — dispatcher executes the deliver', () => {
-    const v = runProbe({ SWITCHROOM_DELIVERY_MACHINE_CUTOVER: undefined })
-    if (v == null) return // bun not on PATH — covered by the in-process default tests above
-    expect(v.dispatchEnabled).toBe(true)
-    expect(v.cutoverEnabled).toBe(true)
-    expect(v.sendCalls).toBe(1)
-    expect(v.setTurnStartedCalls).toBe(1)
-    expect(v.deliverResults).toEqual([true])
-    expect(v.buffered).toBe(0)
-  })
-
-  it('=0: dispatcher is a total no-op and the gate reverts to legacy; shadow stays on', () => {
-    const v = runProbe({ SWITCHROOM_DELIVERY_MACHINE_CUTOVER: '0' })
-    if (v == null) return
-    expect(v.dispatchEnabled).toBe(false)
-    expect(v.cutoverEnabled).toBe(false)
-    // Shadow trace continues for the bake; only authoritative reads flip off.
-    expect(v.shadowEnabled).toBe(true)
-    expect(v.sendCalls).toBe(0)
-    expect(v.buffered).toBe(0)
-    expect(v.setTurnStartedCalls).toBe(0)
-    expect(v.deliverResults).toEqual([])
-  })
-
-  it('=1 (explicit on): identical to the default', () => {
-    const v = runProbe({ SWITCHROOM_DELIVERY_MACHINE_CUTOVER: '1' })
-    if (v == null) return
-    expect(v.dispatchEnabled).toBe(true)
-    expect(v.cutoverEnabled).toBe(true)
-    expect(v.sendCalls).toBe(1)
-  })
-})

package/telegram-plugin/tests/inbound-delivery-cutover-gate.test.ts

@@ -1,13 +1,14 @@
 /**
- * PR3b cutover — the turn-in-flight GATE now reads the delivery state
- * machine (`isMachineInTurn`) instead of the PR3b `claudeBusyKeys` set.
+ * The turn-in-flight GATE reads the delivery state machine
+ * (`isMachineInTurn`) — since #2996 P1 the machine is the SOLE authority
+ * (the legacy `claudeBusyKeys` set was deleted).
  *
- * The bug this closes (gymbro/clerk, 2026-05-28): `claudeBusyKeys` is a
- * per-delivery Set — every delivery `.add`s a key, but turn-end `.delete`s
- * exactly one. When a turn-end is missed (or fires under a non-matching
- * key) the set keeps an orphan, `size > 0` reads true forever, and EVERY
- * subsequent inbound buffers as "held mid-turn" until the 5-min
- * framework-fallback force-drains it.
+ * The bug the machine gate closes (gymbro/clerk, 2026-05-28): the legacy
+ * set was per-delivery — every delivery `.add`ed a key, but turn-end
+ * `.delete`d exactly one. When a turn-end was missed (or fired under a
+ * non-matching key) the set kept an orphan, `size > 0` read true forever,
+ * and EVERY subsequent inbound buffered as "held mid-turn" until the 5-min
+ * framework-fallback force-drained it.
  *
  * The machine cannot accumulate orphans: global state holds ONE
  * `activeTurn`, so any matching turnEnd returns it to idle, and the TTL
@@ -19,7 +20,6 @@ import { describe, expect, it, beforeEach } from 'vitest'
 import {
   shadowEmit,
   isMachineInTurn,
-  isDeliveryCutoverEnabled,
   __shadowResetForTests,
 } from '../gateway/inbound-delivery-machine-shadow.js'
 import { TURN_TTL_MS, type ChatKey } from '../gateway/inbound-delivery-machine.js'
@@ -31,13 +31,9 @@ function inbound(key: ChatKey, at: number, msgId = 1) {
   shadowEmit({ kind: 'inbound', key, msg: { msgId, isSteering: false, payload: null }, at })
 }
 
-describe('PR3b cutover gate accessors', () => {
+describe('machine turn-in-flight gate accessors (sole authority, #2996 P1)', () => {
   beforeEach(() => __shadowResetForTests())
 
-  it('enabled by default (shadow on, no kill-switch in test env)', () => {
-    expect(isDeliveryCutoverEnabled()).toBe(true)
-  })
-
   it('reads idle before any turn (bridge alive)', () => {
     shadowEmit({ kind: 'bridgeUp', at: 1000 })
     expect(isMachineInTurn()).toBe(false)

package/telegram-plugin/tests/inbound-delivery-dispatch-equivalence.test.ts

@@ -18,13 +18,12 @@
  *   3. Invariant #1 at the dispatch layer: an inbound is delivered XOR
  *      (buffered AND persisted) — never both, never neither.
  *
- * It does NOT invoke the imperative twins (`markClaudeBusyForInbound`,
- * the legacy `turnInFlightForGate` claudeBusyKeys branch,
- * `dispatchPermissionVerdict`, the silence-poke ladder), so it is NOT a
- * proof that machine path and imperative path produce identical I/O.
- * Twin-equivalence evidence for PR4 (twin deletion) must come from the
- * live shadow trace + gate-parity-probe bake per the RFC's cutover
- * protocol — do NOT cite this file as that proof.
+ * It does NOT invoke the remaining imperative delivery body (the twin
+ * carve-outs for `!`-interrupt / bridge_dead, `dispatchPermissionVerdict`,
+ * the silence-poke ladder), so it is NOT a proof that machine path and
+ * imperative path produce identical I/O. (#2996 P1 deleted the legacy
+ * gate/claudeBusyKeys twins after the cutover bake; the carve-out body's
+ * eventual deletion — the #2794 PR4 remainder — needs its own evidence.)
  *
  * What it DOES gate: if a future edit adds an effect kind the
  * dispatcher doesn't execute, the "no unhandled effect" assertion fails

package/telegram-plugin/tests/inbound-delivery-machine-dispatch.test.ts

@@ -17,7 +17,6 @@ import { describe, expect, it, vi, beforeEach } from 'vitest'
 import {
   __dispatchOneForTests,
   dispatchEffects,
-  isDispatchEnabled,
 } from '../gateway/inbound-delivery-machine-dispatch'
 import type { DispatchCtx } from '../gateway/inbound-delivery-machine-dispatch'
 import { createPendingInboundBuffer } from '../gateway/pending-inbound-buffer'
@@ -50,12 +49,6 @@ function makeCtx(overrides?: Partial<DispatchCtx>): {
   return { ctx, logs, sendToAgent, clientSend, inbound, perm }
 }
 
-describe('isDispatchEnabled', () => {
-  it('defaults to true when the kill-switch env-var is unset', () => {
-    expect(isDispatchEnabled()).toBe(true)
-  })
-})
-
 describe('dispatchEffects — drainBuffer', () => {
   it('redelivers buffered inbound to the registered client', () => {
     const { ctx, clientSend, inbound } = makeCtx()
@@ -175,15 +168,6 @@ describe('dispatchEffects — bridgeUp composite (all three effects in order)',
   })
 })
 
-describe('dispatchEffects — kill switch', () => {
-  // The kill switch is checked at module-load time so we can't toggle
-  // it inside the test process easily. We validate the contract that
-  // the helper exists and respects the env-var — see isDispatchEnabled.
-  it('exposes the kill-switch check', () => {
-    expect(typeof isDispatchEnabled()).toBe('boolean')
-  })
-})
-
 describe('dispatchEffects — inbound-routing effects (PR3c wiring)', () => {
   const k = 'c1:_' as never
   const ipcMsg = { type: 'inbound' as const, id: 'm1', chat_id: '1', text: 'hi', meta: { source: 'telegram' } }

package/telegram-plugin/tests/inbound-emit-after-intercepts.test.ts

@@ -9,10 +9,10 @@
  * — before the permission-reply / `/auth` paste-back / interrupt-empty /
  * secret-detect-drop intercepts — an intercepted message (e.g. an approval
  * reply) drove the machine idle→`bridge_alive_in_turn`, then early-returned
- * as an intercept: no delivery, no claudeBusyKeys mark, and critically no
- * `turnEnd`. The machine held the gate closed until the 5-min TTL tick
- * force-cleared it, buffering every inbound (including `/usage`) meanwhile —
- * the dangerous `machine_over_holds` divergence gate-parity-probe.ts flags.
+ * as an intercept: no delivery, and critically no `turnEnd`. The machine
+ * held the gate closed until the 5-min TTL tick force-cleared it, buffering
+ * every inbound (including `/usage`) meanwhile — the dangerous over-hold
+ * direction the bake-era gate-parity probe flagged.
  *
  * The behaviour lives inside the un-exported `handleInbound` closure, so —
  * mirroring the other gateway-*.test.ts source-pins — we assert on source
@@ -28,6 +28,10 @@ import { dirname, resolve } from 'node:path'
 
 const __dirname = dirname(fileURLToPath(import.meta.url))
 const GATEWAY_SRC = readFileSync(resolve(__dirname, '..', 'gateway', 'gateway.ts'), 'utf8')
+// P8 PR-D: the isSteering classification body moved verbatim to
+// turn-start-surfaces.ts; the gateway call site (armTurnStartSurfaces) is the
+// ordering anchor now.
+const TURN_START_SRC = readFileSync(resolve(__dirname, '..', 'gateway', 'turn-start-surfaces.ts'), 'utf8')
 
 /** Byte offset of the sole `shadowEmit({ kind: 'inbound' ... })` call. */
 function inboundEmitOffset(): number {
@@ -50,21 +54,28 @@ describe('gateway: inbound machine-emit is deferred past the intercepts', () =>
     const emitIdx = inboundEmitOffset()
     // The permission-reply intercept is one of the early-return paths that
     // must NOT drive the machine into a turn.
-    const permIdx = GATEWAY_SRC.indexOf('const permMatch = PERMISSION_REPLY_RE.exec(text)')
+    // P7 PR-4: the intercept body moved to inbound-interceptors.ts; the
+    // gateway call site is the ordering anchor now.
+    const permIdx = GATEWAY_SRC.indexOf('interceptPermissionReply({ text, chat_id, msgId }')
     expect(permIdx).toBeGreaterThan(0)
     expect(emitIdx).toBeGreaterThan(permIdx)
   })
 
   it('emits AFTER the `/auth add` paste-back intercept', () => {
     const emitIdx = inboundEmitOffset()
-    const authIdx = GATEWAY_SRC.indexOf('pendingAuthAddFlows.get(interceptKey)')
+    // P7 PR-5: the intercept body moved to inbound-interceptors.ts; the
+    // gateway call site is the ordering anchor now.
+    const authIdx = GATEWAY_SRC.indexOf('interceptAuthAdd(')
     expect(authIdx).toBeGreaterThan(0)
     expect(emitIdx).toBeGreaterThan(authIdx)
   })
 
   it('emits AFTER isSteering is classified, and passes the real value (not a hardcoded false)', () => {
     const emitIdx = inboundEmitOffset()
-    const steerIdx = GATEWAY_SRC.indexOf('isSteering = priorTurnInFlight && isSteerPrefix')
+    // P8 PR-D: classification lives in turn-start-surfaces.ts; the gateway
+    // ordering anchor is the armTurnStartSurfaces call that computes it.
+    expect(TURN_START_SRC).toContain('isSteering = priorTurnInFlight && isSteerPrefix')
+    const steerIdx = GATEWAY_SRC.indexOf('turnStartSurfaces().armTurnStartSurfaces({')
     expect(steerIdx).toBeGreaterThan(0)
     expect(emitIdx).toBeGreaterThan(steerIdx)
     // The emit's msg object must forward the live `isSteering` binding, so a

package/telegram-plugin/tests/inbound-message-types.test.ts

@@ -39,30 +39,62 @@ const SRC = readFileSync(
   'utf8',
 )
 
+// The media-envelope handlers were extracted out of gateway.ts into their own
+// module (switchroom#2996 P6 cluster A). gateway.ts keeps the `bot.on(…)`
+// registration lines (their order is a load-bearing invariant) but each now
+// delegates to a `handle<Kind>Message(ctx, mediaEnvelopeDeps)` function that
+// lives here. The structural assertions below still need to see the real
+// handler body, so we resolve a delegation to the extracted source.
+const MEDIA_SRC = readFileSync(
+  new URL('../gateway/media-message-handlers.ts', import.meta.url),
+  'utf8',
+)
+
 // ─── Helpers ─────────────────────────────────────────────────────────────
 
 /**
- * Extract the body of a `bot.on('message:<kind>', …)` handler. Returns
- * the substring from the `bot.on(` line up to the matching closing
- * `})` at the outer scope. Good enough for grepping — not a full
- * AST parse.
+ * Return the substring of `src` starting at `header` up to the matching
+ * closing brace of the block it opens. Naive depth count of {/} from the
+ * first `{` — good enough for grepping, not a full AST parse.
  */
-function handlerBody(kind: string): string {
-  const needle = `bot.on('message:${kind}'`
-  const start = SRC.indexOf(needle)
-  expect(start, `handler bot.on('message:${kind}') not found`).toBeGreaterThan(0)
-  // Find the matching close — naive depth count of {/} from the first `{`.
-  const firstBrace = SRC.indexOf('{', start)
+function braceBlock(src: string, header: string, label: string): string {
+  const start = src.indexOf(header)
+  expect(start, `${label} not found`).toBeGreaterThan(0)
+  const firstBrace = src.indexOf('{', start)
   let depth = 0
-  for (let i = firstBrace; i < SRC.length; i++) {
-    const c = SRC[i]
+  for (let i = firstBrace; i < src.length; i++) {
+    const c = src[i]
     if (c === '{') depth++
     else if (c === '}') {
       depth--
-      if (depth === 0) return SRC.slice(start, i + 1)
+      if (depth === 0) return src.slice(start, i + 1)
     }
   }
-  throw new Error(`could not find end of handler ${kind}`)
+  throw new Error(`could not find end of ${label}`)
+}
+
+/**
+ * Extract the body of a `bot.on('message:<kind>', …)` handler. If the
+ * registration delegates to an extracted `handle<Kind>Message(ctx,
+ * mediaEnvelopeDeps)` function, the returned body is that function's source
+ * (from media-message-handlers.ts). Otherwise it is the inline gateway.ts
+ * handler block. Either way callers see the real handler logic.
+ */
+function handlerBody(kind: string): string {
+  const needle = `bot.on('message:${kind}'`
+  const start = SRC.indexOf(needle)
+  expect(start, `handler bot.on('message:${kind}') not found`).toBeGreaterThan(0)
+  const lineEnd = SRC.indexOf('\n', start)
+  const regLine = SRC.slice(start, lineEnd < 0 ? SRC.length : lineEnd)
+  const delegate = regLine.match(/(handle\w+Message)\(ctx,\s*mediaEnvelopeDeps\)/)
+  if (delegate) {
+    return braceBlock(
+      MEDIA_SRC,
+      `export async function ${delegate[1]}(`,
+      `extracted handler ${delegate[1]}`,
+    )
+  }
+  return braceBlock(SRC, needle, `handler ${kind}`)
 }
 
 // ─── Registration completeness ───────────────────────────────────────────
@@ -108,7 +140,9 @@ describe('inbound message-type handlers: forwarding decisions', () => {
     it(`${kind} forwards via handleInbound and logs to stderr`, () => {
       const body = handlerBody(kind)
       expect(body).toMatch(/handleInbound\(ctx,/)
-      expect(body).toMatch(/process\.stderr\.write/)
+      // Logs the event — directly (inline handlers) or via the injected
+      // `deps.log` stderr sink (extracted media-envelope handlers).
+      expect(body).toMatch(/process\.stderr\.write|deps\.log\(/)
       // Must not divert to the ack-only path — that would silently
       // hide the payload from the agent.
       expect(body).not.toMatch(/handleAckOnly\(/)
@@ -148,7 +182,9 @@ describe('inbound message-type handlers: ack-only decisions', () => {
     it(`${kind} uses handleAckOnly (no forward to agent)`, () => {
       const body = handlerBody(kind)
       expect(body).toMatch(/handleAckOnly\(/)
-      expect(body).toMatch(/process\.stderr\.write/)
+      // Logs the event — directly (inline handlers) or via the injected
+      // `deps.log` stderr sink (extracted media-envelope handlers).
+      expect(body).toMatch(/process\.stderr\.write|deps\.log\(/)
       // Ack-only must NOT call handleInbound — the whole point is
       // we don't bother the agent for these.
       expect(body).not.toMatch(/handleInbound\(/)