switchroom 0.18.30 → 0.18.32

package/telegram-plugin/tests/subagent-watcher-resume-reregister.test.ts

@@ -0,0 +1,291 @@
+/**
+ * Tests for SubagentWatcher re-registration after a SendMessage resume
+ * (issue #3315).
+ *
+ * A background worker that completes normally (a REAL `sub_agent_turn_end`)
+ * is swept out of the registry by `cleanupTerminalAgent`, which records the
+ * agent id in `terminatedAgentIds` so a rescan of the still-present JSONL
+ * doesn't re-register and re-fire a duplicate handback (issue #1116 Bug B).
+ *
+ * But a SendMessage-resume reuses the SAME `agent-<id>.jsonl`, appending a
+ * NEW turn to it. Pre-fix the `terminatedAgentIds` guard suppressed that file
+ * forever regardless of growth, so the resumed worker was never tracked again:
+ * no FSWatcher, no `onProgress`, no progress card — the exact UX failure the
+ * card exists to prevent (operator: "I don't see any progress cards, anything
+ * happening??").
+ *
+ * This suite pins BOTH directions of the deterministic size-based mechanism:
+ *
+ *  (a) terminal cleanup → resume (JSONL grows past the terminal size) ⇒ the
+ *      watcher re-registers the agent as a LIVE worker and emits progress
+ *      cues again. The re-registration reads only the NEW turn — it does NOT
+ *      replay the already-handed-back completed turn (no duplicate onFinish
+ *      until the resumed turn genuinely ends).
+ *  (b) terminal cleanup with NO resume (JSONL static) ⇒ the agent stays
+ *      cleaned up: no re-registration, no duplicate onFinish, no leaked card.
+ */
+
+import { describe, it, expect, vi } from 'vitest'
+import { startSubagentWatcher } from '../subagent-watcher.js'
+import * as fs from 'fs'
+
+function buildJSONL(...lines: object[]): string {
+  return lines.map((l) => JSON.stringify(l)).join('\n') + '\n'
+}
+function subAgentUserMsg(promptText: string) {
+  return { type: 'user', message: { content: [{ type: 'text', text: promptText }] } }
+}
+function subAgentToolUse(name: string, id: string, input: Record<string, unknown> = {}) {
+  return { type: 'assistant', message: { content: [{ type: 'tool_use', name, id, input }] } }
+}
+function subAgentTurnEnd() {
+  return { type: 'system', subtype: 'turn_duration', duration_ms: 1234 }
+}
+
+const RESCAN_MS = 500
+const CLEANUP_GRACE_MS = 30_000 // TERMINAL_CLEANUP_GRACE_MS in subagent-watcher.ts
+
+interface ProgressCall {
+  agentId: string
+  skeleton: boolean
+  progressLine?: string
+  toolCount: number
+}
+
+function makeHarness(opts: { agentId?: string } = {}) {
+  const { agentId = 'resume-agent' } = opts
+
+  let currentTime = 1000
+  const progressCalls: ProgressCall[] = []
+  const finishCalls: Array<{ agentId: string; outcome: string }> = []
+  const terminalCleanupCalls: string[] = []
+  const logs: string[] = []
+
+  const agentDir = '/home/user/.switchroom/agents/myagent'
+  const sessionId = 'mock-session'
+  const projectsRoot = `${agentDir}/.claude/projects`
+  const projectDir = `${projectsRoot}/mock-cwd`
+  const sessionDir = `${projectDir}/${sessionId}`
+  const subagentsDir = `${sessionDir}/subagents`
+  const jsonlPath = `${subagentsDir}/agent-${agentId}.jsonl`
+
+  // The agent JSONL is NOT present at construction, so the boot scan registers
+  // nothing and the file — when it later appears — registers post-boot as a
+  // LIVE (non-historical) worker, exactly like a freshly-dispatched one.
+  const fileContents = new Map<string, Buffer>()
+
+  let lastOpenedPath: string | null = null
+  const mockFs = {
+    existsSync: ((p: fs.PathLike) => {
+      const ps = String(p)
+      if (ps === projectsRoot || ps === projectDir || ps === sessionDir || ps === subagentsDir) return true
+      return fileContents.has(ps)
+    }) as typeof fs.existsSync,
+    readdirSync: ((p: fs.PathLike) => {
+      const ps = String(p)
+      if (ps === projectsRoot) return ['mock-cwd']
+      if (ps === projectDir) return [sessionId]
+      if (ps === sessionDir) return ['subagents']
+      if (ps === subagentsDir) {
+        // Dynamic: list the agent-*.jsonl files currently present on "disk".
+        const names: string[] = []
+        for (const key of fileContents.keys()) {
+          if (key.startsWith(subagentsDir + '/agent-') && key.endsWith('.jsonl')) {
+            names.push(key.slice(subagentsDir.length + 1))
+          }
+        }
+        return names
+      }
+      return []
+    }) as unknown as typeof fs.readdirSync,
+    statSync: ((p: fs.PathLike) =>
+      ({ size: fileContents.get(String(p))?.length ?? 0, mtimeMs: currentTime }) as fs.Stats) as typeof fs.statSync,
+    openSync: ((p: fs.PathLike) => {
+      lastOpenedPath = String(p)
+      return 42
+    }) as unknown as typeof fs.openSync,
+    closeSync: (() => { lastOpenedPath = null }) as typeof fs.closeSync,
+    readSync: ((
+      _fd: number,
+      buf: NodeJS.ArrayBufferView,
+      offset: number,
+      length: number,
+      position: number | null,
+    ): number => {
+      const content = lastOpenedPath != null ? fileContents.get(lastOpenedPath) : undefined
+      if (!content) return 0
+      const pos = position ?? 0
+      const src = content.slice(pos, pos + length)
+      ;(src as Buffer).copy(buf as Buffer, offset)
+      return src.length
+    }) as unknown as typeof fs.readSync,
+    watch: (() => ({ close: vi.fn() }) as unknown as fs.FSWatcher) as unknown as typeof fs.watch,
+  }
+
+  const intervals: Array<{ fn: () => void; ms: number; ref: number; fireAt: number }> = []
+  const timeouts: Array<{ fn: () => void; ref: number; fireAt: number }> = []
+  let nextRef = 1
+
+  const watcher = startSubagentWatcher({
+    agentDir,
+    rescanMs: RESCAN_MS,
+    onProgress: ({ agentId: id, skeleton, progressLine, toolCount }) =>
+      progressCalls.push({ agentId: id, skeleton: skeleton === true, progressLine, toolCount }),
+    onFinish: ({ agentId: id, outcome }) => finishCalls.push({ agentId: id, outcome }),
+    onTerminalCleanup: (id) => terminalCleanupCalls.push(id),
+    now: () => currentTime,
+    setInterval: (fn, ms) => {
+      const ref = nextRef++
+      intervals.push({ fn, ms, ref, fireAt: currentTime + ms })
+      return { ref }
+    },
+    clearInterval: (handle) => {
+      const { ref } = handle as { ref: number }
+      const idx = intervals.findIndex((i) => i.ref === ref)
+      if (idx !== -1) intervals.splice(idx, 1)
+    },
+    setTimeout: (fn, ms) => {
+      const ref = nextRef++
+      timeouts.push({ fn, ref, fireAt: currentTime + ms })
+      return { ref }
+    },
+    clearTimeout: (handle) => {
+      const { ref } = handle as { ref: number }
+      const idx = timeouts.findIndex((t) => t.ref === ref)
+      if (idx !== -1) timeouts.splice(idx, 1)
+    },
+    fs: mockFs,
+    log: (msg) => logs.push(msg),
+  })
+
+  const advance = (ms: number): void => {
+    currentTime += ms
+    for (;;) {
+      intervals.sort((a, b) => a.fireAt - b.fireAt)
+      timeouts.sort((a, b) => a.fireAt - b.fireAt)
+      const nextI = intervals[0]
+      const nextT = timeouts[0]
+      const iReady = nextI && nextI.fireAt <= currentTime
+      const tReady = nextT && nextT.fireAt <= currentTime
+      if (!iReady && !tReady) break
+      if (tReady && (!iReady || nextT!.fireAt <= nextI!.fireAt)) {
+        timeouts.shift()
+        nextT!.fn()
+      } else {
+        nextI!.fireAt += nextI!.ms
+        nextI!.fn()
+      }
+    }
+  }
+
+  const setFile = (content: string): void => {
+    fileContents.set(jsonlPath, Buffer.from(content, 'utf-8'))
+  }
+  const append = (content: string): void => {
+    const cur = fileContents.get(jsonlPath) ?? Buffer.alloc(0)
+    fileContents.set(jsonlPath, Buffer.concat([cur, Buffer.from(content, 'utf-8')]))
+  }
+
+  return {
+    agentId,
+    progressCalls,
+    finishCalls,
+    terminalCleanupCalls,
+    logs,
+    advance,
+    watcher,
+    setFile,
+    append,
+  }
+}
+
+describe('subagent-watcher resume re-registration (issue #3315)', () => {
+  it('(a) re-registers a terminal-then-resumed worker so its progress card resumes', () => {
+    const agentId = 'resume-live'
+    const h = makeHarness({ agentId })
+
+    // A worker is dispatched post-boot: its JSONL appears with a running turn.
+    h.setFile(buildJSONL(subAgentUserMsg('bg task'), subAgentToolUse('Bash', 't1')))
+    h.advance(RESCAN_MS) // rescan discovers the file → LIVE registration
+
+    const registered = h.watcher.getRegistry().get(agentId)
+    expect(registered).toBeDefined()
+    expect(registered!.state).toBe('running')
+    expect(registered!.historical).toBe(false)
+
+    // It completes normally with a REAL turn_end.
+    h.append(buildJSONL(subAgentTurnEnd()))
+    h.advance(RESCAN_MS) // poll reads turn_end → done → onFinish(completed)
+    expect(h.finishCalls).toHaveLength(1)
+    expect(h.finishCalls[0].outcome).toBe('completed')
+
+    // Grace elapses → the entry is swept out of the registry.
+    h.advance(CLEANUP_GRACE_MS)
+    expect(h.watcher.getRegistry().has(agentId)).toBe(false)
+    expect(h.terminalCleanupCalls).toContain(agentId)
+
+    const progressBeforeResume = h.progressCalls.length
+
+    // SendMessage resume: Claude Code appends a NEW turn to the SAME JSONL.
+    h.append(buildJSONL(
+      subAgentUserMsg('follow-up question'),
+      subAgentToolUse('Read', 't2', { file_path: '/tmp/x' }),
+    ))
+    h.advance(RESCAN_MS) // rescan sees growth past terminal size → re-register
+
+    // The worker is tracked again — live, running, non-historical.
+    const revived = h.watcher.getRegistry().get(agentId)
+    expect(revived).toBeDefined()
+    expect(revived!.state).toBe('running')
+    expect(revived!.historical).toBe(false)
+    expect(h.logs.some((l) => l.includes('resumed after terminal cleanup') && l.includes(agentId))).toBe(true)
+
+    // Progress cues resume (the card updates again) — the user-visible fix.
+    expect(h.progressCalls.length).toBeGreaterThan(progressBeforeResume)
+    expect(h.progressCalls.slice(progressBeforeResume).some((c) => c.agentId === agentId)).toBe(true)
+
+    // The completed turn was NOT replayed — no duplicate onFinish fired on
+    // re-registration (the old turn_end sits before the resume cursor).
+    expect(h.finishCalls).toHaveLength(1)
+
+    // When the resumed turn genuinely ends, onFinish fires again for the new
+    // turn — the resumed work gets its own handback.
+    h.append(buildJSONL(subAgentTurnEnd()))
+    h.advance(RESCAN_MS)
+    expect(h.finishCalls).toHaveLength(2)
+    expect(h.finishCalls[1].outcome).toBe('completed')
+
+    h.watcher.stop()
+  })
+
+  it('(b) a terminal worker that is NOT resumed stays cleaned up (no re-register, no duplicate handback)', () => {
+    const agentId = 'stay-clean'
+    const h = makeHarness({ agentId })
+
+    h.setFile(buildJSONL(subAgentUserMsg('bg task'), subAgentToolUse('Bash', 't1')))
+    h.advance(RESCAN_MS)
+    expect(h.watcher.getRegistry().has(agentId)).toBe(true)
+
+    h.append(buildJSONL(subAgentTurnEnd()))
+    h.advance(RESCAN_MS)
+    expect(h.finishCalls).toHaveLength(1)
+
+    h.advance(CLEANUP_GRACE_MS) // sweep
+    expect(h.watcher.getRegistry().has(agentId)).toBe(false)
+    const finishAfterCleanup = h.finishCalls.length
+    const progressAfterCleanup = h.progressCalls.length
+
+    // The JSONL stays on disk, static (Claude Code leaves it), and the worker
+    // is never resumed. Many rescans must NOT re-register it or re-fire the
+    // handback (issue #1116 Bug B guard preserved) — the reverse-bug direction.
+    for (let i = 0; i < 20; i++) h.advance(RESCAN_MS)
+
+    expect(h.watcher.getRegistry().has(agentId)).toBe(false)
+    expect(h.finishCalls).toHaveLength(finishAfterCleanup) // no duplicate
+    expect(h.progressCalls).toHaveLength(progressAfterCleanup) // no card churn
+    // Cleanup fired exactly once — no leaked/duplicated terminal sweep.
+    expect(h.terminalCleanupCalls.filter((id) => id === agentId)).toHaveLength(1)
+
+    h.watcher.stop()
+  })
+})

