switchroom 0.18.7 → 0.18.9

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

@@ -131,10 +131,17 @@ describe('lever 2 — finalize the card BEFORE a substantive reply send', () =>
     return after.split('\nasync function ')[0]?.split('\nfunction ')[0] ?? after
   }
 
-  it('executeReply finalizes (clearActivitySummary) before the chunk loop, gated on substantive', () => {
+  // #2996 step 1: the chunk send loop was relocated verbatim from executeReply
+  // into outbound-send-path.ts's `sendReplyChunks`, invoked here as
+  // `await sendReplyChunks(chunkSendDeps, …)`. This guard's INTENT — the
+  // lever-2 card finalize runs BEFORE the reply send — is unchanged; the send
+  // marker is now the delegation call rather than the inline `for` loop.
+  const SEND_MARKER = 'sendReplyChunks('
+
+  it('executeReply finalizes (clearActivitySummary) before the reply send, gated on substantive', () => {
     const src = executeReplySrc()
     const clearIdx = src.indexOf('clearActivitySummary(')
-    const loopIdx = src.indexOf('for (let i = 0; i < chunks.length')
+    const loopIdx = src.indexOf(SEND_MARKER)
     expect(clearIdx).toBeGreaterThan(-1)
     expect(loopIdx).toBeGreaterThan(-1)
     expect(clearIdx).toBeLessThan(loopIdx)
@@ -148,8 +155,8 @@ describe('lever 2 — finalize the card BEFORE a substantive reply send', () =>
     // An ack (non-substantive) falls through and never finalizes early, so the
     // reopen path keeps owning the card (the #2141 ack-then-work feed).
     const replySrc = executeReplySrc()
-    // The pre-loop clearActivitySummary must be the substantive-gated one.
-    const preLoop = replySrc.split('for (let i = 0; i < chunks.length')[0] ?? ''
+    // The pre-send clearActivitySummary must be the substantive-gated one.
+    const preLoop = replySrc.split(SEND_MARKER)[0] ?? ''
     const clears = [...preLoop.matchAll(/clearActivitySummary\(/g)]
     expect(clears).toHaveLength(1)
   })

package/telegram-plugin/tests/fixtures/cutover-killswitch-probe.ts

@@ -0,0 +1,75 @@
+/**
+ * Subprocess probe for the SWITCHROOM_DELIVERY_MACHINE_CUTOVER kill switch.
+ *
+ * The cutover env var is read at MODULE LOAD in both
+ * `inbound-delivery-machine-dispatch.ts` and
+ * `inbound-delivery-machine-shadow.ts`, so an in-process test can't flip it
+ * after import (and bun's `vi` shim has no resetModules/stubEnv). The
+ * cutover-flip test spawns this script under `bun` with the env it wants
+ * and asserts the JSON verdict printed on stdout.
+ *
+ * Output: one JSON line —
+ *   {
+ *     dispatchEnabled, cutoverEnabled, shadowEnabled,
+ *     sendCalls, buffered, setTurnStartedCalls, deliverResults
+ *   }
+ * after driving a fresh-turn inbound effect set through dispatchEffects
+ * against a recording fake ctx.
+ */
+
+import { dispatchEffects, isDispatchEnabled } from '../../gateway/inbound-delivery-machine-dispatch'
+import {
+  isDeliveryCutoverEnabled,
+  __shadowEnabledForTests,
+} from '../../gateway/inbound-delivery-machine-shadow'
+import { createPendingInboundBuffer } from '../../gateway/pending-inbound-buffer'
+import { createPendingPermissionBuffer } from '../../gateway/pending-permission-decisions'
+import { initialState, transition, type ChatKey } from '../../gateway/inbound-delivery-machine'
+
+const KEY = '111:_' as ChatKey
+const msg = { type: 'inbound', chatId: '111', messageId: 42, text: 'hello' }
+
+const alive = transition(initialState(), { kind: 'bridgeUp', at: 1000 }).state
+const { effects } = transition(alive, {
+  kind: 'inbound',
+  key: KEY,
+  msg: { msgId: 42, isSteering: false, payload: msg },
+  at: 2000,
+})
+
+let sendCalls = 0
+const buffer = createPendingInboundBuffer()
+let setTurnStartedCalls = 0
+const deliverResults: boolean[] = []
+
+dispatchEffects(effects, {
+  selfAgent: 'probe-agent',
+  ipcServer: {
+    sendToAgent: () => {
+      sendCalls++
+      return true
+    },
+  } as never,
+  pendingInboundBuffer: buffer,
+  inboundSpool: null,
+  pendingPermissionBuffer: createPendingPermissionBuffer(),
+  log: () => {},
+  onSetTurnStarted: () => {
+    setTurnStartedCalls++
+  },
+  onDeliverResult: (_k, ok) => {
+    deliverResults.push(ok)
+  },
+})
+
+process.stdout.write(
+  JSON.stringify({
+    dispatchEnabled: isDispatchEnabled(),
+    cutoverEnabled: isDeliveryCutoverEnabled(),
+    shadowEnabled: __shadowEnabledForTests(),
+    sendCalls,
+    buffered: buffer.drain('probe-agent').length,
+    setTurnStartedCalls,
+    deliverResults,
+  }) + '\n',
+)

package/telegram-plugin/tests/flood-circuit-breaker.test.ts

@@ -0,0 +1,74 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import {
+  computeFloodWait,
+  floodWaitRemainingMs,
+  isFloodWaitActive,
+  readFloodState,
+  writeFloodState,
+  makeFloodWaitRecorder,
+  suppressNonEssentialSendMs,
+  floodStatePath,
+  type FloodWaitState,
+} from '../flood-circuit-breaker.js'
+
+describe('#2923 flood circuit-breaker', () => {
+  let dir: string
+  beforeEach(() => {
+    dir = mkdtempSync(join(tmpdir(), 'flood-cb-'))
+  })
+  afterEach(() => rmSync(dir, { recursive: true, force: true }))
+
+  it('records a flood-wait window from retry_after', () => {
+    const now = 1_000_000
+    const s = computeFloodWait(null, 4116, now)
+    expect(s.untilTs).toBe(now + 4116_000)
+    expect(s.retryAfterSec).toBe(4116)
+    expect(isFloodWaitActive(s, now)).toBe(true)
+    expect(isFloodWaitActive(s, s.untilTs + 1)).toBe(false)
+  })
+
+  it('EXTENDS (never shrinks) an existing window on a fresh, shorter 429', () => {
+    const now = 1_000_000
+    const long = computeFloodWait(null, 4000, now)
+    // A later 429 reporting a shorter ban must not pull the expiry earlier.
+    const shorter = computeFloodWait(long, 10, now + 1000)
+    expect(shorter.untilTs).toBe(long.untilTs)
+  })
+
+  it('floodWaitRemainingMs is 0 for no state / expired state', () => {
+    expect(floodWaitRemainingMs(null, 5)).toBe(0)
+    const expired: FloodWaitState = { untilTs: 100, retryAfterSec: 1, recordedTs: 0 }
+    expect(floodWaitRemainingMs(expired, 200)).toBe(0)
+  })
+
+  it('persists + reads back the window; corrupt marker → null', () => {
+    const p = floodStatePath(dir)
+    expect(readFloodState(p)).toBeNull()
+    const s = computeFloodWait(null, 60, 1000)
+    writeFloodState(p, s)
+    expect(readFloodState(p)).toEqual(s)
+    writeFileSync(p, '{bad')
+    expect(readFloodState(p)).toBeNull()
+  })
+
+  it('makeFloodWaitRecorder persists the window (the onFloodWait hook)', () => {
+    const p = floodStatePath(dir)
+    const record = makeFloodWaitRecorder(p, () => 500_000)
+    record(4116)
+    const s = readFloodState(p)
+    expect(s).not.toBeNull()
+    expect(s!.untilTs).toBe(500_000 + 4116_000)
+  })
+
+  it('suppressNonEssentialSendMs > 0 while a ban is open, 0 after it lifts', () => {
+    const p = floodStatePath(dir)
+    writeFloodState(p, computeFloodWait(null, 68 * 60, 1_000_000))
+    // A restart mid-ban: the boot card must be suppressed.
+    expect(suppressNonEssentialSendMs(p, 1_000_000)).toBeGreaterThan(0)
+    // After the window: send proceeds.
+    expect(suppressNonEssentialSendMs(p, 1_000_000 + 68 * 60_000 + 1)).toBe(0)
+  })
+})

package/telegram-plugin/tests/gateway-outbound-redact.test.ts

@@ -35,8 +35,12 @@ describe('gateway outbound secret-scrub — structural wiring', () => {
   })
 
   it('reply: scrubs at entry, before the stderr preview log', () => {
+    // #2996: the entry pipeline (normalize → redact → punctuation/bold →
+    // voice-scrub) is extracted into outbound-send-path.ts. The reply path now
+    // delegates via `normalizeOutboundBody(rawText, 'reply', redactOutboundText)`
+    // — the injected redactor still runs at entry, before the stderr preview.
     const start = src.indexOf('async function executeReply(')
-    const redactIdx = src.indexOf(`redactOutboundText(text, 'reply')`, start)
+    const redactIdx = src.indexOf(`normalizeOutboundBody(rawText, 'reply', redactOutboundText)`, start)
     const previewIdx = src.indexOf('reply: invoked chatId=', start)
     expect(start).toBeGreaterThan(0)
     expect(redactIdx).toBeGreaterThan(start)

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

@@ -1,13 +1,15 @@
 /**
- * Structural pins for the session-only model relaunch wiring in gateway.ts.
+ * Structural pins for the session-model stickiness wiring in gateway.ts
+ * (reference/rfcs/session-model-stickiness.md).
  *
  * The behaviour lives in un-exported inline closures (buildModelDeps's
- * scheduleModelRelaunch, the model-menu callback sr-* branch, and the boot
- * re-hydration / alert-sentinel block inside the startup IIFE), so — mirroring
- * the other gateway-*.test.ts source-pins — we assert on the source structure.
- * The end-to-end behaviour of the carrier itself is exercised in
- * tests/scaffold.session-model-override.test.ts (rendered start.sh) and the
- * handler contract in telegram-plugin/tests/model-command.test.ts.
+ * scheduleModelRelaunch/scheduleRestart, triggerSelfRestart, the /restart and
+ * /new handlers, the model-menu callback branches, and the boot re-hydration
+ * block inside the startup IIFE), so — mirroring the other gateway-*.test.ts
+ * source-pins — we assert on the source structure. The end-to-end behaviour
+ * of the boot resolver is exercised in tests/scaffold.session-model.test.ts
+ * (rendered start.sh), the file helpers in session-model-file.test.ts, and
+ * the handler contract in model-command.test.ts.
  */
 
 import { describe, it, expect } from 'vitest'
@@ -18,54 +20,199 @@ import { dirname, resolve } from 'node:path'
 const __dirname = dirname(fileURLToPath(import.meta.url))
 const GATEWAY_SRC = readFileSync(resolve(__dirname, '..', 'gateway', 'gateway.ts'), 'utf8')
 
-describe('gateway: scheduleModelRelaunch dep', () => {
-  it('writes the carrier with exact "<model>\\n" bytes', () => {
+describe('gateway: triggerSelfRestart stamps relaunch-model intent BEFORE the kill', () => {
+  it('docker branch: writeRelaunchModelIntent(intentForRestartReason(reason)) precedes the SIGTERM scheduling', () => {
+    const fnIdx = GATEWAY_SRC.indexOf('function triggerSelfRestart(')
+    expect(fnIdx).toBeGreaterThan(0)
+    const win = GATEWAY_SRC.slice(fnIdx, fnIdx + 3000)
+    const writeIdx = win.indexOf('writeRelaunchModelIntent(smDir, intentForRestartReason(reason), reason)')
+    const killIdx = win.indexOf("process.kill(1, 'SIGTERM')")
+    // Write-before-kill invariant: boot default is REVERT, so the intent must
+    // be on disk synchronously before the SIGTERM is even scheduled.
+    expect(writeIdx).toBeGreaterThan(0)
+    expect(killIdx).toBeGreaterThan(writeIdx)
+    // And before the setTimeout that schedules it.
+    const timeoutIdx = win.indexOf('setTimeout(')
+    expect(timeoutIdx).toBeGreaterThan(writeIdx)
+  })
+
+  it('legacy systemd branch stamps intent too (self-target only)', () => {
+    const fnIdx = GATEWAY_SRC.indexOf('function triggerSelfRestart(')
+    const win = GATEWAY_SRC.slice(fnIdx, fnIdx + 4200)
+    const legacyIdx = win.indexOf('// Legacy systemd path.')
+    expect(legacyIdx).toBeGreaterThan(0)
+    const legacyWin = win.slice(legacyIdx)
+    expect(legacyWin).toContain('writeRelaunchModelIntent(smDir, intentForRestartReason(reason), reason)')
+    expect(legacyWin.indexOf('writeRelaunchModelIntent')).toBeLessThan(legacyWin.indexOf('spawn('))
+  })
+})
+
+describe('gateway: scheduleModelRelaunch dep (durable .session-model)', () => {
+  it('writes the durable file via writeSessionModelFile before dispatching the restart', () => {
     const idx = GATEWAY_SRC.indexOf('scheduleModelRelaunch: async')
     expect(idx).toBeGreaterThan(0)
-    const win = GATEWAY_SRC.slice(idx, idx + 900)
-    expect(win).toMatch(/writeFileSync\(\s*join\(agentDir, '\.session-model-override'\),\s*`\$\{model\}\\n`/)
+    const win = GATEWAY_SRC.slice(idx, idx + 1800)
+    const writeIdx = win.indexOf('writeSessionModelFile(')
+    const restartIdx = win.indexOf('deps.scheduleRestart(reason)')
+    expect(writeIdx).toBeGreaterThan(0)
+    expect(restartIdx).toBeGreaterThan(writeIdx)
   })
 
   it('sets the in-memory session-model override before dispatching the restart', () => {
     const idx = GATEWAY_SRC.indexOf('scheduleModelRelaunch: async')
-    const win = GATEWAY_SRC.slice(idx, idx + 900)
-    // The override now lives on the freshness-aware sessionModelSource
-    // (session-model-source.ts) rather than a bare module-level variable.
+    const win = GATEWAY_SRC.slice(idx, idx + 1800)
     const setIdx = win.indexOf('sessionModelSource.setOverride(model)')
     const restartIdx = win.indexOf('deps.scheduleRestart(reason)')
     expect(setIdx).toBeGreaterThan(0)
     expect(restartIdx).toBeGreaterThan(setIdx)
   })
 
+  it('rolls back the prior file content (not just deletion) on a non-in-flight dispatch failure', () => {
+    const idx = GATEWAY_SRC.indexOf('scheduleModelRelaunch: async')
+    const win = GATEWAY_SRC.slice(idx, idx + 1800)
+    expect(win).toContain('const prevFileRaw = readSessionModelFileRaw(agentDir)')
+    expect(win).toContain('restoreSessionModelFileRaw(agentDir, prevFileRaw)')
+    expect(win).toContain("!== 'restart_in_flight'")
+  })
+
+  it('the non-in-flight rollback ALSO clears the keep-intent (a live intent with no restart coming would wrongly KEEP across a crash)', () => {
+    const idx = GATEWAY_SRC.indexOf('scheduleModelRelaunch: async')
+    const win = GATEWAY_SRC.slice(idx, idx + 2400)
+    const inFlightIdx = win.indexOf("!== 'restart_in_flight'")
+    const clearIdx = win.indexOf('clearRelaunchModelIntent(agentDir)')
+    expect(inFlightIdx).toBeGreaterThan(0)
+    expect(clearIdx).toBeGreaterThan(inFlightIdx)
+  })
+
   it('reuses the same scheduleRestart dispatch (not a bespoke restart path)', () => {
     const idx = GATEWAY_SRC.indexOf('scheduleModelRelaunch: async')
-    const win = GATEWAY_SRC.slice(idx, idx + 900)
+    const win = GATEWAY_SRC.slice(idx, idx + 1800)
     expect(win).toContain('await deps.scheduleRestart(reason)')
   })
 })
 
-describe('gateway: model-menu sr-* target relaunches via the carrier', () => {
+describe('gateway: intent writers on the restart verbs', () => {
+  it('model-switch scheduleRestart stamps keep-intent before the hostd dispatch', () => {
+    const idx = GATEWAY_SRC.indexOf('scheduleRestart: async (reason: string)')
+    expect(idx).toBeGreaterThan(0)
+    const win = GATEWAY_SRC.slice(idx, idx + 3200)
+    const keepIdx = win.indexOf("writeRelaunchModelIntent(smDir, 'keep', reason)")
+    const dispatchIdx = win.indexOf("op: 'agent_restart'")
+    expect(keepIdx).toBeGreaterThan(0)
+    expect(dispatchIdx).toBeGreaterThan(keepIdx)
+  })
+
+  it('scheduleRestart clears the keep-intent when hostd refuses (failed dispatch → no live intent on disk)', () => {
+    const idx = GATEWAY_SRC.indexOf('scheduleRestart: async (reason: string)')
+    const win = GATEWAY_SRC.slice(idx, idx + 3200)
+    const failIdx = win.indexOf('hostd restart failed')
+    const clearIdx = win.indexOf('clearRelaunchModelIntent(smDir)')
+    expect(clearIdx).toBeGreaterThan(0)
+    expect(failIdx).toBeGreaterThan(clearIdx) // cleared before the throw's message
+    // And it sits in the same error branch as clearRestartMarker.
+    const markerIdx = win.indexOf('clearRestartMarker()')
+    expect(clearIdx).toBeGreaterThan(markerIdx)
+  })
+
+  it('/restart stamps an explicit revert intent (reason honesty) before dispatch', () => {
+    const idx = GATEWAY_SRC.indexOf("stampUserRestartReason('user: /restart from chat')")
+    expect(idx).toBeGreaterThan(0)
+    const win = GATEWAY_SRC.slice(idx, idx + 900)
+    const revertIdx = win.indexOf("writeRelaunchModelIntent(smDir, 'revert', 'user: /restart from chat')")
+    const dispatchIdx = win.indexOf("hostdRequestId('gw-restart')")
+    expect(revertIdx).toBeGreaterThan(0)
+    expect(dispatchIdx).toBeGreaterThan(revertIdx)
+  })
+
+  it('/new and /reset stamp keep-intent (fresh conversation, same model — contract row 7)', () => {
+    const idx = GATEWAY_SRC.indexOf('stampUserRestartReason(`user: /${kind} from chat`)')
+    expect(idx).toBeGreaterThan(0)
+    const win = GATEWAY_SRC.slice(idx, idx + 700)
+    const keepIdx = win.indexOf("writeRelaunchModelIntent(agentDir, 'keep', `user: /${kind} from chat`)")
+    const dispatchIdx = win.indexOf('tryHostdDispatch')
+    expect(keepIdx).toBeGreaterThan(0)
+    expect(dispatchIdx).toBeGreaterThan(keepIdx)
+  })
+})
+
+describe('gateway: model-menu callback persists the sticky override', () => {
+  it('a confirmed selection persists the canonical token (selectedModelToken), never the display label', () => {
+    const idx = GATEWAY_SRC.indexOf('const outcome = await handleModelMenuCallback(data, modelDeps)')
+    expect(idx).toBeGreaterThan(0)
+    const win = GATEWAY_SRC.slice(idx, idx + 1600)
+    expect(win).toContain('outcome.selectedModelToken')
+    expect(win).toMatch(/writeSessionModelFile\(\s*smDir,\s*outcome\.selectedModelToken/)
+  })
+
+  it('a confirmed "Default" selection CLEARS the sticky file', () => {
+    const idx = GATEWAY_SRC.indexOf('const outcome = await handleModelMenuCallback(data, modelDeps)')
+    const win = GATEWAY_SRC.slice(idx, idx + 1800)
+    expect(win).toContain('outcome.clearedDefault')
+    expect(win).toContain('clearSessionModelFile(smDir)')
+  })
+
   it('the sr-* callback branch calls scheduleModelRelaunch, not inject', () => {
     const idx = GATEWAY_SRC.indexOf('if (data.startsWith(MODEL_CALLBACK_SR))')
     expect(idx).toBeGreaterThan(0)
     const win = GATEWAY_SRC.slice(idx, idx + 1400)
     expect(win).toContain('modelDeps.scheduleModelRelaunch(srName')
-    // It must return before falling through to handleModelMenuCallback (which
-    // would inject an sr-* id claude's picker rejects).
     expect(win).toMatch(/scheduleModelRelaunch[\s\S]*?\n\s*return\n/)
   })
+
+  it('the sr-to-claude transition writes the durable file (and clears it on a Default tap)', () => {
+    const idx = GATEWAY_SRC.indexOf('isSrToClaudeTransition(prevSessionModel, outcome.selectedModel)')
+    expect(idx).toBeGreaterThan(0)
+    const win = GATEWAY_SRC.slice(idx, idx + 3600)
+    expect(win).toMatch(/writeSessionModelFile\(\s*agentDir,\s*token/)
+    expect(win).toContain('clearSessionModelFile(agentDir)')
+    // Restart rides triggerSelfRestart with a keep-classified reason.
+    expect(win).toContain("triggerSelfRestart(agentName, 'sr-to-claude-model-switch'")
+  })
 })
 
-describe('gateway boot: session-model re-hydration + LiteLLM-down alert', () => {
-  it('re-hydrates activeSessionModelOverride from .active-session-model', () => {
+describe('gateway: typed /model persists the REQUESTED canonical token', () => {
+  it('persists expandSrAlias(parsed.model), and `/model default` clears file + in-memory override', () => {
+    const idx = GATEWAY_SRC.indexOf("const requested = parsed.kind === 'set' ? expandSrAlias(parsed.model) : null")
+    expect(idx).toBeGreaterThan(0)
+    const win = GATEWAY_SRC.slice(idx, idx + 2400)
+    expect(win).toContain("requested?.toLowerCase() === 'default'")
+    expect(win).toContain('sessionModelSource.setOverride(null)')
+    expect(win).toContain('clearSessionModelFile(smDir)')
+    // Non-default: the requested token (shape-gated, non-sr) is what persists.
+    expect(win).toContain('isValidModelArg(requested) && !isSrModel(requested)')
+    expect(win).toMatch(/writeSessionModelFile\(\s*smDir,\s*requested/)
+  })
+
+  it('`/model default` file-clear is NOT gated on a positive confirmation (silent-switch path must not resurrect)', () => {
+    const idx = GATEWAY_SRC.indexOf("const requested = parsed.kind === 'set' ? expandSrAlias(parsed.model) : null")
+    const win = GATEWAY_SRC.slice(idx, idx + 2400)
+    // The default branch clears the file unconditionally, and only the
+    // in-memory override change is confirmation-gated inside it.
+    const clearIdx = win.indexOf('if (smDir) clearSessionModelFile(smDir)')
+    const gatedOverrideIdx = win.indexOf('if (reply.selectedModel) sessionModelSource.setOverride(null)')
+    expect(clearIdx).toBeGreaterThan(0)
+    expect(gatedOverrideIdx).toBeGreaterThan(clearIdx)
+    // And the whole default branch is not nested in an `if (reply.selectedModel)` block:
+    const between = win.slice(0, clearIdx)
+    expect(between).not.toContain('if (reply.selectedModel) {')
+  })
+
+  it('a persist failure is surfaced ON THE REPLY, not just stderr (typed + menu paths)', () => {
+    expect(GATEWAY_SRC.match(/won’t survive a relaunch/g)?.length ?? 0).toBeGreaterThanOrEqual(2)
+    const typedIdx = GATEWAY_SRC.indexOf('persistWarning =')
+    expect(typedIdx).toBeGreaterThan(0)
+    expect(GATEWAY_SRC).toContain('reply.text + persistWarning')
+    // Menu path appends onto the outgoing card text.
+    expect(GATEWAY_SRC).toContain('outcome.reply.text +=')
+  })
+})
+
+describe('gateway boot: session-model re-hydration + alert relay', () => {
+  it('re-hydrates the override from .active-session-model', () => {
     const idx = GATEWAY_SRC.indexOf("join(smAgentDir, '.active-session-model')")
     expect(idx).toBeGreaterThan(0)
     const win = GATEWAY_SRC.slice(idx - 200, idx + 1400)
-    // Only an override when the launched model differs from the configured one.
     expect(win).toMatch(/launched\.length > 0 && launched !== configured \? launched : null/)
-    // The configured value must be resolved through resolveMainModel (the SAME
-    // resolver start.sh's scaffold uses) so an unset/`default` model config does
-    // not get flagged as a phantom session override on an ordinary restart.
     expect(win).toContain('resolveMainModel(raw ?? undefined)')
   })
 
@@ -74,10 +221,15 @@ describe('gateway boot: session-model re-hydration + LiteLLM-down alert', () =>
     expect(idx).toBeGreaterThan(0)
     const win = GATEWAY_SRC.slice(idx, idx + 1100)
     expect(win).toContain('unlinkSync(alertPath)')
-    // Broadcasts to every operator in allowFrom, not just allowFrom[0].
     expect(win).toContain('const operators = loadAccess().allowFrom')
     expect(win).toContain('for (const operator of operators)')
     expect(win).toContain('lockedBot.api')
     expect(win).toContain('.sendMessage(operator')
   })
 })
+
+describe('gateway: the legacy one-shot carrier is no longer written', () => {
+  it('no gateway code writes .session-model-override anymore (start.sh migration shim only reads it)', () => {
+    expect(GATEWAY_SRC).not.toMatch(/writeFileSync\([^)]*\.session-model-override/)
+  })
+})