switchroom 0.18.32 → 0.19.0

package/telegram-plugin/tests/photo-message-handler.test.ts

@@ -0,0 +1,114 @@
+/**
+ * Outcome pins for the photo inbound handler extracted from gateway.ts
+ * (switchroom#2996 P6 cluster D). Unlike the metadata-only attachment handlers,
+ * photo downloads the largest size from the Telegram CDN into the inbox and
+ * returns the on-disk path as the coalesced image. The download closure is
+ * driven here against a fake grammy ctx + fetch, pinning: caption-or-fallback
+ * envelope, largest-size selection, inbox write, and token redaction on error.
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { mkdtempSync, rmSync, readFileSync, existsSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { handlePhotoMessage, type PhotoHandlerDeps } from '../gateway/photo-message-handler.js'
+
+const TOKEN = '123:SECRET-TOKEN'
+let inboxDir: string
+
+function makeDeps(overrides: Partial<PhotoHandlerDeps> = {}) {
+  const logs: string[] = []
+  // capture the download closure passed to handleInboundCoalesced so the test
+  // can invoke it and assert the returned path.
+  let captured: { text: string; download?: () => Promise<string | undefined> } | undefined
+  const handleInboundCoalesced = vi.fn(async (_ctx: any, text: string, download: any) => {
+    captured = { text, download }
+  })
+  const deps: PhotoHandlerDeps = {
+    handleInboundCoalesced,
+    getToken: () => TOKEN,
+    inboxDir,
+    log: line => logs.push(line),
+    ...overrides,
+  }
+  return { deps, handleInboundCoalesced, logs, getCaptured: () => captured }
+}
+
+function ctxWith(photo: unknown[], caption?: string, getFile?: any): any {
+  return {
+    message: { photo, caption },
+    api: { getFile: getFile ?? vi.fn() },
+    chat: { id: 42 },
+  }
+}
+
+beforeEach(() => {
+  inboxDir = mkdtempSync(join(tmpdir(), 'photo-inbox-'))
+})
+afterEach(() => {
+  rmSync(inboxDir, { recursive: true, force: true })
+  vi.restoreAllMocks()
+})
+
+describe('handlePhotoMessage', () => {
+  it('uses the caption as the envelope, falling back to (photo)', async () => {
+    const { deps, handleInboundCoalesced } = makeDeps()
+    await handlePhotoMessage(ctxWith([{ file_id: 'p1', file_unique_id: 'u1' }]), deps)
+    expect(handleInboundCoalesced.mock.calls[0][1]).toBe('(photo)')
+
+    const { deps: deps2, handleInboundCoalesced: h2 } = makeDeps()
+    await handlePhotoMessage(ctxWith([{ file_id: 'p1', file_unique_id: 'u1' }], 'look'), deps2)
+    expect(h2.mock.calls[0][1]).toBe('look')
+  })
+
+  it('downloads the largest size and writes it into the inbox', async () => {
+    const getFile = vi.fn(async () => ({ file_path: 'photos/big.jpg' }))
+    const ctx = ctxWith(
+      [{ file_id: 'small', file_unique_id: 'us' }, { file_id: 'big', file_unique_id: 'ub' }],
+      undefined,
+      getFile,
+    )
+    const { deps, getCaptured } = makeDeps()
+    const fetchSpy = vi.spyOn(globalThis, 'fetch').mockResolvedValue(
+      new Response(new Uint8Array([1, 2, 3]), { status: 200 }),
+    )
+    await handlePhotoMessage(ctx, deps)
+    const dlPath = await getCaptured()!.download!()
+    // Largest (last) size selected.
+    expect(getFile).toHaveBeenCalledWith('big')
+    // Token embedded in the CDN URL.
+    expect(fetchSpy.mock.calls[0][0]).toContain(`/bot${TOKEN}/photos/big.jpg`)
+    expect(dlPath).toBeDefined()
+    expect(existsSync(dlPath!)).toBe(true)
+    expect(Array.from(readFileSync(dlPath!))).toEqual([1, 2, 3])
+  })
+
+  it('returns undefined and logs HTTP status on a failed download', async () => {
+    const getFile = vi.fn(async () => ({ file_path: 'photos/x.jpg' }))
+    const { deps, getCaptured, logs } = makeDeps()
+    vi.spyOn(globalThis, 'fetch').mockResolvedValue(new Response(null, { status: 502 }))
+    await handlePhotoMessage(ctxWith([{ file_id: 'p', file_unique_id: 'u' }], undefined, getFile), deps)
+    const dlPath = await getCaptured()!.download!()
+    expect(dlPath).toBeUndefined()
+    expect(logs.some(l => l.includes('HTTP 502'))).toBe(true)
+  })
+
+  it('redacts the bot token from a thrown error message', async () => {
+    const getFile = vi.fn(async () => ({ file_path: 'photos/x.jpg' }))
+    const { deps, getCaptured, logs } = makeDeps()
+    vi.spyOn(globalThis, 'fetch').mockRejectedValue(new Error(`connect failed to bot${TOKEN}/x`))
+    await handlePhotoMessage(ctxWith([{ file_id: 'p', file_unique_id: 'u' }], undefined, getFile), deps)
+    const dlPath = await getCaptured()!.download!()
+    expect(dlPath).toBeUndefined()
+    const line = logs.find(l => l.startsWith('telegram gateway: photo download failed:'))!
+    expect(line).toContain('<REDACTED>')
+    expect(line).not.toContain(TOKEN)
+  })
+
+  it('returns undefined when the file has no path', async () => {
+    const getFile = vi.fn(async () => ({}))
+    const { deps, getCaptured } = makeDeps()
+    await handlePhotoMessage(ctxWith([{ file_id: 'p', file_unique_id: 'u' }], undefined, getFile), deps)
+    expect(await getCaptured()!.download!()).toBeUndefined()
+  })
+})

package/telegram-plugin/tests/pinned-message-handler.test.ts

@@ -0,0 +1,108 @@
+/**
+ * Outcome pins for the `message:pinned_message` service-message cleanup handler
+ * extracted from gateway.ts (switchroom#2996 P6 cluster F). Asserts the
+ * chat-scoped ownership guard (only OUR pins get their service message
+ * deleted), the reconcile-store race retry, and best-effort logging on a
+ * delete failure — against injected pin-state maps + a mock deleteServiceMessage.
+ */
+
+import { describe, it, expect, vi } from 'vitest'
+import {
+  handlePinnedMessage,
+  type PinnedMessageHandlerDeps,
+} from '../gateway/pinned-message-handler.js'
+
+function makeDeps(over: Partial<PinnedMessageHandlerDeps> = {}) {
+  const deleteServiceMessage = vi.fn(async () => {})
+  const log = vi.fn()
+  const deps: PinnedMessageHandlerDeps = {
+    statusPinState: new Map(),
+    statusPinChatIds: new Map(),
+    deleteServiceMessage,
+    log,
+    ...over,
+  }
+  return { deps, deleteServiceMessage, log }
+}
+
+function ctxWith(chatId: number, pinnedMessageId: number | undefined, serviceMsgId = 999): any {
+  return {
+    msg: {
+      message_id: serviceMsgId,
+      pinned_message: pinnedMessageId == null ? undefined : { message_id: pinnedMessageId },
+    },
+    chat: { id: chatId },
+  }
+}
+
+describe('handlePinnedMessage — ownership guard', () => {
+  it('deletes the service message when the pin is ours in this chat', async () => {
+    const { deps, deleteServiceMessage } = makeDeps({
+      statusPinState: new Map([['fg:a', { messageId: 555 }]]),
+      statusPinChatIds: new Map([['fg:a', '42']]),
+    })
+    await handlePinnedMessage(ctxWith(42, 555, 999), deps)
+    expect(deleteServiceMessage).toHaveBeenCalledWith('42', 999)
+  })
+
+  it('does NOT delete when the pinned id matches but the tracked chat differs', async () => {
+    const { deps, deleteServiceMessage } = makeDeps({
+      statusPinState: new Map([['fg:a', { messageId: 555 }]]),
+      statusPinChatIds: new Map([['fg:a', '99']]), // tracked in a DIFFERENT chat
+    })
+    await handlePinnedMessage(ctxWith(42, 555, 999), deps)
+    expect(deleteServiceMessage).not.toHaveBeenCalled()
+  })
+
+  it('does nothing when there is no pinned_message id', async () => {
+    const { deps, deleteServiceMessage } = makeDeps()
+    await handlePinnedMessage(ctxWith(42, undefined), deps)
+    expect(deleteServiceMessage).not.toHaveBeenCalled()
+  })
+
+  it('does not delete an untracked (operator-manual) pin', async () => {
+    const { deps, deleteServiceMessage } = makeDeps()
+    await handlePinnedMessage(ctxWith(42, 555, 999), deps)
+    expect(deleteServiceMessage).not.toHaveBeenCalled()
+  })
+})
+
+describe('handlePinnedMessage — reconcile-store race', () => {
+  it('re-checks ownership once after the store catches up', async () => {
+    // REAL timers on purpose: this suite also runs under `bun test`, whose
+    // vitest shim does not support vi.useFakeTimers — fake timers here left
+    // the global clock mocked and hung the NEXT test file in CI (the exact
+    // #3354 bun-test failure). The handler waits 250ms before its single
+    // re-check; populate the store inside that window and await the real
+    // delay.
+    const state = new Map<string, { messageId: number }>()
+    const chatIds = new Map<string, string>()
+    const { deps, deleteServiceMessage } = makeDeps({
+      statusPinState: state,
+      statusPinChatIds: chatIds,
+    })
+    const p = handlePinnedMessage(ctxWith(42, 555, 999), deps)
+    // Store catches up during the 250ms race window.
+    state.set('fg:a', { messageId: 555 })
+    chatIds.set('fg:a', '42')
+    await p
+    expect(deleteServiceMessage).toHaveBeenCalledWith('42', 999)
+  })
+})
+
+describe('handlePinnedMessage — best-effort delete failure', () => {
+  it('logs a concise reason when the delete throws', async () => {
+    const { deps, log } = makeDeps({
+      statusPinState: new Map([['fg:a', { messageId: 555 }]]),
+      statusPinChatIds: new Map([['fg:a', '42']]),
+      deleteServiceMessage: vi.fn(async () => {
+        throw new Error('not enough rights')
+      }),
+    })
+    await handlePinnedMessage(ctxWith(42, 555, 999), deps)
+    expect(log).toHaveBeenCalledTimes(1)
+    const line = log.mock.calls[0][0] as string
+    expect(line).toContain('could not delete pin service message')
+    expect(line).toContain('not enough rights')
+  })
+})