package/telegram-plugin/tests/subagent-watcher-resurrection.test.ts

@@ -395,4 +395,36 @@ describe('subagent-watcher card resurrection (issue #3023)', () => {
     h.advance(500)
     expect(h.resurrectCalls).toHaveLength(1)
   })
+
+  it('(f) a false finish resumed after cleanup grace is owned by resurrection, not the #3315 resume path', () => {
+    // Non-interference guard (issue #3315 × #3023): once the terminal-cleanup
+    // grace has elapsed, a falsely-finalised worker's id sits in BOTH
+    // `terminatedAgentIds` (the #3315 resume-detection map) AND
+    // `falseFinishTracker`. Its JSONL resuming must be handled by the
+    // resurrection path (bounded-chain + onResurrect semantics), NOT
+    // double-handled by the scanSubagentsDir resume branch. The branch defers
+    // when a false-finish record exists.
+    const agentId = 'false-finish-post-grace'
+    const h = makeHarness({ agentId })
+
+    h.advance(500)
+    unmarkHistorical(h, agentId)
+
+    driveToFalseFinish(h, agentId)
+    // Let the 30s terminal-cleanup grace elapse so the entry is swept — its id
+    // is now in BOTH terminatedAgentIds and falseFinishTracker.
+    h.advance(30_000)
+    expect(h.watcher.getRegistry().has(agentId)).toBe(false)
+
+    // JSONL resumes growing.
+    h.appendActivity()
+    h.advance(500)
+
+    // Resurrected exactly once via the #3023 path...
+    expect(h.resurrectCalls).toHaveLength(1)
+    expect(h.watcher.getRegistry().get(agentId)?.state).toBe('running')
+    // ...and NOT re-registered by the #3315 resume branch (its log marker is
+    // absent — the branch deferred because a false-finish record existed).
+    expect(h.logs.some((l) => l.includes('resumed after terminal cleanup'))).toBe(false)
+  })
 })

