switchroom 0.18.31 → 0.18.33

package/telegram-plugin/tests/gateway-disconnect-flush.test.ts

@@ -51,19 +51,6 @@ function makeDeps(agentName: string | null) {
     ['chat1:thr1:msg1', 100],
     ['chat2:thr2:msg2', 200],
   ])
-  // PR3b: claudeBusyKeys tracks turns actually handed to claude. In a
-  // healthy registered-disconnect scenario both maps would carry the
-  // same keys (delivery succeeded); the dangling-sweep tests below
-  // override individual deps to exercise the orphaned-key path.
-  const claudeBusyKeys = new Set<string>([
-    'chat1:thr1:msg1',
-    'chat2:thr2:msg2',
-  ])
-  // #2787: shadow timestamp map, kept in lockstep with claudeBusyKeys.
-  const claudeBusyKeySince = new Map<string, number>([
-    ['chat1:thr1:msg1', 100],
-    ['chat2:thr2:msg2', 200],
-  ])
   const activeDraftStreams = new Map<string, FakeStream>([
     ['chat1:thr1:r1', { isFinal: () => false, finalize: finalizeA }],
     ['chat2:thr2:r2', { isFinal: () => true, finalize: finalizeB }],
@@ -79,8 +66,6 @@ function makeDeps(agentName: string | null) {
       activeStatusReactions,
       activeReactionMsgIds,
       activeTurnStartedAt,
-      claudeBusyKeys,
-      claudeBusyKeySince,
       activeDraftStreams,
       clearActiveReactions,
       disposeProgressDriver,
@@ -202,8 +187,6 @@ describe('flushOnAgentDisconnect — dangling-turn sweep (2026-05-23 wedge fix)'
         ['ghost:thr:msg', { chatId: 'ghost', messageId: 42 }],
       ]),
       activeTurnStartedAt: new Map<string, number>([['ghost:thr:msg', 100]]),
-      claudeBusyKeys: new Set<string>(['ghost:thr:msg']),
-      claudeBusyKeySince: new Map<string, number>([['ghost:thr:msg', 100]]),
       activeDraftStreams: new Map<string, FakeStream>(),
       clearActiveReactions,
       disposeProgressDriver,
@@ -214,10 +197,6 @@ describe('flushOnAgentDisconnect — dangling-turn sweep (2026-05-23 wedge fix)'
 
     flushOnAgentDisconnect(deps)
 
-    // PR3b: claudeBusyKeys swept alongside the activeTurnStartedAt
-    // dangling entry — both maps mirror each other on registered
-    // disconnects, so a key in one is always a key in the other.
-    expect(deps.claudeBusyKeys.size).toBe(0)
     // The sweep fired and cleared the dangling entry.
     expect(deps.activeTurnStartedAt.size).toBe(0)
     expect(deps.activeReactionMsgIds.size).toBe(0)
@@ -261,8 +240,6 @@ describe('flushOnAgentDisconnect — dangling-turn sweep (2026-05-23 wedge fix)'
       activeStatusReactions: new Map<string, FakeCtrl>(),
       activeReactionMsgIds: new Map<string, { chatId: string; messageId: number }>(),
       activeTurnStartedAt: new Map<string, number>([['real-turn:thr:msg', 100]]),
-      claudeBusyKeys: new Set<string>(['real-turn:thr:msg']),
-      claudeBusyKeySince: new Map<string, number>([['real-turn:thr:msg', 100]]),
       activeDraftStreams: new Map<string, FakeStream>(),
       clearActiveReactions: vi.fn(),
       disposeProgressDriver: vi.fn(),
@@ -278,109 +255,11 @@ describe('flushOnAgentDisconnect — dangling-turn sweep (2026-05-23 wedge fix)'
     expect(onDanglingTurnsSwept).not.toHaveBeenCalled()
   })
 
-  // PR3b orphan-sweep regression: synthetic-inbound deliveries
-  // (cron, reactions, vault, button-callback) bypass handleInbound's
-  // fresh-turn branch and so never stamp activeTurnStartedAt. They
-  // DO mark claudeBusyKeys. If their turn dies without turn_end, the
-  // activeTurnStartedAt-keyed dangling sweep misses them — orphan
-  // persists in claudeBusyKeys → fleet gate wedges. This test pins
-  // the post-sweep claudeBusyKeys.clear() fix.
-  it('sweeps claudeBusyKeys orphans that have NO activeTurnStartedAt entry (PR3b follow-up)', () => {
-    const onDanglingTurnsSwept = vi.fn()
-    const log = vi.fn()
-    const deps = {
-      agentName: 'clerk',
-      activeStatusReactions: new Map<string, FakeCtrl>(),
-      activeReactionMsgIds: new Map<string, { chatId: string; messageId: number }>(),
-      activeTurnStartedAt: new Map<string, number>(),
-      // The orphan scenario: claude was handed a turn (e.g. cron
-      // synthetic delivered), so claudeBusyKeys has it, but
-      // activeTurnStartedAt was never set because cron bypasses
-      // handleInbound's fresh-turn branch.
-      claudeBusyKeys: new Set<string>(['cron-only-key:_']),
-      claudeBusyKeySince: new Map<string, number>([['cron-only-key:_', 100]]),
-      activeDraftStreams: new Map<string, FakeStream>(),
-      clearActiveReactions: vi.fn(),
-      disposeProgressDriver: vi.fn(),
-      stopTurnTypingLoops: vi.fn(),
-      onDanglingTurnsSwept,
-      log,
-    }
-
-    flushOnAgentDisconnect(deps)
-
-    // The orphan is cleared even though it never had an
-    // activeTurnStartedAt entry.
-    expect(deps.claudeBusyKeys.size).toBe(0)
-    // The activeTurnStartedAt-keyed sweep wasn't fired (nothing in
-    // that map to sweep) — so onDanglingTurnsSwept shouldn't fire
-    // either. The orphan sweep is a separate observation.
-    expect(onDanglingTurnsSwept).not.toHaveBeenCalled()
-    // But it logs the orphan-clear so operators can see it.
-    expect(
-      log.mock.calls.some((c: unknown[]) =>
-        typeof c[0] === 'string' && /orphan claudeBusyKeys/.test(c[0]),
-      ),
-    ).toBe(true)
-  })
-
-  it('orphan-sweep singular vs plural log message agrees with count', () => {
-    // Tiny grammar regression: "1 entry" vs "2 entries".
-    const log = vi.fn()
-    const baseDeps = {
-      agentName: 'clerk',
-      activeStatusReactions: new Map<string, FakeCtrl>(),
-      activeReactionMsgIds: new Map<string, { chatId: string; messageId: number }>(),
-      activeTurnStartedAt: new Map<string, number>(),
-      activeDraftStreams: new Map<string, FakeStream>(),
-      clearActiveReactions: vi.fn(),
-      disposeProgressDriver: vi.fn(),
-      stopTurnTypingLoops: vi.fn(),
-    }
-    // Singular form.
-    flushOnAgentDisconnect({
-      ...baseDeps,
-      claudeBusyKeys: new Set<string>(['k1:_']),
-      claudeBusyKeySince: new Map<string, number>([['k1:_', 100]]),
-      log,
-    })
-    expect(log.mock.calls.some((c: unknown[]) =>
-      typeof c[0] === 'string' && / 1 orphan claudeBusyKeys entry /.test(c[0]),
-    )).toBe(true)
-    // Plural form.
-    log.mockClear()
-    flushOnAgentDisconnect({
-      ...baseDeps,
-      claudeBusyKeys: new Set<string>(['k1:_', 'k2:1']),
-      claudeBusyKeySince: new Map<string, number>([['k1:_', 100], ['k2:1', 100]]),
-      log,
-    })
-    expect(log.mock.calls.some((c: unknown[]) =>
-      typeof c[0] === 'string' && / 2 orphan claudeBusyKeys entries /.test(c[0]),
-    )).toBe(true)
-  })
-
-  it('does NOT fire orphan-sweep log when claudeBusyKeys is empty', () => {
-    // Zero-noise discipline: every disconnect for a healthy idle
-    // agent shouldn't produce a "0 orphan claudeBusyKeys" line.
-    const log = vi.fn()
-    flushOnAgentDisconnect({
-      agentName: 'clerk',
-      activeStatusReactions: new Map<string, FakeCtrl>(),
-      activeReactionMsgIds: new Map<string, { chatId: string; messageId: number }>(),
-      activeTurnStartedAt: new Map<string, number>(),
-      claudeBusyKeys: new Set<string>(),
-      claudeBusyKeySince: new Map<string, number>(),
-      activeDraftStreams: new Map<string, FakeStream>(),
-      clearActiveReactions: vi.fn(),
-      disposeProgressDriver: vi.fn(),
-      stopTurnTypingLoops: vi.fn(),
-      log,
-    })
-    expect(log.mock.calls.some((c: unknown[]) =>
-      typeof c[0] === 'string' && /orphan claudeBusyKeys/.test(c[0]),
-    )).toBe(false)
-  })
+  // (#2996 P1) The PR3b claudeBusyKeys orphan-sweep tests that lived here
+  // were deleted with the set itself — the delivery machine's bridgeDown
+  // event (emitted by the gateway alongside this flush) structurally
+  // clears the turn-in-flight gate for synthetic-delivered turns that
+  // died without a turn_end.
 
   it('omitting onDanglingTurnsSwept is safe (optional callback)', () => {
     // Backward-compat guard — existing callers that don't pass the new
@@ -390,8 +269,6 @@ describe('flushOnAgentDisconnect — dangling-turn sweep (2026-05-23 wedge fix)'
       activeStatusReactions: new Map<string, FakeCtrl>(),
       activeReactionMsgIds: new Map<string, { chatId: string; messageId: number }>(),
       activeTurnStartedAt: new Map<string, number>([['ghost:thr:msg', 100]]),
-      claudeBusyKeys: new Set<string>(['ghost:thr:msg']),
-      claudeBusyKeySince: new Map<string, number>([['ghost:thr:msg', 100]]),
       activeDraftStreams: new Map<string, FakeStream>(),
       clearActiveReactions: vi.fn(),
       disposeProgressDriver: vi.fn(),

package/telegram-plugin/tests/gateway-handler-registration-wiring.test.ts

@@ -0,0 +1,299 @@
+/**
+ * Registration-wiring pin for the #2996 P0a leaf move.
+ *
+ * P0a extracted the 62 top-level grammY registration statements — the 60
+ * `bot.use` / `bot.command` / `bot.on` / `bot.catch` calls PLUS the two
+ * interleaved handler-registering helpers (`registerOpsInfoCommands` and the
+ * terminal `installUnhandledMessageCatchAll`) — out of their previously
+ * module-scope-interspersed positions in gateway.ts and into a single
+ * `registerGatewayHandlers(bot, deps)` function, called exactly once at the
+ * same point in module evaluation as the old last registration.
+ *
+ * grammY middleware/handler ORDER is load-bearing — the admin-gate `bot.use`
+ * must run before any command, and the specific `message:*` handlers before
+ * the catch-all. This test is the deterministic guard that the move (and any
+ * future edit to the block) preserves the EXACT ordered registration
+ * sequence. It is outcome-asserting: it fails if a registration is dropped,
+ * reordered, duplicated, or added, and if any registration leaks back out to
+ * module top-level (which would change its evaluation order relative to the
+ * single call site).
+ *
+ * P0b (#2996) update: the single `registerGatewayHandlers(bot, {})` call moved
+ * OFF module top level into the boot function `initGatewayBot()` — because P0b
+ * defers `new Bot` construction to boot, so `bot` no longer exists at import.
+ * The call still fires exactly once, after construction and before the runner,
+ * preserving registration order. The call-site assertion below now pins that
+ * new location (zero top-level calls; exactly one inside initGatewayBot).
+ *
+ * The golden sequence below was captured from `origin/main` immediately
+ * BEFORE the move (parser-extracted top-level `bot.*` order) so the same
+ * assertion holds pre- and post-move — the ordered list is a behaviour
+ * invariant, not an artifact of the new structure.
+ *
+ * Source-parsing (not import) mirrors gateway-pending-command-wiring.test.ts:
+ * gateway.ts is not import-safe under vitest until the #2996 P0 importability
+ * seam lands, so we assert on the parsed source instead.
+ */
+
+import { describe, it, expect } from 'vitest'
+import { readFileSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+import { dirname, resolve } from 'node:path'
+import ts from 'typescript'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const GATEWAY_PATH = resolve(__dirname, '..', 'gateway', 'gateway.ts')
+const GATEWAY_SRC = readFileSync(GATEWAY_PATH, 'utf8')
+
+/**
+ * The frozen, ordered registration sequence. Order is significant — this is
+ * the exact top-level order captured from origin/main BEFORE the move.
+ * Format: `use` / `catch` (no name), `command:<name>`, `on:<event>`,
+ * `helper:<fn>` for the interleaved handler-registering helper calls.
+ */
+const GOLDEN_REGISTRATIONS: readonly string[] = [
+  'use',
+  'helper:registerStartInfoCommands',
+  'command:inject',
+  'command:compact',
+  'command:clear',
+  'helper:registerModelEffortCommands',
+  'command:agentstart',
+  'command:agentstop',
+  'command:stop',
+  'command:restart',
+  'command:new',
+  'command:update',
+  'command:upgradestatus',
+  'command:upgrade',
+  'command:audit',
+  'command:approve',
+  'command:deny',
+  'command:folders',
+  'command:pending',
+  'command:interrupt',
+  'command:connect',
+  'command:auth',
+  'command:vault',
+  'command:topics',
+  'command:logs',
+  'command:memory',
+  'command:issues',
+  'command:usage',
+  'helper:registerOpsInfoCommands',
+  'on:callback_query:data',
+  'on:message:text',
+  'on:message:photo',
+  'on:message:document',
+  'on:message:voice',
+  'on:message:audio',
+  'on:message:video',
+  'on:message:video_note',
+  'on:message:sticker',
+  'on:message:animation',
+  'on:message:contact',
+  'on:message:location',
+  'on:message:venue',
+  'on:message:poll',
+  'on:message:web_app_data',
+  'on:message:users_shared',
+  'on:message:chat_shared',
+  'on:message:dice',
+  'on:message:game',
+  'on:message:story',
+  'on:message:paid_media',
+  'on:message:successful_payment',
+  'on:message:passport_data',
+  'on:message:checklist_tasks_done',
+  'on:message:checklist_tasks_added',
+  'on:message:pinned_message',
+  'helper:installUnhandledMessageCatchAll',
+  'on:message_reaction',
+  'catch',
+]
+
+/**
+ * The interleaved handler-registering helper calls. Their position in the
+ * sequence is load-bearing: `installUnhandledMessageCatchAll` MUST come after
+ * every `message:*` handler (grammY no-double-handling; see
+ * catch-all-unhandled-message.test.ts) and before `message_reaction`.
+ */
+const HELPER_REGISTRARS = new Set(['registerOpsInfoCommands', 'registerStartInfoCommands', 'registerModelEffortCommands', 'installUnhandledMessageCatchAll'])
+
+const sourceFile = ts.createSourceFile(
+  GATEWAY_PATH,
+  GATEWAY_SRC,
+  ts.ScriptTarget.Latest,
+  true,
+  ts.ScriptKind.TS,
+)
+
+/** `bot.<verb>` for a CallExpression whose callee is `bot.<verb>`, else null. */
+function botVerb(expr: ts.Expression): string | null {
+  if (!ts.isCallExpression(expr)) return null
+  const callee = expr.expression
+  if (ts.isPropertyAccessExpression(callee) && ts.isIdentifier(callee.expression)) {
+    if (callee.expression.text === 'bot') return callee.name.text
+  }
+  return null
+}
+
+/** Unwrap a possibly `as`-cast string literal to its text; else null. */
+function stringArg(arg: ts.Expression | undefined): string | null {
+  if (!arg) return null
+  let node: ts.Expression = arg
+  if (ts.isAsExpression(node)) node = node.expression
+  if (ts.isStringLiteralLike(node)) return node.text
+  return null
+}
+
+/** Canonical signature for a registration statement, or null if not one. */
+function registrationSig(stmt: ts.Statement): string | null {
+  if (!ts.isExpressionStatement(stmt)) return null
+  const expr = stmt.expression
+  if (!ts.isCallExpression(expr)) return null
+  // Interleaved handler-registering helper: `helperName(bot, ...)`.
+  if (ts.isIdentifier(expr.expression) && HELPER_REGISTRARS.has(expr.expression.text)) {
+    return `helper:${expr.expression.text}`
+  }
+  const verb = botVerb(expr)
+  if (verb === null) return null
+  if (verb === 'command' || verb === 'on') {
+    const name = stringArg(expr.arguments[0])
+    return name === null ? `${verb}:<non-literal>` : `${verb}:${name}`
+  }
+  return verb // use / catch / anything else with no name key
+}
+
+function findFunction(name: string): ts.FunctionDeclaration | undefined {
+  for (const s of sourceFile.statements) {
+    if (ts.isFunctionDeclaration(s) && s.name?.text === name) return s
+  }
+  return undefined
+}
+
+describe('gateway #2996 P0a: registerGatewayHandlers is the single ordered registration unit', () => {
+  it('defines registerGatewayHandlers(bot, deps) at module top level', () => {
+    const fn = findFunction('registerGatewayHandlers')
+    expect(fn).toBeDefined()
+    expect(fn!.parameters.length).toBe(2)
+    expect(fn!.parameters[0].name.getText(sourceFile)).toBe('bot')
+    expect(fn!.parameters[1].name.getText(sourceFile)).toBe('deps')
+  })
+
+  it('registers the EXACT golden ordered sequence inside the function', () => {
+    const fn = findFunction('registerGatewayHandlers')
+    expect(fn?.body).toBeDefined()
+    const actual: string[] = []
+    for (const stmt of fn!.body!.statements) {
+      const sig = registrationSig(stmt)
+      if (sig !== null) actual.push(sig)
+    }
+    // Deep, ordered equality — fails on drop, reorder, duplicate, or add.
+    expect(actual).toEqual([...GOLDEN_REGISTRATIONS])
+  })
+
+  it('has no duplicate registrations', () => {
+    const fn = findFunction('registerGatewayHandlers')
+    const sigs: string[] = []
+    for (const stmt of fn!.body!.statements) {
+      const sig = registrationSig(stmt)
+      if (sig !== null) sigs.push(sig)
+    }
+    expect(new Set(sigs).size).toBe(sigs.length)
+  })
+
+  it('leaves ZERO bot.* registrations at module top level (all live in the function)', () => {
+    const leaked: string[] = []
+    for (const stmt of sourceFile.statements) {
+      const sig = registrationSig(stmt)
+      if (sig !== null) leaked.push(sig)
+    }
+    expect(leaked).toEqual([])
+  })
+
+  it('calls registerGatewayHandlers(bot, ...) exactly once, inside initGatewayBot (P0b), never at module top level', () => {
+    // P0b (#2996): the call moved off module top level into the boot function
+    // initGatewayBot(). Assert (a) ZERO top-level calls — proving the deferral —
+    // and (b) exactly one call in the whole file, with `bot` as its first arg,
+    // located inside initGatewayBot's body.
+    let topLevelCalls = 0
+    for (const stmt of sourceFile.statements) {
+      if (
+        ts.isExpressionStatement(stmt) &&
+        ts.isCallExpression(stmt.expression) &&
+        ts.isIdentifier(stmt.expression.expression) &&
+        stmt.expression.expression.text === 'registerGatewayHandlers'
+      ) {
+        topLevelCalls++
+      }
+    }
+    expect(topLevelCalls).toBe(0)
+
+    // Count every registerGatewayHandlers(...) call anywhere in the module, and
+    // record whether it is lexically inside the initGatewayBot function.
+    const initGatewayBot = findFunction('initGatewayBot')
+    expect(initGatewayBot).toBeDefined()
+    const initStart = initGatewayBot!.getStart(sourceFile)
+    const initEnd = initGatewayBot!.getEnd()
+
+    let totalCalls = 0
+    let callsInsideInit = 0
+    const visit = (node: ts.Node): void => {
+      if (
+        ts.isCallExpression(node) &&
+        ts.isIdentifier(node.expression) &&
+        node.expression.text === 'registerGatewayHandlers'
+      ) {
+        totalCalls++
+        // first arg is the bot singleton
+        expect(node.arguments[0]?.getText(sourceFile)).toBe('bot')
+        const start = node.getStart(sourceFile)
+        if (start >= initStart && node.getEnd() <= initEnd) callsInsideInit++
+      }
+      ts.forEachChild(node, visit)
+    }
+    visit(sourceFile)
+
+    expect(totalCalls).toBe(1)
+    expect(callsInsideInit).toBe(1)
+  })
+
+  it('registers the admin-gate middleware (bot.use) FIRST and the error boundary (bot.catch) LAST', () => {
+    const fn = findFunction('registerGatewayHandlers')
+    const sigs: string[] = []
+    for (const stmt of fn!.body!.statements) {
+      const sig = registrationSig(stmt)
+      if (sig !== null) sigs.push(sig)
+    }
+    expect(sigs[0]).toBe('use')
+    expect(sigs[sigs.length - 1]).toBe('catch')
+    // the catch-all-ish specific media handlers precede message_reaction, which
+    // precedes the error boundary
+    expect(sigs.indexOf('on:message:text')).toBeGreaterThan(sigs.indexOf('use'))
+    expect(sigs.indexOf('on:message_reaction')).toBeGreaterThan(sigs.indexOf('on:message:text'))
+  })
+
+  it('installs the terminal catch-all AFTER every message:* handler and before message_reaction', () => {
+    const fn = findFunction('registerGatewayHandlers')
+    const sigs: string[] = []
+    for (const stmt of fn!.body!.statements) {
+      const sig = registrationSig(stmt)
+      if (sig !== null) sigs.push(sig)
+    }
+    const catchAllIdx = sigs.indexOf('helper:installUnhandledMessageCatchAll')
+    expect(catchAllIdx).toBeGreaterThan(0)
+    // Every message:* handler precedes the catch-all (grammY no-double-handling).
+    const messageHandlers = sigs.filter(s => /^on:message(:|$)/.test(s) && s !== 'on:message_reaction')
+    expect(messageHandlers.length).toBeGreaterThan(0)
+    for (const mh of messageHandlers) {
+      expect(sigs.indexOf(mh)).toBeLessThan(catchAllIdx)
+    }
+    // message_reaction (a different update type) is registered AFTER the catch-all.
+    expect(sigs.indexOf('on:message_reaction')).toBeGreaterThan(catchAllIdx)
+    // ops-info commands register between the last /command and callback_query:data.
+    const opsIdx = sigs.indexOf('helper:registerOpsInfoCommands')
+    expect(opsIdx).toBeGreaterThan(sigs.indexOf('command:usage'))
+    expect(opsIdx).toBeLessThan(sigs.indexOf('on:callback_query:data'))
+  })
+})

package/telegram-plugin/tests/gateway-loopback-paste-redact.test.ts

@@ -3,42 +3,50 @@ import { readFileSync } from 'node:fs'
 
 /**
  * Structural integration test for the loopback-paste fail-safe redaction in
- * the gateway's inbound handler (security audit #3084, F2/F3).
+ * the inbound intercept gauntlet (security audit #3084, F2/F3).
  *
- * Why structural: gateway/gateway.ts does not export its inbound handler, so a
- * pure-functional invocation would require end-to-end harnessing of
- * Bot/Grammy/Context. The decision predicate (shouldConsumeLoopbackPaste, incl.
+ * Why structural: the decision predicate (shouldConsumeLoopbackPaste, incl.
  * the malformed-paste fail-safe) is exhaustively unit-tested in
  * `auth-loopback-relay.test.ts`, and the redaction primitive
  * (redactAuthCodeMessage) in `auth-code-redact.test.ts`. What's left to assert
- * here is that the gateway actually WIRES a fail-safe so a code-bearing paste
- * that is malformed, or arrives just after the intercept TTL, or has no active
- * flow, is redacted + dropped rather than forwarded to the agent.
+ * here is that the intercept path actually WIRES a fail-safe so a code-bearing
+ * paste that is malformed, or arrives just after the intercept TTL, or has no
+ * active flow, is redacted + dropped rather than forwarded to the agent.
  *
- * The invariants:
+ * P7 PR-6 (#2996): the intercept body (pending-flow branch + fail-safe tail)
+ * moved verbatim into gateway/inbound-interceptors.ts
+ * (`interceptLoopbackRelay`); gateway.ts keeps the ordered delegation. The
+ * invariants are unchanged — only the file that owns each literal moved:
  *   1. The stale (TTL-expired) loopback branch does NOT let the paste fall
- *      through to the agent — it flows into the fail-safe below.
- *   2. A fail-safe `if (shouldConsumeLoopbackPaste(text))` block exists that
- *      redacts (redactAuthCodeMessage) and returns, sitting AFTER the
- *      pending-flow branch but BEFORE the generic auth-code / agent-forward
- *      handlers.
+ *      through to the agent — it flows into the fail-safe below it.
+ *   2. A fail-safe `if (shouldConsumeLoopbackPaste(p.text))` block exists that
+ *      redacts (deps.redactAuthCode → redactAuthCodeMessage) and returns
+ *      handled, sitting AFTER the pending-flow branch; the gateway invokes the
+ *      loopback intercept BEFORE the generic auth-code / reauth intercept.
  */
 describe('gateway loopback-paste fail-safe redaction — structural wiring', () => {
-  const src = readFileSync(
+  const gatewaySrc = readFileSync(
     new URL('../gateway/gateway.ts', import.meta.url),
     'utf8',
   )
+  const interceptorsSrc = readFileSync(
+    new URL('../gateway/inbound-interceptors.ts', import.meta.url),
+    'utf8',
+  )
 
-  it('imports the consume predicate + redaction helper', () => {
-    expect(src).toMatch(/shouldConsumeLoopbackPaste/)
-    expect(src).toMatch(/redactAuthCodeMessage/)
+  it('wires the consume predicate + redaction helper', () => {
+    // The intercept module owns the predicate; the gateway binds the
+    // redaction closure (deps.redactAuthCode → redactAuthCodeMessage).
+    expect(interceptorsSrc).toMatch(/shouldConsumeLoopbackPaste/)
+    expect(gatewaySrc).toMatch(/redactAuthCodeMessage/)
+    expect(gatewaySrc).toMatch(/interceptLoopbackRelay\(/)
   })
 
   it('has a fail-safe redact-and-return block guarded by shouldConsumeLoopbackPaste', () => {
-    // Isolate the fail-safe block: `if (shouldConsumeLoopbackPaste(text)) { ... }`
+    // Isolate the fail-safe block: `if (shouldConsumeLoopbackPaste(p.text)) { ... }`
     // that is NOT part of the `pendingLoop && ...` pending-flow branch.
-    const failSafe = src.match(
-      /if \(shouldConsumeLoopbackPaste\(text\)\) \{[\s\S]{0,600}?\n {2}\}/g,
+    const failSafe = interceptorsSrc.match(
+      /if \(shouldConsumeLoopbackPaste\(p\.text\)\) \{[\s\S]{0,700}?\n {2}\}/g,
     )
     expect(failSafe).not.toBeNull()
     // The standalone fail-safe (the one NOT preceded by `pendingLoop &&`).
@@ -46,21 +54,28 @@ describe('gateway loopback-paste fail-safe redaction — structural wiring', ()
       (b) => !b.startsWith('if (pendingLoop'),
     )
     expect(standalone).toBeDefined()
-    expect(standalone!).toMatch(/redactAuthCodeMessage/)
-    expect(standalone!).toMatch(/return/)
+    expect(standalone!).toMatch(/deps\.redactAuthCode/)
+    expect(standalone!).toMatch(/return \{ handled: true \}/)
   })
 
   it('the stale loopback branch falls through to the fail-safe (does not forward)', () => {
-    // The stale-path comment must reference the fail-safe, and the fail-safe
-    // block must appear AFTER the pending-loop branch and BEFORE the generic
-    // auth-code intercept (`pendingReauthFlows`).
-    const failSafeIdx = src.indexOf(
+    // The fail-safe block must appear AFTER the pending-loop branch inside the
+    // intercept module; and the gateway must invoke the loopback intercept
+    // BEFORE the generic auth-code intercept (`pendingReauthFlows`).
+    const failSafeIdx = interceptorsSrc.indexOf(
       'Fail-safe redaction (security audit #3084, F2/F3)',
     )
-    const pendingLoopIdx = src.indexOf('const pendingLoop = pendingLoopbackFlows.get')
-    const reauthIdx = src.indexOf('const pendingReauth = pendingReauthFlows.get')
+    const pendingLoopIdx = interceptorsSrc.indexOf(
+      'const pendingLoop = pendingLoopbackFlows.get',
+    )
     expect(failSafeIdx).toBeGreaterThan(-1)
     expect(failSafeIdx).toBeGreaterThan(pendingLoopIdx)
-    expect(reauthIdx).toBeGreaterThan(failSafeIdx)
+
+    const loopbackCallIdx = gatewaySrc.indexOf('interceptLoopbackRelay(')
+    // P7 PR-7: the reauth intercept body also moved; its gateway call site is
+    // the ordering anchor.
+    const reauthIdx = gatewaySrc.indexOf('interceptReauth(')
+    expect(loopbackCallIdx).toBeGreaterThan(-1)
+    expect(reauthIdx).toBeGreaterThan(loopbackCallIdx)
   })
 })

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

@@ -22,6 +22,19 @@ describe('gateway outbound secret-scrub — structural wiring', () => {
     new URL('../gateway/gateway.ts', import.meta.url),
     'utf8',
   )
+  // #2996 P2: executeReply's body moved VERBATIM to outbound-send-path.ts
+  // (`sendReply`); the reply-path scrub-ordering assertion reads there. The
+  // injected redactor (`redactOutboundText`) still lives in gateway.ts.
+  const sendPathSrc = readFileSync(
+    new URL('../gateway/outbound-send-path.ts', import.meta.url),
+    'utf8',
+  )
+  // #2996 P4-A: the turn-flush backstop scrub lives in handleSessionEvent,
+  // which moved VERBATIM to stream-render.ts.
+  const streamSrc = readFileSync(
+    new URL('../gateway/stream-render.ts', import.meta.url),
+    'utf8',
+  )
 
   it('imports the shared redactor', () => {
     expect(src).toMatch(/import \{ redact \} from '\.\.\/secret-detect\/redact\.js'/)
@@ -39,9 +52,9 @@ describe('gateway outbound secret-scrub — structural wiring', () => {
     // 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(`normalizeOutboundBody(rawText, 'reply', redactOutboundText)`, start)
-    const previewIdx = src.indexOf('reply: invoked chatId=', start)
+    const start = sendPathSrc.indexOf('export async function sendReply(')
+    const redactIdx = sendPathSrc.indexOf(`normalizeOutboundBody(rawText, 'reply', redactOutboundText)`, start)
+    const previewIdx = sendPathSrc.indexOf('reply: invoked chatId=', start)
     expect(start).toBeGreaterThan(0)
     expect(redactIdx).toBeGreaterThan(start)
     expect(previewIdx).toBeGreaterThan(redactIdx) // mask BEFORE the preview is logged
@@ -59,8 +72,8 @@ describe('gateway outbound secret-scrub — structural wiring', () => {
   it('turn-flush backstop: scrubs the model terminal prose before send', () => {
     // Turn-flush delivers the model's answer when it skipped reply/stream_reply
     // — arbitrary agent free-text that hits the wire + stderr preview.
-    const redactIdx = src.indexOf(`redactOutboundText(capturedText, 'turn_flush')`)
-    const scrubSiteIdx = src.indexOf(`site: 'turn_flush'`)
+    const redactIdx = streamSrc.indexOf(`redactOutboundText(capturedText, 'turn_flush')`)
+    const scrubSiteIdx = streamSrc.indexOf(`site: 'turn_flush'`)
     expect(redactIdx).toBeGreaterThan(0)
     expect(scrubSiteIdx).toBeGreaterThan(redactIdx) // mask BEFORE the voice scrub + send
   })

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

@@ -15,6 +15,10 @@ import { readFileSync } from 'node:fs'
  */
 describe('request_secret — gateway wiring', () => {
   const gw = readFileSync(new URL('../gateway/gateway.ts', import.meta.url), 'utf8')
+  // executeRequestSecret moved verbatim to card-tool-handlers.ts (#2996 P5-tail);
+  // the handler-body pins below read that module. The dispatch case + the
+  // secure-capture path (captureProvidedSecret / handleInbound) stay in gateway.ts.
+  const cardTool = readFileSync(new URL('../gateway/card-tool-handlers.ts', import.meta.url), 'utf8')
   const bridge = readFileSync(new URL('../bridge/bridge.ts', import.meta.url), 'utf8')
 
   it('declares the MCP tool with required {chat_id,key} and NO value arg', () => {
@@ -30,7 +34,7 @@ describe('request_secret — gateway wiring', () => {
 
   it('is allow-listed and dispatched', () => {
     expect(gw).toMatch(/'request_secret',\n/)
-    expect(gw).toMatch(/case 'request_secret':\s*\n\s*return executeRequestSecret\(args\)/)
+    expect(gw).toMatch(/case 'request_secret':\s*\n\s*return cardToolHandlers\.executeRequestSecret\(args\)/)
   })
 
   it('routes the vsp: callback', () => {
@@ -71,8 +75,8 @@ describe('request_secret — gateway wiring', () => {
   })
 
   it('dedupes to one open request per (chat,key)', () => {
-    const idx = gw.indexOf('async function executeRequestSecret(')
-    const body = gw.slice(idx, idx + 1800)
+    const idx = cardTool.indexOf('async function executeRequestSecret(')
+    const body = cardTool.slice(idx, idx + 1800)
     expect(body).toMatch(/p\.chat_id === chat_id && p\.key === key/)
   })
 })