switchroom 0.18.31 → 0.18.32

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

package/telegram-plugin/tests/litellm-proxy-auth-misconfig.test.ts

@@ -227,39 +227,94 @@ describe('PendingUserNoticeGate — notice fires IFF the turn dies reply-less',
     }
   }
 
+  // The single-turn norm: the error surfaced while topic A's turn was live, so
+  // the notice is keyed to A and topic A's turn end resolves it. `TOPIC_A` is a
+  // `statusKey(chatId, threadId)`-shaped value.
+  const TOPIC_A = '5000000002'
+  const TOPIC_B = '5000000009:42'
+
   it('DROPS the notice when the turn recovered (delivered a reply)', () => {
     const gate = new PendingUserNoticeGate()
-    gate.schedule(makeNotice())
-    expect(gate.resolveTurnEnd(true, 1_001_000)).toEqual([])
+    gate.schedule(makeNotice({ key: TOPIC_A }))
+    expect(gate.resolveTurnEnd(TOPIC_A, true, 1_001_000)).toEqual([])
     // And it does not resurrect on a later failed turn end.
-    expect(gate.resolveTurnEnd(false, 1_002_000)).toEqual([])
+    expect(gate.resolveTurnEnd(TOPIC_A, false, 1_002_000)).toEqual([])
   })
 
   it('SENDS the notice exactly once when the turn ends without a reply', () => {
     const gate = new PendingUserNoticeGate()
-    const notice = makeNotice()
-    gate.schedule(notice)
-    const flushed = gate.resolveTurnEnd(false, 1_001_000)
+    gate.schedule(makeNotice({ key: TOPIC_A }))
+    const flushed = gate.resolveTurnEnd(TOPIC_A, false, 1_001_000)
     expect(flushed).toHaveLength(1)
     expect(flushed[0].chatIds).toEqual(['5000000002', '5000000003'])
     // Exactly once — a second turn end flushes nothing.
-    expect(gate.resolveTurnEnd(false, 1_002_000)).toEqual([])
+    expect(gate.resolveTurnEnd(TOPIC_A, false, 1_002_000)).toEqual([])
   })
 