package/telegram-plugin/tests/turn-end-gate-backstop.test.ts

@@ -4,10 +4,10 @@
  * Outcome contract: if a pre-purge op in the turn_end handler body THROWS
  * before the canonical purge (endCurrentTurnAtomic → purgeReactionTracking)
  * runs, the guarded finally must still clear this turn's gate state
- * (activeTurnStartedAt + the mirrored claudeBusyKeys) so the #1556 inbound
- * gate re-opens for the next inbound. On the happy path — where the body
- * clears the key itself — the backstop must be a no-op (no double purge), and
- * the original error must always propagate.
+ * (activeTurnStartedAt; the purge also emits the machine turnEnd) so the
+ * #1556 inbound gate re-opens for the next inbound. On the happy path —
+ * where the body clears the key itself — the backstop must be a no-op (no
+ * double purge), and the original error must always propagate.
  */
 import { describe, it, expect } from 'vitest'
 import { withTurnEndGateBackstop } from '../gateway/turn-end-gate-backstop.js'
@@ -22,19 +22,16 @@ function statusKey(chatId: string, threadId?: number): string {
 }
 
 /** Mirror of the production gate state + a purge that clears it, as
- * purgeReactionTracking does (activeTurnStartedAt.delete + claudeBusyKeys
- * drain for the key). */
+ * purgeReactionTracking does (activeTurnStartedAt.delete for the key). */
 function freshGate(turn: Turn) {
   const key = statusKey(turn.sessionChatId, turn.sessionThreadId)
   const activeTurnStartedAt = new Map<string, number>([[key, Date.now()]])
-  const claudeBusyKeys = new Set<string>([key])
   const purgeCalls: Array<{ key: string; endingTurn: Turn | undefined }> = []
   const purge = (k: string, endingTurn: Turn | undefined) => {
     purgeCalls.push({ key: k, endingTurn })
     activeTurnStartedAt.delete(k)
-    claudeBusyKeys.delete(k)
   }
-  return { key, activeTurnStartedAt, claudeBusyKeys, purge, purgeCalls }
+  return { key, activeTurnStartedAt, purge, purgeCalls }
 }
 
 function deps(gate: ReturnType<typeof freshGate>) {
@@ -58,10 +55,9 @@ describe('withTurnEndGateBackstop (#2094 finding 1)', () => {
       }, deps(gate)),
     ).toThrow('redactOutboundText blew up')
 