package/telegram-plugin/tests/render/render.test.ts

@@ -143,6 +143,48 @@ describe("render: inline palette", () => {
   });
 });
 
+describe("render: line-leading issue refs are not headings (#3304 regression)", () => {
+  it("multi-line message whose first line starts with #3304 stays a paragraph", () => {
+    const md = "#3304 is merged. The regression suite is green.\n\nNext up: the follow-up PR.";
+    const doc = parse(md);
+    // Spec-correct parse: `#` without a following space is NOT an ATX heading.
+    expect(doc.blocks.map((b) => b.type)).toEqual(["paragraph", "paragraph"]);
+
+    const out = render(doc);
+    // The line-leading `#` must be escaped so Telegram's non-spec rich parser
+    // cannot promote the line to a heading...
+    expect(out.startsWith("\\#3304 is merged.")).toBe(true);
+    expect(out).not.toMatch(/^#{1,6} /m);
+    // ...and the escape resolves back to the literal "#3304" on re-parse
+    // (what the reader sees), with no heading node anywhere.
+    const reparsed = parse(out);
+    expect(reparsed.blocks.map((b) => b.type)).toEqual(["paragraph", "paragraph"]);
+    expect((reparsed.blocks[0] as any).children[0].text).toContain("#3304 is merged.");
+  });
+
+  it("issue ref at line start mid-message is escaped too", () => {
+    const md = "Shipped today:\n#123 closes the loop on retries.";
+    const out = render(parse(md));
+    expect(out).toContain("\n\\#123 closes the loop");
+    const reparsed = parse(out);
+    expect(reparsed.blocks.every((b) => b.type !== "heading")).toBe(true);
+  });
+
+  it("a genuine `# Heading` still renders as a heading", () => {
+    const md = "# Release notes\n\n#456 fixed the flake.";
+    const out = render(parse(md));
+    expect(out.startsWith("# Release notes")).toBe(true);
+    expect(out).toContain("\\#456 fixed the flake.");
+    const reparsed = parse(out);
+    expect(reparsed.blocks[0].type).toBe("heading");
+  });
+
+  it("mid-line `#` is left alone", () => {
+    const md = "merged in PR #789 yesterday";
+    expect(render(parse(md))).toBe(md);
+  });
+});
+
 describe("render: block palette", () => {
   it("heading levels 1-6", () => {
     for (let level = 1; level <= 6; level++) {

package/telegram-plugin/tests/secret-detect-delete-must-surface-failures.test.ts

@@ -31,10 +31,14 @@ import { describe, it, expect } from "vitest";
 import { readFileSync } from "node:fs";
 import { resolve } from "node:path";
 
-const gatewaySrc = readFileSync(
-  resolve(__dirname, "..", "gateway", "gateway.ts"),
-  "utf-8",
-);
+const gatewaySrc =
+  readFileSync(resolve(__dirname, "..", "gateway", "gateway.ts"), "utf-8") +
+  "\n" +
+  // P7 PR-9 (#2996): the secret-detect pipeline intercept moved verbatim into
+  // gateway/inbound-interceptors.ts (interceptSecretDetectPipeline); the
+  // FAIL-CLOSED block anchor now resolves there. deleteSensitiveMessage is
+  // injected via deps but every branch still routes through it.
+  readFileSync(resolve(__dirname, "..", "gateway", "inbound-interceptors.ts"), "utf-8");
 
 /** Slice the gateway source between two anchor strings. */
 function sliceBetween(src: string, from: string, to: string): string {

package/telegram-plugin/tests/secret-detect-fail-closed.test.ts

@@ -19,10 +19,20 @@ import { readFileSync } from 'node:fs'
  * bytes directly.
  */
 describe('secret-detect pipeline fail-closed contract (gateway)', () => {
-  const src = readFileSync(
+  // P7 PR-9 (#2996): the pipeline intercept (incl. the fail-closed catch)
+  // moved verbatim into gateway/inbound-interceptors.ts
+  // (interceptSecretDetectPipeline). The catch now returns `{ handled: true }`
+  // and the gateway call site early-returns on `handled` BEFORE the sinks —
+  // the contract is unchanged, split across the seam.
+  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',
+  )
+  const src = gatewaySrc + '\n' + interceptorsSrc
 
   it('has exactly one [secret-detect] pipeline error catch marker', () => {
     const matches = src.match(/\[secret-detect\] pipeline error/g) ?? []
@@ -30,25 +40,23 @@ describe('secret-detect pipeline fail-closed contract (gateway)', () => {
   })
 
   it('the catch block around runPipeline returns (does not fall through to recordInbound / broadcast)', () => {
-    const idx = src.indexOf('[secret-detect] pipeline error')
+    // Interceptor side: after the error marker, the catch must return
+    // `{ handled: true }` (drop) — never fall out of the catch body.
+    const idx = interceptorsSrc.indexOf('[secret-detect] pipeline error')
     expect(idx).toBeGreaterThan(0)
-
-    // The fail-closed `return` must appear BEFORE the next recordInbound()
-    // and ipcServer.broadcast() calls. We scan forward from the error-log
-    // marker for the first top-level `return` statement (indented by 4
-    // spaces, matching the handleInbound body style).
-    const tail = src.slice(idx)
-    const returnMatch = tail.match(/\n {4}return\b/)
-    expect(returnMatch).not.toBeNull()
-    const returnOffset = returnMatch!.index!
-    const recordOffset = tail.indexOf('recordInbound(')
-    const broadcastOffset = tail.indexOf('ipcServer.broadcast(inboundMsg)')
-    // Both sinks are further down the function body; the fail-closed
-    // return must come first.
-    expect(recordOffset).toBeGreaterThan(0)
-    expect(broadcastOffset).toBeGreaterThan(0)
-    expect(returnOffset).toBeLessThan(recordOffset)
-    expect(returnOffset).toBeLessThan(broadcastOffset)
+    const tail = interceptorsSrc.slice(idx, idx + 2000)
+    expect(tail).toMatch(/\n\s*return \{ handled: true \}/)
+    // Gateway side: the delegation early-returns on `handled` BEFORE both
+    // sinks, so a dropped message can never reach them.
+    const callIdx = gatewaySrc.indexOf('await interceptSecretDetectPipeline(')
+    expect(callIdx).toBeGreaterThan(0)
+    const afterCall = gatewaySrc.slice(callIdx)
+    const handledReturn = afterCall.indexOf('if (secretOutcome.handled) return')
+    const recordOffset = afterCall.indexOf('recordInbound(')
+    const broadcastOffset = afterCall.indexOf('ipcServer.broadcast(inboundMsg)')
+    expect(handledReturn).toBeGreaterThan(0)
+    expect(recordOffset).toBeGreaterThan(handledReturn)
+    expect(broadcastOffset).toBeGreaterThan(handledReturn)
   })
 
   it('catch body warns the user that the message was dropped', () => {
@@ -58,15 +66,17 @@ describe('secret-detect pipeline fail-closed contract (gateway)', () => {
   })
 
   it('no path exists where recordInbound or broadcast is called with the raw effectiveText after a pipeline throw', () => {
-    // Structural guarantee: between the catch marker and the next sink
-    // there must be a `return` — otherwise a thrown pipeline error could
-    // flow through.
-    const catchIdx = src.indexOf('[secret-detect] pipeline error')
-    const afterCatch = src.slice(catchIdx)
-    const recordIdx = afterCatch.indexOf('recordInbound(')
-    expect(recordIdx).toBeGreaterThan(0)
-    const gap = afterCatch.slice(0, recordIdx)
-    expect(gap).toMatch(/\n\s*return\b/)
+    // Structural guarantee across the seam: the interceptor catch returns
+    // handled:true, and the gateway adopts the scrubbed effectiveText only
+    // on the handled:false path — there is no branch that reaches the sinks
+    // after a throw. Pin: the catch body ends in `return { handled: true }`
+    // with no intervening effectiveText pass-through.
+    const catchIdx = interceptorsSrc.indexOf('[secret-detect] pipeline error')
+    expect(catchIdx).toBeGreaterThan(0)
+    const catchTail = interceptorsSrc.slice(catchIdx, catchIdx + 2000)
+    const returnIdx = catchTail.search(/\n\s*return \{ handled: true \}/)
+    expect(returnIdx).toBeGreaterThan(0)
+    expect(catchTail.slice(0, returnIdx)).not.toMatch(/handled: false/)
   })
 
   it('server.ts no longer contains the secret-detect intercept', () => {

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

@@ -98,10 +98,12 @@ describe('anthropic_oauth_code pattern — Channel A', () => {
 // ─── Channel B — context rule structural tests ────────────────────────────────
 
 describe('auth-flow context rule — Channel B (structural wiring in gateway.ts)', () => {
-  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-9 (#2996): the secret-detect pipeline intercept moved verbatim
+    // into gateway/inbound-interceptors.ts (interceptSecretDetectPipeline).
+    readFileSync(new URL('../gateway/inbound-interceptors.ts', import.meta.url), 'utf8')
 
   it('declares awaitingAuthCodeAt map and AUTH_CODE_CONTEXT_TTL_MS constant', () => {
     expect(src).toMatch(/const awaitingAuthCodeAt = new Map<string, number>/)
@@ -121,7 +123,7 @@ describe('auth-flow context rule — Channel B (structural wiring in gateway.ts)
 
   it('clears awaitingAuthCodeAt (delete) in the inbound handler when the flag is active', () => {
     // The inbound handler must call delete after reading the flag
-    expect(src).toMatch(/awaitingAuthCodeAt\.delete\(chat_id\)/)
+    expect(src).toMatch(/awaitingAuthCodeAt\.delete\((?:p\.)?chat_id\)/)
   })
 
   it('checks isAuthFlowContext in the secret-detect block (passphrase path)', () => {
@@ -155,7 +157,9 @@ describe('auth-flow context rule — Channel B (structural wiring in gateway.ts)
   })
 
   it('auth-flow context rule sits BEFORE recordInbound() and broadcast()', () => {
-    const contextIdx = src.indexOf('isAuthFlowContext')
+    // P7 PR-9: the context rule lives inside interceptSecretDetectPipeline;
+    // its gateway CALL SITE is the ordering anchor against the sinks.
+    const contextIdx = src.indexOf('await interceptSecretDetectPipeline(')
     const recordIdx = src.indexOf('recordInbound(', contextIdx)
     const broadcastIdx = src.indexOf('ipcServer.broadcast(inboundMsg)', contextIdx)
     expect(contextIdx).toBeGreaterThan(0)
@@ -191,8 +195,12 @@ describe('anthropic_oauth_code pattern — URL false-positive regression', () =>
 // Test 2: Blocker 1 sequencing — structural check that deleteMessage is called
 // inside the pendingReauthFlows intercept path, before setMessageReaction.
 describe('pendingReauthFlows intercept — deleteMessage sequencing (Blocker 1)', () => {
+  // P7 PR-7 (#2996): the reauth intercept body moved verbatim into
+  // gateway/inbound-interceptors.ts (interceptReauth); the redaction is the
+  // injected deps.redactAuthCode closure over redactAuthCodeMessage +
+  // redactAuthCodeApi (bound in gateway.ts). Same pins, new file owner.
   const src = readFileSync(
-    new URL('../gateway/gateway.ts', import.meta.url),
+    new URL('../gateway/inbound-interceptors.ts', import.meta.url),
     'utf8',
   )
 
@@ -202,7 +210,7 @@ describe('pendingReauthFlows intercept — deleteMessage sequencing (Blocker 1)'
     // `setMessageReaction(...)` literals, but #488 consolidated all 6
     // auth-code paste paths through `redactAuthCodeMessage`. The pin
     // is now: the intercept block must call the helper.
-    const interceptIdx = src.indexOf('// Auth-code intercept')
+    const interceptIdx = src.indexOf('export async function interceptReauth(')
     expect(interceptIdx).toBeGreaterThan(0)
 
     // Find the end of this intercept block — the next blank line after
@@ -215,7 +223,7 @@ describe('pendingReauthFlows intercept — deleteMessage sequencing (Blocker 1)'
     // (optionally cast, #623), now the gated `redactAuthCodeApi` adapter whose
     // reaction routes through the send gate + flood breaker (#3155). `msgId`
     // may be narrowed (`msgId ?? null`).
-    expect(window).toMatch(/redactAuthCodeMessage\((?:bot\.api|redactAuthCodeApi)(?:\s+as\s+\w+)?,\s*chat_id,\s*msgId(?:\s*\?\?\s*null)?(?:,\s*[^)]+)?\)/)
+    expect(window).toMatch(/deps\.redactAuthCode\(p\.chat_id,\s*p\.msgId(?:\s*\?\?\s*null)?\)/)
   })
 
   it('redaction lands AFTER the success/error reply renders', () => {
@@ -224,10 +232,10 @@ describe('pendingReauthFlows intercept — deleteMessage sequencing (Blocker 1)'
     // even if their original message disappears mid-render. Same
     // ordering the helper preserves — fire-and-forget redaction
     // happens after `await switchroomReply(...)`.
-    const interceptIdx = src.indexOf('// Auth-code intercept')
+    const interceptIdx = src.indexOf('export async function interceptReauth(')
     const window = src.slice(interceptIdx, interceptIdx + 2000)
-    const replyIdx = window.indexOf('switchroomReply(ctx,')
-    const redactIdx = window.indexOf('redactAuthCodeMessage(')
+    const replyIdx = window.indexOf('deps.switchroomReply(')
+    const redactIdx = window.indexOf('deps.redactAuthCode(')
     expect(replyIdx).toBeGreaterThan(0)
     expect(redactIdx).toBeGreaterThan(0)
     expect(replyIdx).toBeLessThan(redactIdx)
@@ -237,10 +245,12 @@ describe('pendingReauthFlows intercept — deleteMessage sequencing (Blocker 1)'
 // Test 3: Flag consumption — awaitingAuthCodeAt is NOT cleared on a non-detection
 // inbound (a stray "ok" within the 5-min window should not disarm Channel B).
 describe('awaitingAuthCodeAt flag — consumption only on actual detection', () => {
-  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-9 (#2996): the secret-detect pipeline intercept moved verbatim
+    // into gateway/inbound-interceptors.ts (interceptSecretDetectPipeline).
+    readFileSync(new URL('../gateway/inbound-interceptors.ts', import.meta.url), 'utf8')
 
   it('delete(chat_id) does NOT appear at the top of the isAuthFlowContext block (no early consume)', () => {
     // The old bug: delete fired unconditionally inside `if (isAuthFlowContext)`.
@@ -261,7 +271,7 @@ describe('awaitingAuthCodeAt flag — consumption only on actual detection', ()
     expect(fallbackIdx).toBeGreaterThan(0)
     // Within 400 chars after the comment, delete must appear
     const window = src.slice(fallbackIdx, fallbackIdx + 400)
-    expect(window).toMatch(/awaitingAuthCodeAt\.delete\(chat_id\)/)
+    expect(window).toMatch(/(?:deps\.)?awaitingAuthCodeAt\.delete\((?:p\.)?chat_id\)/)
   })
 
   it('awaitingAuthCodeAt.delete appears inside the no-passphrase hasHigh branch', () => {
@@ -272,7 +282,7 @@ describe('awaitingAuthCodeAt flag — consumption only on actual detection', ()
     const window = src.slice(noPpIdx, noPpIdx + 1200)
     // Conditional consume: only fires if isAuthFlowContext
     expect(window).toMatch(/if \(isAuthFlowContext\)/)
-    expect(window).toMatch(/awaitingAuthCodeAt\.delete\(chat_id\)/)
+    expect(window).toMatch(/(?:deps\.)?awaitingAuthCodeAt\.delete\((?:p\.)?chat_id\)/)
   })
 })
 

package/telegram-plugin/tests/silence-liveness-wiring.test.ts

@@ -24,6 +24,15 @@ import { readFileSync } from 'node:fs'
 import { resolve } from 'node:path'
 
 const gatewaySrc = readFileSync(resolve(__dirname, '..', 'gateway', 'gateway.ts'), 'utf-8')
+// #2996 P4-A: the model-driven reset sites (tool_label append, answer-stream
+// onMetric) live inside handleSessionEvent, which moved VERBATIM to
+// stream-render.ts. There the live-turn guard reads the injected accessor
+// (`getCurrentTurn() === turn`) rather than the `currentTurn` module global.
+const streamSrc = readFileSync(resolve(__dirname, '..', 'gateway', 'stream-render.ts'), 'utf-8')
+// #2996 P4-B: drainActivitySummary / feedHeartbeatTick moved VERBATIM into
+// narrative-lane.ts (factory scope, bodies indented +2; gateway keeps thin
+// same-name wrappers) — the heartbeat-safety windows read the module source.
+const laneSrc = readFileSync(resolve(__dirname, '..', 'gateway', 'narrative-lane.ts'), 'utf-8')
 
 function between(src: string, startMarker: string, endMarker: string): string {
   const after = src.split(startMarker)[1] ?? ''
@@ -32,13 +41,13 @@ function between(src: string, startMarker: string, endMarker: string): string {
 
 describe('silence-poke production-liveness — heartbeat safety', () => {
   it('drainActivitySummary must NOT reset the silence clock (the framework heartbeat drains here)', () => {
-    const body = between(gatewaySrc, 'async function drainActivitySummary', '\nfunction feedHeartbeatTick')
+    const body = between(laneSrc, 'async function drainActivitySummary', '\n  function feedHeartbeatTick')
     expect(body.length).toBeGreaterThan(100) // sanity: the slice found the function body
     expect(body).not.toMatch(/noteProduction/)
   })
 
   it('feedHeartbeatTick itself must NOT reset the silence clock (model-independent re-render)', () => {
-    const body = between(gatewaySrc, 'function feedHeartbeatTick(): void {', '\n}')
+    const body = between(laneSrc, 'function feedHeartbeatTick(): void {', '\n  }')
     expect(body.length).toBeGreaterThan(50)
     expect(body).not.toMatch(/noteProduction/)
   })
@@ -47,18 +56,18 @@ describe('silence-poke production-liveness — heartbeat safety', () => {
     // appendActivityLabel returns a fresh render only when the model emits a NEW
     // labelled step — the genuine liveness signal the heartbeat can never forge.
     const block = between(
-      gatewaySrc,
+      streamSrc,
       'const rendered = appendActivityLabel(turn.mirrorLines, ev.label)',
       '\n      return',
     )
     expect(block).toMatch(/silencePoke\.noteProduction/)
-    expect(block).toMatch(/currentTurn === turn/)
+    expect(block).toMatch(/getCurrentTurn\(\) === turn/)
   })
 
   it('the answer-stream draft onMetric reset is model-driven and gated on the live turn', () => {
-    const block = between(gatewaySrc, 'onMetric: (metricEv) => {', '\n            },')
+    const block = between(streamSrc, 'onMetric: (metricEv) => {', '\n            },')
     expect(block).toMatch(/silencePoke\.noteProduction/)
-    expect(block).toMatch(/currentTurn === turn/)
+    expect(block).toMatch(/getCurrentTurn\(\) === turn/)
   })
 
   it('production-liveness is behind the default-ON SWITCHROOM_SILENCE_LIVENESS_PRODUCTION kill switch', () => {
@@ -74,12 +83,17 @@ describe('silence-poke production-liveness — heartbeat safety', () => {
     // Structural guard so a refactor can't silently re-silence the re-ping
     // (the gateway IIFE can't be instantiated in-process — same pattern as the
     // heartbeat-safety assertions above).
-    const block = between(gatewaySrc, 'onFrameworkFallback: async (ctx) => {', '\nfunction trackRedeliveredInbound')
+    // #2996 P8 PR-C3: the fallback body moved verbatim to liveness-wiring.ts;
+    // the send itself is the injected `sendSilenceText(chat, thread, text,
+    // silent)` closure (gateway keeps the bot-api touch), so the gate now
+    // rides the closure's `silent` argument at the callsite.
+    const livenessSrc = readFileSync(resolve(__dirname, '..', 'gateway', 'liveness-wiring.ts'), 'utf-8')
+    const block = between(livenessSrc, 'onFrameworkFallback: async (ctx) => {', '\n  }\n}')
     expect(block.length).toBeGreaterThan(100) // sanity: slice found the handler body
     // The signal is derived once, hoisted above the update-status branch so it's
     // in scope at the send site.
     expect(block).toMatch(/const blockedOnApproval = activeStatusReactions/)
     // The send gates on it rather than hard-coding silent.
-    expect(block).toMatch(/disable_notification: blockedOnApproval \? false : true/)
+    expect(block).toMatch(/sendSilenceText\(ctx\.chatId, ctx\.threadId \?\? null, text, blockedOnApproval \? false : true\)/)
   })
 })