-  it('collapses an error burst within one turn to ONE pending notice per agent', () => {
+  it('collapses an error burst within one turn to ONE pending notice per topic', () => {
     const gate = new PendingUserNoticeGate()
-    gate.schedule(makeNotice({ atMs: 1_000_000 }))
-    gate.schedule(makeNotice({ atMs: 1_000_500 }))
-    gate.schedule(makeNotice({ atMs: 1_001_000 }))
-    expect(gate.resolveTurnEnd(false, 1_002_000)).toHaveLength(1)
+    gate.schedule(makeNotice({ atMs: 1_000_000, key: TOPIC_A }))
+    gate.schedule(makeNotice({ atMs: 1_000_500, key: TOPIC_A }))
+    gate.schedule(makeNotice({ atMs: 1_001_000, key: TOPIC_A }))
+    expect(gate.resolveTurnEnd(TOPIC_A, false, 1_002_000)).toHaveLength(1)
   })
 
   it('expires an unresolved notice after the TTL (bias to silence over false failure)', () => {
     const gate = new PendingUserNoticeGate()
-    gate.schedule(makeNotice({ atMs: 1_000_000 }))
+    gate.schedule(makeNotice({ atMs: 1_000_000, key: TOPIC_A }))
     const after = 1_000_000 + PENDING_USER_NOTICE_TTL_MS + 1
     expect(gate.hasPending(after)).toBe(false)
-    expect(gate.resolveTurnEnd(false, after)).toEqual([])
+    expect(gate.resolveTurnEnd(TOPIC_A, false, after)).toEqual([])
+  })
+
+  // ── #3294 — keyed by turn/topic so concurrent per-topic turns don't
+  //    cross-resolve each other's pending notices. ─────────────────────────────
+  it("does NOT flush topic A's notice when a DIFFERENT topic's turn ends reply-less", () => {
+    const gate = new PendingUserNoticeGate()
+    gate.schedule(makeNotice({ atMs: 1_000_000, key: TOPIC_A }))
+    // Topic B's turn ends WITHOUT a reply. Pre-#3294 this flushed A's notice
+    // (a false "couldn't complete" for a turn that may still recover). Now B's
+    // end resolves nothing keyed to A.
+    expect(gate.resolveTurnEnd(TOPIC_B, false, 1_000_500)).toEqual([])
+    // A's notice is still pending, and A's OWN reply-less end flushes it.
+    expect(gate.hasPending(1_000_600)).toBe(true)
+    const flushed = gate.resolveTurnEnd(TOPIC_A, false, 1_000_700)
+    expect(flushed).toHaveLength(1)
+    expect(flushed[0].key).toBe(TOPIC_A)
+  })
+
+  it("does NOT drop topic A's notice when a DIFFERENT topic's turn recovers", () => {
+    const gate = new PendingUserNoticeGate()
+    gate.schedule(makeNotice({ atMs: 1_000_000, key: TOPIC_A }))
+    // Topic B's turn recovered (delivered a reply). It must not drop A's notice.
+    expect(gate.resolveTurnEnd(TOPIC_B, true, 1_000_500)).toEqual([])
+    // A's notice survives and still flushes on A's reply-less end.
+    expect(gate.resolveTurnEnd(TOPIC_A, false, 1_000_700)).toHaveLength(1)
+  })
+
+  it('keeps a per-topic pending notice for each concurrent topic (no cross-collapse)', () => {
+    const gate = new PendingUserNoticeGate()
+    gate.schedule(makeNotice({ atMs: 1_000_000, key: TOPIC_A, chatIds: ['5000000002'] }))
+    gate.schedule(makeNotice({ atMs: 1_000_100, key: TOPIC_B, chatIds: ['5000000009'] }))
+    // A's end flushes only A.
+    const a = gate.resolveTurnEnd(TOPIC_A, false, 1_000_200)
+    expect(a).toHaveLength(1)
+    expect(a[0].chatIds).toEqual(['5000000002'])
+    // B is still pending and flushes on B's end.
+    const b = gate.resolveTurnEnd(TOPIC_B, false, 1_000_300)
+    expect(b).toHaveLength(1)
+    expect(b[0].chatIds).toEqual(['5000000009'])
+  })
+
+  it('an UNATTRIBUTED (undefined-key) notice resolves on any turn end (legacy single-turn behavior)', () => {
+    const gate = new PendingUserNoticeGate()
+    // No key — the error arrived with no live turn (between turns / post-poke).
+    gate.schedule(makeNotice({ atMs: 1_000_000 }))
+    // Any topic's reply-less end flushes it (preserves pre-#3294 behavior so a
+    // genuine death on a single-turn gateway still notifies the user).
+    const flushed = gate.resolveTurnEnd(TOPIC_B, false, 1_000_500)
+    expect(flushed).toHaveLength(1)
+    expect(flushed[0].key).toBeUndefined()
   })
 })
 

package/telegram-plugin/tests/multitopic-routing-wiring.test.ts

@@ -12,6 +12,13 @@ import { describe, it, expect } from 'vitest'
 import { readFileSync } from 'node:fs'
 import { resolve } from 'node:path'
 