-    // Outcome: gate is OPEN again — both maps cleared, so the #1556 inbound
-    // gate no longer wedges the next inbound.
+    // Outcome: gate is OPEN again — the turn map is cleared, so the #1556
+    // inbound gate no longer wedges the next inbound.
     expect(gate.activeTurnStartedAt.has(gate.key)).toBe(false)
-    expect(gate.claudeBusyKeys.has(gate.key)).toBe(false)
     // The backstop fired exactly once, forwarding the ending turn.
     expect(gate.purgeCalls).toEqual([{ key: gate.key, endingTurn: turn }])
   })

package/telegram-plugin/tests/turn-flush-safety.test.ts

@@ -267,16 +267,18 @@ describe('#2798 turn-flush punctuation/bold parity with reply', () => {
     // (`normalizeOutboundBody`). The reply path delegates to it via
     // `normalizeOutboundBody(rawText, 'reply', redactOutboundText)`; the
     // redact→normalize→scrub ordering is now pinned in the module source.
-    const replyDelegates = gatewaySrc.indexOf(
-      `normalizeOutboundBody(rawText, 'reply', redactOutboundText)`,
-      gatewaySrc.indexOf('async function executeReply('),
-    )
-    expect(replyDelegates).toBeGreaterThan(0)
-
     const moduleSrc = readFileSync(
       new URL('../gateway/outbound-send-path.ts', import.meta.url),
       'utf8',
     )
+    // #2996 P2: the reply orchestration itself now lives in the module
+    // (`sendReply`); the delegation line is pinned there.
+    const replyDelegates = moduleSrc.indexOf(
+      `normalizeOutboundBody(rawText, 'reply', redactOutboundText)`,
+      moduleSrc.indexOf('export async function sendReply('),
+    )
+    expect(replyDelegates).toBeGreaterThan(0)
+
     const start = moduleSrc.indexOf('export function normalizeOutboundBody(')
     const redactIdx = moduleSrc.indexOf('redact(text, site)', start)
     const normIdx = moduleSrc.indexOf('stripExcessBold(normalizePunctuation(text))', start)

package/telegram-plugin/tests/turn-flush-suppression-wiring.test.ts

@@ -0,0 +1,112 @@
+/**
+ * S1/S2/S4 WIRING (fable red-team 2026-07-17, fixed in #3299 @ a6e09dfb).
+ *
+ * The behavioural suite `turn-flush-suppression.test.ts` proves the scoped
+ * suppression predicate in isolation, and `answer-ready-flush.test.ts` proves
+ * the quiescence controller's reset/re-arm semantics — but neither says
+ * whether the GATEWAY actually calls them, or what it does with the answer.
+ * That decision-vs-delivery gap is exactly how the original S1 bug shipped:
+ * every routine was individually correct while the gateway's call site
+ * counted ANY chat-wide outbound and then CLOSED the obligation, silently
+ * dropping the user's real answer.
+ *
+ * gateway.ts is a side-effecting IIFE that cannot be imported in a unit test
+ * (same constraint as activity-card-wiring.test.ts /
+ * silence-liveness-wiring.test.ts), so these are STRUCTURAL assertions that
+ * pin the load-bearing call sites. They COMPLEMENT the behavioural suites —
+ * the outcomes are proven at routine level; this guards the wiring those
+ * routines depend on. Each test names the regression it would catch.
+ */
+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')
+
+function between(src: string, startMarker: string, endMarker: string): string {
+  const after = src.split(startMarker)[1] ?? ''
+  return after.split(endMarker)[0] ?? ''
+}
+
+/** Strip // comment lines so prose quoting the OLD (buggy) shape can't
+ *  satisfy — or trip — an assertion about the CODE. */
+function codeOnly(src: string): string {
+  return src
+    .split('\n')
+    .filter((l) => !l.trim().startsWith('//'))
+    .filter((l) => !l.trim().startsWith('*') && !l.trim().startsWith('/*'))
+    .join('\n')
+}
+
+describe('S1 wiring — turn-flush suppression call site', () => {
+  // The whole suppression branch: predicate call through the end of the
+  // `if (suppress)` early-return.
+  const branch = between(
+    gatewaySrc,
+    'const { shouldSuppressTurnFlush }',
+    '// #3276 guard 5',
+  )
+
+  it('the gateway asks the SCOPED predicate, not a chat-wide outbound count', () => {
+    expect(branch.length).toBeGreaterThan(100)
+    const code = codeOnly(branch)
+    // The oracle is the thread/length-scoped history query…
+    expect(code).toMatch(/hasSubstantiveOutbound:\s*hasOutboundDeliveredSince/)
+    // …with an EXPLICIT null thread for chat-root turns (undefined would
+    // match rows in ANY topic and re-open the cross-topic false positive)…
+    expect(code).toMatch(/threadId:\s*backstopThreadId\s*\?\?\s*null/)
+    // …and the captured answer's length driving the substantive floor.
+    expect(code).toMatch(/answerLength:\s*capturedText\.length/)
+    // The OLD chat-wide predicate must never come back anywhere in the branch.
+    expect(code).not.toMatch(/getRecentOutboundCount/)
+  })
+
+  it('suppression leaves the obligation OPEN (noteTurnEnded) — never closes it', () => {
+    const code = codeOnly(branch)
+    // A false-positive suppression must stay recoverable: the sweep/liveness
+    // floor arbitrates. Closing here made the drop PERMANENT (the S1 bug).
+    expect(code).toMatch(/obligationLedger\.noteTurnEnded\(turn\.turnId/)
+    expect(code).not.toMatch(/obligationLedger\.close\(/)
+  })
+
+  it('the old predicate is gone from the whole gateway turn-flush path', () => {
+    // getRecentOutboundCount must not be consulted anywhere in gateway.ts —
+    // any reintroduction re-opens the chat-wide suppression class.
+    expect(codeOnly(gatewaySrc)).not.toMatch(/getRecentOutboundCount/)
+  })
+})
+
+describe('S2 wiring — thinking events re-arm the answer-ready quiescence flush', () => {
+  it("the 'thinking' event arm calls resetAnswerReadyFlushTimeout()", () => {
+    // Without this, "prose → >1s thinking pause → trailing NO_REPLY" lets the
+    // quiescence timer fire mid-pause and deliver a turn the model intended
+    // silent. Scope to the thinking case arm only.
+    const arm = between(gatewaySrc, "case 'thinking': {", "case 'tool_use': {")
+    expect(arm.length).toBeGreaterThan(50)
+    expect(codeOnly(arm)).toMatch(/resetAnswerReadyFlushTimeout\(\)/)
+  })
+})
+
+describe('S4 wiring — flushed answers quote-anchor to the inbound they answer', () => {
+  it('deliverAnswer anchors the FIRST chunk with reply_parameters + allow_sending_without_reply', () => {
+    const sendChunk = between(
+      gatewaySrc,
+      'const sendChunk = async (chunkIndex: number',
+      'buildSendOpts:',
+    )
+    expect(sendChunk.length).toBeGreaterThan(50)
+    const code = codeOnly(sendChunk)
+    // First chunk only, and only when the turn has an inbound to anchor to.
+    expect(code).toMatch(/chunkIndex === 0 && args\.replyToMessageId != null/)
+    // allow_sending_without_reply keeps the send alive if the user deleted
+    // their message — without it the whole flush would fail on a dangling id.
+    expect(code).toMatch(/allow_sending_without_reply:\s*true/)
+    expect(code).toMatch(/reply_parameters/)
+  })
+
+  it('the turn-flush call site passes the turn’s inbound id (bare for synthesized turns)', () => {
+    // The anchor must be the message this TURN answers — turn.sourceMessageId
+    // is null for cron/handback turns, which therefore still send bare.
+    expect(codeOnly(gatewaySrc)).toMatch(/replyToMessageId:\s*turn\.sourceMessageId/)
+  })
+})

package/telegram-plugin/tests/turn-flush-suppression.test.ts

@@ -0,0 +1,90 @@
+/**
+ * S1 fix (fable red-team 2026-07-17) — turn-flush pre-delivery suppression.
+ *
+ * The old gateway predicate (`getRecentOutboundCount(chatId, 2) > 0`) counted
+ * ANY assistant row in the WHOLE chat, so a worker progress ping, a command
+ * ack, or a reply in a different forum topic suppressed the flush and closed
+ * the obligation — silently dropping the user's real answer. These tests pin
+ * the scoped replacement: the oracle must be asked for a SAME-THREAD row of
+ * substantive length within the 2s window, and oracle failures fail OPEN
+ * (deliver, don't drop). The oracle's own thread/length SQL semantics are
+ * pinned separately in `history.test.ts` (`hasOutboundDeliveredSince`).
+ */
+import { describe, it, expect } from 'vitest'
+import {
+  shouldSuppressTurnFlush,
+  FLUSH_SUPPRESSION_WINDOW_MS,
+} from '../gateway/turn-flush-suppression.js'
+import { FINAL_ANSWER_MIN_CHARS } from '../final-answer-detect.js'
+
+type OracleCall = { chatId: string; sinceMs: number; threadId: number | null; minChars: number }
+
+function capture(result: boolean) {
+  const calls: OracleCall[] = []
+  const deps = {
+    hasSubstantiveOutbound: (chatId: string, sinceMs: number, threadId: number | null, minChars: number) => {
+      calls.push({ chatId, sinceMs, threadId, minChars })
+      return result
+    },
+  }
+  return { calls, deps }
+}
+
+describe('shouldSuppressTurnFlush', () => {
+  it('suppresses iff the oracle finds a substantive same-thread outbound', () => {
+    const yes = capture(true)
+    expect(
+      shouldSuppressTurnFlush(yes.deps, { chatId: '-100', threadId: 7, answerLength: 500, nowMs: 10_000 }),
+    ).toBe(true)
+    const no = capture(false)
+    expect(
+      shouldSuppressTurnFlush(no.deps, { chatId: '-100', threadId: 7, answerLength: 500, nowMs: 10_000 }),
+    ).toBe(false)
+  })
+
+  it('scopes the oracle query to the turn thread and the 2s window', () => {
+    const { calls, deps } = capture(true)
+    shouldSuppressTurnFlush(deps, { chatId: '-100', threadId: 7, answerLength: 500, nowMs: 10_000 })
+    expect(calls).toHaveLength(1)
+    expect(calls[0]!.chatId).toBe('-100')
+    // Explicit thread id — never `undefined` (undefined would match rows in
+    // ANY topic and re-open the cross-topic false positive).
+    expect(calls[0]!.threadId).toBe(7)
+    expect(calls[0]!.sinceMs).toBe(10_000 - FLUSH_SUPPRESSION_WINDOW_MS)
+  })
+
+  it('passes an explicit null thread for DM / chat-root turns', () => {
+    const { calls, deps } = capture(false)
+    shouldSuppressTurnFlush(deps, { chatId: '55', threadId: null, answerLength: 300, nowMs: 5_000 })
+    expect(calls[0]!.threadId).toBeNull()
+  })
+
+  it('caps the length floor at FINAL_ANSWER_MIN_CHARS for long answers (a short ping can never suppress a long answer)', () => {
+    const { calls, deps } = capture(false)
+    shouldSuppressTurnFlush(deps, { chatId: '-100', threadId: null, answerLength: 5_000, nowMs: 10_000 })
+    expect(calls[0]!.minChars).toBe(FINAL_ANSWER_MIN_CHARS)
+  })
+
+  it('lowers the floor to the answer length for terse answers (their own stream materialization still suppresses a duplicate)', () => {
+    const { calls, deps } = capture(true)
+    shouldSuppressTurnFlush(deps, { chatId: '-100', threadId: null, answerLength: 12, nowMs: 10_000 })
+    expect(calls[0]!.minChars).toBe(12)
+  })
+
+  it('clamps the floor to >= 1 for a degenerate empty answer', () => {
+    const { calls, deps } = capture(false)
+    shouldSuppressTurnFlush(deps, { chatId: '-100', threadId: null, answerLength: 0, nowMs: 10_000 })
+    expect(calls[0]!.minChars).toBe(1)
+  })
+
+  it('fails open (no suppression) when the oracle throws — deliver beats drop', () => {
+    const deps = {
+      hasSubstantiveOutbound: () => {
+        throw new Error('sqlite unavailable')
+      },
+    }
+    expect(
+      shouldSuppressTurnFlush(deps, { chatId: '-100', threadId: null, answerLength: 300, nowMs: 10_000 }),
+    ).toBe(false)
+  })
+})

package/telegram-plugin/tests/vault-grant-inbound-builders.test.ts

@@ -414,8 +414,8 @@ describe('approve vs deny shape invariants', () => {
 // grant/save-outcome inbound must carry that topic so the resumed turn's
 // reply lands back in it — not General. The carrier is two-fold and BOTH
 // halves are load-bearing:
-//   - top-level `threadId` → the gateway's per-topic busy-key / deliver-
-//     until-acked keying (markClaudeBusyForInbound reads it).
+//   - top-level `threadId` → the gateway's per-topic deliver-until-acked
+//     keying (chatKeyForInbound reads it).
 //   - `meta.message_thread_id` (stringified) → rendered into the
 //     `<channel message_thread_id="…">` XML, which session-tail's
 //     parseChannelMeta re-extracts to set currentTurn.sessionThreadId, which