+// #2996 P2: executeReply's body moved VERBATIM to outbound-send-path.ts
+// (`sendReply`); the reply-path routing assertions read the window there.
+const sendPathSrc = readFileSync(
+  resolve(__dirname, '..', 'gateway', 'outbound-send-path.ts'),
+  'utf-8',
+)
+const sendReplyFn = sendPathSrc.split('export async function sendReply(')[1]?.split('\nexport ')[0] ?? ''
 const gatewaySrc = readFileSync(
   resolve(__dirname, '..', 'gateway', 'gateway.ts'),
   'utf-8',
@@ -54,7 +61,7 @@ describe('component 3 — turn-origin reply routing', () => {
   })
 
   it('executeReply resolves the answer thread via the origin turn, not the live currentTurn', () => {
-    const fn = gatewaySrc.split('async function executeReply')[1]?.split('\nasync function ')[0] ?? ''
+    const fn = sendReplyFn
     expect(fn).toMatch(/TURN_ORIGIN_ROUTING_ENABLED/)
     expect(fn).toMatch(/findTurnByOriginId\(args\.origin_turn_id/)
     // The resolution + reply-route telemetry go through resolveAnswerThreadWithLog,
@@ -85,8 +92,7 @@ describe('framework-owned origin recovery (determinism residual, 2026-06-05)', (
   })
 
   it('the reply path recovers origin from the quoted message_id when the model omits the echo', () => {
-    for (const name of ['executeReply']) {
-      const fn = gatewaySrc.split(new RegExp(`async function ${name}`))[1]?.split('\nasync function ')[0] ?? ''
+    for (const fn of [sendReplyFn]) {
       // Echo first (authoritative), quoted message_id as the framework fallback.
       expect(fn).toMatch(/const echoedTurn = findTurnByOriginId\(args\.origin_turn_id/)
       // Quoted lookup is CHAT-SCOPED (cross-chat message-id collision guard).

package/telegram-plugin/tests/obligation-ledger.test.ts

@@ -620,3 +620,43 @@ describe("ObligationLedger — escalation suppression predicate (Fix 4)", () =>
     expect(snapshots[1]).toEqual([]);
   });
 });
+
+// #3282 — the durable captured-answer snapshot attaches to the OPEN obligation
+// so a partial backstop delivery is resumed (tail only) rather than regenerated.
+describe("ObligationLedger — noteCapturedDelivery (#3282)", () => {
+  function input(id: string, openedAt: number) {
+    return { originTurnId: id, chatId: "-100123", threadId: 3, messageId: 1, text: "q", openedAt };
+  }
+  const snap = { chunks: ["c0", "c1"], chunkStates: [{ index: 0, messageIds: [10], confirmed: true }] };
+
+  it("attaches the snapshot to an OPEN obligation and persists it", () => {
+    const snapshots: Obligation[][] = [];
+    const L = new ObligationLedger(2, { onChange: (s) => snapshots.push(s) });
+    L.openIfAbsent(input("c:3#1", 1000));
+    L.noteCapturedDelivery("c:3#1", snap);
+    expect(L.list()[0]!.capturedDelivery).toEqual(snap);
+    // The mutation persisted (onChange fired again after open).
+    expect(snapshots.at(-1)![0]!.capturedDelivery).toEqual(snap);
+  });
+
+  it("is a no-op for an obligation that is not open (a delivered turn has none to resume)", () => {
+    const L = new ObligationLedger(2);
+    L.noteCapturedDelivery("c:3#missing", snap); // never opened
+    expect(L.isOpen("c:3#missing")).toBe(false);
+  });
+
+  it("ignores an EMPTY snapshot (nothing to resume)", () => {
+    const L = new ObligationLedger(2);
+    L.openIfAbsent(input("c:3#1", 1000));
+    L.noteCapturedDelivery("c:3#1", { chunks: [], chunkStates: [] });
+    expect(L.list()[0]!.capturedDelivery).toBeUndefined();
+  });
+
+  it("close drops the snapshot with the obligation (bounded lifetime, A6)", () => {
+    const L = new ObligationLedger(2);
+    L.openIfAbsent(input("c:3#1", 1000));
+    L.noteCapturedDelivery("c:3#1", snap);
+    expect(L.close("c:3#1")).toBe(true);
+    expect(L.isOpen("c:3#1")).toBe(false);
+  });
+});

package/telegram-plugin/tests/obligation-store.test.ts

@@ -118,6 +118,49 @@ describe("obligation-store", () => {
     expect(loaded[0]!.representCount).toBe(1);
   });
 
+  it("round-trips a valid capturedDelivery snapshot through persist → load (#3282)", () => {
+    const { fs } = memFs();
+    const capturedDelivery = {
+      chunks: ["c0", "c1"],
+      chunkStates: [
+        { index: 0, messageIds: [10], confirmed: true },
+        { index: 1, messageIds: [11, 12], confirmed: false },
+      ],
+    };
+    persistObligations(PATH, fs, [ob("c:3#715", { capturedDelivery })]);
+    const loaded = loadObligations(PATH, fs);
+    expect(loaded).toHaveLength(1);
+    expect(loaded[0]!.capturedDelivery).toEqual(capturedDelivery);
+  });
+
+  it("STRIPS a malformed capturedDelivery (fail-open to fresh-generation represent) (#3282)", () => {
+    // A partial write / forward-incompatible shape must not crash the resume: the
+    // row survives (obligation preserved), the bad blob is dropped.
+    const bad = {
+      v: 1,
+      obligations: [
+        { ...ob("c:3#715"), capturedDelivery: { chunks: "not-an-array", chunkStates: [] } },
+        { ...ob("c:3#716"), capturedDelivery: { chunks: ["c0"], chunkStates: [{ index: 0 }] } },
+      ],
+    };
+    const { fs } = memFs({ [PATH]: JSON.stringify(bad) });
+    const loaded = loadObligations(PATH, fs);
+    expect(loaded.map((o) => o.originTurnId)).toEqual(["c:3#715", "c:3#716"]);
+    expect(loaded[0]!.capturedDelivery).toBeUndefined();
+    expect(loaded[1]!.capturedDelivery).toBeUndefined();
+  });
+
+  it("STRIPS an empty-chunks capturedDelivery (nothing to resume → fresh-gen, bounded) (#3282)", () => {
+    const bad = {
+      v: 1,
+      obligations: [{ ...ob("c:3#715"), capturedDelivery: { chunks: [], chunkStates: [] } }],
+    };
+    const { fs } = memFs({ [PATH]: JSON.stringify(bad) });
+    const loaded = loadObligations(PATH, fs);
+    expect(loaded).toHaveLength(1);
+    expect(loaded[0]!.capturedDelivery).toBeUndefined();
+  });
+
   it("never throws on a write failure — degrades to in-memory (logs)", () => {
     const logs: string[] = [];
     const fs: ObligationStoreFsSeam = {

package/telegram-plugin/tests/pending-card-durability-wiring.test.ts

@@ -143,7 +143,8 @@ describe('resolution clears the durable store (Defect A)', () => {
 
 describe('TTL expiry wakes the parked agent (Defect B)', () => {
   it('the periodic reaper runs the approval-card expiry sweep inside try/catch', () => {
-    const reaper = slice(GATEWAY, 'const pendingStateReaper = setInterval', 12000)
+    // Anchor tolerates the #2996 P0c `isGatewayMain ? setInterval(...)` boot gate.
+    const reaper = slice(GATEWAY, 'const pendingStateReaper = ', 12000)
     // The sweep call must be guarded like the sibling sweepStaleTurnActiveMarker:
     // an escaped throw inside this setInterval callback reaches uncaughtException
     // and takes the whole gateway down.

package/telegram-plugin/tests/permission-no-repeat-wiring.test.ts

@@ -101,14 +101,17 @@ describe('inbound gate holds while approval card is outstanding (#2841)', () =>
     expect(fn).toMatch(/hasPendingApproval\s*=\s*pendingPermissions\.size\s*>\s*0/)
   })
 
-  it('turnInFlightMachineOnly carries BOTH busy paths (legacy claudeBusyKeys + machine)', () => {
+  it('turnInFlightMachineOnly reads the delivery machine (sole gate, #2996 P1)', () => {
     // #3262: the machine-in-turn signal moved here (read by the /model & /effort
-    // resolver without the approval hold). Both the legacy claudeBusyKeys path
-    // and the machine-authoritative probeGateParity path must be present — a
-    // dropped branch would silently change the busy read.
+    // resolver without the approval hold). #2996 P1 deleted the legacy
+    // claudeBusyKeys branch and the gate-parity probe — the machine read is
+    // the ONLY busy source now; a reintroduced legacy branch would silently
+    // fork the busy read again.
     const fn = slice(GATEWAY, 'function turnInFlightMachineOnly()', 1400)
-    expect(fn).toMatch(/claudeBusyKeys\.size\s*>\s*0/)
-    expect(fn).toContain('probeGateParity(')
+    expect(fn).toContain('return isMachineInTurn()')
+    // Code-shape pins (comments may still narrate the deleted legacy design):
+    expect(fn).not.toMatch(/claudeBusyKeys\.size/)
+    expect(fn).not.toMatch(/probeGateParity\(/)
     // NOT gated by the approval hold — that stays in turnInFlightForGate.
     expect(fn).not.toContain('hasPendingApproval')
   })

package/telegram-plugin/tests/photo-reroute-wiring.test.ts

@@ -21,12 +21,15 @@ import { describe, it, expect } from 'vitest'
 import { readFileSync } from 'node:fs'
 import { resolve } from 'node:path'
 
+// #2996 P2: executeReply's body (incl. the file-send + result + history
+// block this suite pins) moved VERBATIM to outbound-send-path.ts
+// (`sendReply`); the slice reads there now. Assertions unchanged.
 const gatewaySrc = readFileSync(
-  resolve(__dirname, '..', 'gateway', 'gateway.ts'),
+  resolve(__dirname, '..', 'gateway', 'outbound-send-path.ts'),
   'utf-8',
 )
 
-// Slice executeReply's file-send + result + history block: from the
+// Slice sendReply's file-send + result + history block: from the
 // photo-precheck anchor to the recordOutbound call for replies.
 const sliceStart = gatewaySrc.indexOf('const photoPrecheck = new Map')
 const sliceEnd = gatewaySrc.indexOf('history recordOutbound (reply) failed')

package/telegram-plugin/tests/reply-terminal-reaction.test.ts

@@ -43,8 +43,10 @@ describe('#1713 + #1728 — reply tool reaction contract', () => {
     const fs = require('node:fs') as typeof import('node:fs')
     // eslint-disable-next-line @typescript-eslint/no-require-imports
     const path = require('node:path') as typeof import('node:path')
+    // #2996 P2: executeReply's body moved verbatim to outbound-send-path.ts
+    // (`sendReply`); the post-send block anchors live there now.
     const src = fs.readFileSync(
-      path.resolve(__dirname, '../gateway/gateway.ts'),
+      path.resolve(__dirname, '../gateway/outbound-send-path.ts'),
       'utf8',
     )
     // Find the executeReply post-send block — anchored on the
@@ -75,8 +77,10 @@ describe('#1713 + #1728 — reply tool reaction contract', () => {
     const fs = require('node:fs') as typeof import('node:fs')
     // eslint-disable-next-line @typescript-eslint/no-require-imports
     const path = require('node:path') as typeof import('node:path')
+    // #2996 P2: executeReply's body moved verbatim to outbound-send-path.ts
+    // (`sendReply`); the post-send block anchors live there now.
     const src = fs.readFileSync(
-      path.resolve(__dirname, '../gateway/gateway.ts'),
+      path.resolve(__dirname, '../gateway/outbound-send-path.ts'),
       'utf8',
     )
     const anchor = src.indexOf("fresh sendMessage from reply tool is a user-visible")

package/telegram-plugin/tests/secret-detect-oauth-code.test.ts

@@ -145,8 +145,9 @@ describe('auth-flow context rule — Channel B (structural wiring in gateway.ts)
   })
 
   it('reaps awaitingAuthCodeAt in the TTL reaper alongside other pending-state maps', () => {
-    // The pendingStateReaper interval must sweep expired auth-code-context entries
-    const reaperIdx = src.indexOf('pendingStateReaper = setInterval')
+    // The pendingStateReaper interval must sweep expired auth-code-context entries.
+    // Anchor tolerates the #2996 P0c `isGatewayMain ? setInterval(...)` boot gate.
+    const reaperIdx = src.indexOf('pendingStateReaper = ')
     expect(reaperIdx).toBeGreaterThan(0)
     const reaperBlock = src.slice(reaperIdx, reaperIdx + 800)
     expect(reaperBlock).toMatch(/awaitingAuthCodeAt/)