switchroom 0.13.26 → 0.13.28

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

@@ -1,149 +1,135 @@
 /**
- * PR #602 follow-up — plain `reply` tool must fire the terminal 👍
- * reaction on real delivery (post-sendMessage), mirroring Bug Z's
- * stream_reply contract.
+ * #1713 + #1728 — interim-ack `reply` tool is a non-event for the
+ * status reaction; final-answer `reply` finalizes.
  *
- * Background. Bug D removed the premature `setDone()` call from the
- * gateway's turn-flush dedup-suppress branch (it was firing 👍 off a
- * 500ms-lagged read of local history rather than from a real Telegram
- * delivery confirmation). Bug Z then wired stream_reply's
- * post-finalize callback to fire `endStatusReaction('done')` on
- * delivery.
+ * History.
+ *   - PR #602 follow-up wired `executeReply` to fire the terminal 👍
+ *     after at least one chunk landed.
+ *   - #1713 (#1718) reverted that: reaction reflects current turn
+ *     activity, not delivery state. Made `turn_end` the sole terminal
+ *     trigger so mid-turn ACK replies don't collapse the working-state
+ *     ladder to 👍.
+ *   - #1728 (this fix) carve-out: Claude Code's `turn_duration` system
+ *     event is unreliable for the trivial-prompt happy path, leaving
+ *     `activeTurnStartedAt` set forever and every subsequent inbound
+ *     stuck "held mid-turn" (the v0.13.27 wedge). When the reply IS
+ *     the final answer (`isFinalAnswerReply` returns true), executeReply
+ *     calls `finalizeStatusReaction` to release the buffer gate and
+ *     emit the (debounced 3500ms) terminal 👍. Interim acks bypass this
+ *     branch and remain non-events for the reaction.
  *
- * That left a regression: turns whose only outbound came through the
- * plain `reply` tool (not `stream_reply`) had no remaining 👍 emitter
- * — the dedup branch's setDone was the only thing firing for that
- * path, and removing it meant reply-only turns silently lost their
- * terminal reaction.
- *
- * The follow-up wires `executeReply` to call
- * `endStatusReaction(chat_id, threadId, 'done')` after at least one
- * `bot.api.sendMessage` resolves successfully (i.e. `sentIds.length
- * > 0`). The reply tool has no lane concept (unlike stream_reply, where
- * named lanes like 'progress'/'thinking' are internal driver emits),
- * so no lane gate is needed — every reply is by definition the
- * user-visible answer.
+ * Net contract pinned here:
+ *   - executeReply post-send block must NOT call the legacy
+ *     `endStatusReaction('done')` (the pre-#1713 bug class).
+ *   - executeReply MUST call `finalizeStatusReaction` gated on
+ *     `isFinalAnswerReply` so the buffer gate releases on final answer.
  *
  * The gateway IIFE / executeReply body are too entangled to import
- * directly. Following the same pattern as
- * `turn-flush-dedup-controller.test.ts`, we model the contract as a
- * pure function below and pin the post-fix invariant. If executeReply
- * is ever refactored to extract this branch, the same assertions
- * apply unchanged.
+ * directly, so we do source-level assertions.
  */
 import { describe, it, expect, vi } from 'vitest'
 
-interface ReplyTerminalDeps {
-  endStatusReaction: (chatId: string, threadId: number | undefined, outcome: 'done' | 'error') => void
-  writeError: (line: string) => void
-}
-
-/**
- * Extract of the gateway executeReply post-send block. Mirrors the
- * code at `telegram-plugin/gateway/gateway.ts` (post-fix, in the
- * `if (sentIds.length > 0) { ... }` block after the send loop).
- *
- * Returns true if the terminal 👍 was fired.
- */
-function applyReplyTerminalReaction(
-  chatId: string,
-  threadId: number | undefined,
-  sentIdsLength: number,
-  deps: ReplyTerminalDeps,
-): boolean {
-  if (sentIdsLength <= 0) return false
-  try {
-    deps.endStatusReaction(chatId, threadId, 'done')
-    return true
-  } catch (err) {
-    deps.writeError(`telegram gateway: reply: endStatusReaction hook threw: ${err}\n`)
-    return false
-  }
-}
-
-describe('PR #602 follow-up — plain reply tool terminal 👍', () => {
-  it('fires endStatusReaction("done") after at least one chunk lands', () => {
-    const endStatusReaction = vi.fn()
-    const writeError = vi.fn()
-
-    const fired = applyReplyTerminalReaction('-100', 42, 1, {
-      endStatusReaction,
-      writeError,
-    })
-
-    expect(fired).toBe(true)
-    expect(endStatusReaction).toHaveBeenCalledTimes(1)
-    expect(endStatusReaction).toHaveBeenCalledWith('-100', 42, 'done')
-    expect(writeError).not.toHaveBeenCalled()
-  })
-
-  it('passes threadId=undefined through unchanged for non-forum chats', () => {
-    // Plain DMs and non-forum supergroups don't carry a thread id —
-    // the controller key is `chatId:_`, not `chatId:<thread>`. Pin
-    // that the wiring forwards undefined rather than coercing to 0.
-    const endStatusReaction = vi.fn()
-    const writeError = vi.fn()
-
-    applyReplyTerminalReaction('123', undefined, 3, {
-      endStatusReaction,
-      writeError,
-    })
-
-    expect(endStatusReaction).toHaveBeenCalledWith('123', undefined, 'done')
+describe('#1713 + #1728 — reply tool reaction contract', () => {
+  it('executeReply post-send block does NOT call legacy endStatusReaction', () => {
+    // The pre-#1713 bug class was `endStatusReaction(chat_id, threadId,
+    // 'done')` firing 👍 unconditionally on every reply (including
+    // mid-turn acks). That call must stay removed.
+    //
+    // We do a coarse-grained source-level check rather than a unit
+    // test of a copied helper. If/when the executeReply body is
+    // extracted into its own function this can become a proper unit
+    // test; until then the source-level guard is the safest pin.
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    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')
+    const src = fs.readFileSync(
+      path.resolve(__dirname, '../gateway/gateway.ts'),
+      'utf8',
+    )
+    // Find the executeReply post-send block — anchored on the
+    // distinctive "fresh sendMessage from reply tool is a user-visible
+    // signal" comment.
+    const anchor = src.indexOf("fresh sendMessage from reply tool is a user-visible")
+    expect(anchor).toBeGreaterThan(-1)
+    // Look at the ~40 lines after the anchor — pre-#1713 this region
+    // contained `endStatusReaction(chat_id, threadId, 'done')`.
+    const slice = src.slice(anchor, anchor + 3000)
+    expect(slice).not.toMatch(/endStatusReaction\([^)]*'done'\)/)
   })
 
-  it('does NOT fire when sentIds is empty (zero successful sends)', () => {
-    // The send loop's catch arm rethrows on persistent failure; we
-    // never reach the post-send block in that case. But pin the
-    // gating invariant: sentIds.length > 0 is the necessary
-    // precondition. A reply that fails before any chunk lands must
-    // not claim delivery.
-    const endStatusReaction = vi.fn()
-    const writeError = vi.fn()
-
-    const fired = applyReplyTerminalReaction('-200', undefined, 0, {
-      endStatusReaction,
-      writeError,
-    })
-
-    expect(fired).toBe(false)
-    expect(endStatusReaction).not.toHaveBeenCalled()
+  it('executeReply post-send block DOES call finalizeStatusReaction gated on isFinalAnswerReply (#1728 wedge fix)', () => {
+    // #1728 — the v0.13.27 wedge: `turn_duration` system events from
+    // Claude Code don't reliably land for trivial-prompt turns, so
+    // activeTurnStartedAt never clears and every subsequent inbound
+    // gets held mid-turn. The fix: when executeReply detects a final-
+    // answer reply (the same `isFinalAnswerReply` classifier #1664
+    // uses for silent-end re-prompt gating), trigger
+    // `finalizeStatusReaction` to release the buffer gate. Interim
+    // acks (isFinalAnswerReply === false) MUST bypass this branch and
+    // remain non-events for the reaction (preserves #1713).
+    //
+    // If a future commit removes the finalizeStatusReaction call or
+    // un-gates it from isFinalAnswerReply, the wedge returns.
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    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')
+    const src = fs.readFileSync(
+      path.resolve(__dirname, '../gateway/gateway.ts'),
+      'utf8',
+    )
+    const anchor = src.indexOf("fresh sendMessage from reply tool is a user-visible")
+    expect(anchor).toBeGreaterThan(-1)
+    const slice = src.slice(anchor, anchor + 3000)
+    // The finalize MUST appear in the post-send block.
+    expect(slice).toMatch(/finalizeStatusReaction\(/)
+    // It MUST be gated by isFinalAnswerReply (the classifier prevents
+    // interim acks from firing 👍, which would regress #1713).
+    expect(slice).toMatch(/isFinalAnswerReply\(/)
+    // Sanity: the finalize MUST appear AFTER the isFinalAnswerReply
+    // check (i.e. inside the gated branch), not as a sibling that
+    // fires unconditionally.
+    const gateIdx = slice.indexOf('isFinalAnswerReply(')
+    const finalizeIdx = slice.indexOf('finalizeStatusReaction(')
+    expect(gateIdx).toBeGreaterThan(-1)
+    expect(finalizeIdx).toBeGreaterThan(gateIdx)
   })
 
-  it('swallows endStatusReaction throws and surfaces them via writeError', () => {
-    // Defence-in-depth: the controller lookup may race a concurrent
-    // purge. The reply path must not surface a status-reaction
-    // bookkeeping failure to the agent — the message itself already
-    // landed. Pin that the throw is logged, not propagated.
-    const endStatusReaction = vi.fn(() => {
-      throw new Error('controller missing')
-    })
-    const writeError = vi.fn()
-
-    const fired = applyReplyTerminalReaction('-300', undefined, 1, {
-      endStatusReaction,
-      writeError,
-    })
-
-    expect(fired).toBe(false)
-    expect(endStatusReaction).toHaveBeenCalledTimes(1)
-    expect(writeError).toHaveBeenCalledTimes(1)
-    expect(writeError.mock.calls[0][0]).toMatch(/endStatusReaction hook threw/)
+  it('reply tool deps no longer wire a status-reaction terminal callback', () => {
+    // Post-#1713 the stream-reply-handler has no call site for
+    // `deps.endStatusReaction`. Post follow-up cleanup, the dep itself
+    // is gone too — this test pins that the stream-reply-handler source
+    // contains no live call to `deps.endStatusReaction`.
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    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')
+    const src = fs.readFileSync(
+      path.resolve(__dirname, '../stream-reply-handler.ts'),
+      'utf8',
+    )
+    // Only the interface declaration may mention it; no call site.
+    expect(src).not.toMatch(/deps\.endStatusReaction\(/)
   })
 
-  it('fires for multi-chunk replies as well as single-chunk', () => {
-    // Long replies are split across multiple sendMessage calls. As
-    // long as at least one chunk landed, the user saw the answer —
-    // the terminal 👍 reflects "delivered", not "delivered in one
-    // piece".
-    const endStatusReaction = vi.fn()
-    const writeError = vi.fn()
-
-    applyReplyTerminalReaction('-400', 7, 5, {
-      endStatusReaction,
-      writeError,
-    })
-
-    expect(endStatusReaction).toHaveBeenCalledWith('-400', 7, 'done')
+  it('threadId/chatId are still recorded for outbound-dedup', () => {
+    // Sanity check — removing the reaction call must not have removed
+    // the dedup/signal-tracker recording for the reply, which is what
+    // suppresses replayed un-acked tool_calls after a bridge reconnect.
+    const noteSignal = vi.fn()
+    const recordOutbound = vi.fn()
+    // Simulate the post-send block — only the dedup/signal-tracker
+    // calls should fire, and they should fire unconditionally on
+    // sentIds.length > 0.
+    function postSendBlock(sentIdsLength: number) {
+      if (sentIdsLength > 0) {
+        noteSignal('chat:thread', Date.now())
+        recordOutbound('chat', null, 'text')
+      }
+    }
+    postSendBlock(1)
+    expect(noteSignal).toHaveBeenCalledTimes(1)
+    expect(recordOutbound).toHaveBeenCalledTimes(1)
   })
 })

package/telegram-plugin/tests/status-accent.test.ts

@@ -60,7 +60,6 @@ function makeDeps(
     disableLinkPreview: true,
     defaultFormat: 'html',
     logStreamingEvent: () => {},
-    endStatusReaction: () => {},
     historyEnabled: false,
     recordOutbound: () => {},
     writeError: () => {},

package/telegram-plugin/tests/status-reactions.test.ts

@@ -94,7 +94,7 @@ describe('StatusReactionController', () => {
     expect(calls).toEqual(['👀'])
   })
 
-  it('setThinking is debounced by 700ms', async () => {
+  it('setThinking is debounced by 3500ms (#1713)', async () => {
     const { emit, calls } = makeEmitter()
     const ctrl = new StatusReactionController(emit)
     ctrl.setQueued()
@@ -106,43 +106,43 @@ describe('StatusReactionController', () => {
     // Not yet — debounce window
     expect(calls).toEqual(['👀'])
 
-    vi.advanceTimersByTime(700)
+    vi.advanceTimersByTime(3500)
     await flush()
     expect(calls).toEqual(['👀', '🤔'])
   })
 
-  it('rapid intermediate transitions only emit the last one (coalesces)', async () => {
+  it('rapid intermediate transitions only emit the last one (coalesces) — #1713', async () => {
     const { emit, calls } = makeEmitter()
     const ctrl = new StatusReactionController(emit)
     ctrl.setQueued()
     await flush()
 
-    // Simulate model flashing thinking → tool → thinking → coding within 200ms
+    // Simulate model flashing thinking → tool → thinking → coding within 1.2s
     ctrl.setThinking()
-    vi.advanceTimersByTime(100)
+    vi.advanceTimersByTime(400)
     ctrl.setTool('Bash')
-    vi.advanceTimersByTime(100)
+    vi.advanceTimersByTime(400)
     ctrl.setThinking()
-    vi.advanceTimersByTime(100)
+    vi.advanceTimersByTime(400)
     ctrl.setTool('Read')
     await flush()
 
     // Still nothing — debounce hasn't elapsed
     expect(calls).toEqual(['👀'])
 
-    vi.advanceTimersByTime(700)
+    vi.advanceTimersByTime(3500)
     await flush()
     // Only the final state lands (Read → coding 👨‍💻)
     expect(calls).toEqual(['👀', '👨‍💻'])
   })
 
-  it('setDone is terminal and bypasses debounce', async () => {
+  it('finalize() is the only terminal trigger and bypasses debounce (#1713)', async () => {
     const { emit, calls } = makeEmitter()
     const ctrl = new StatusReactionController(emit)
     ctrl.setQueued()
     await flush()
 
-    ctrl.setDone()
+    ctrl.finalize('done')
     await flush()
     expect(calls).toEqual(['👀', '👍'])
 
@@ -153,47 +153,76 @@ describe('StatusReactionController', () => {
     expect(calls).toEqual(['👀', '👍'])
   })
 
-  it('setError is terminal', async () => {
+  it('setError is NON-terminal — recovery to a working state is allowed (#1713)', async () => {
     const { emit, calls } = makeEmitter()
     const ctrl = new StatusReactionController(emit)
     ctrl.setQueued()
     await flush()
 
     ctrl.setError()
+    // setError is debounced (it's a normal working transition now).
+    vi.advanceTimersByTime(3500)
     await flush()
     expect(calls).toEqual(['👀', '😱'])
 
+    // Recovery to thinking is permitted — the controller is NOT finished.
+    ctrl.setThinking()
+    vi.advanceTimersByTime(3500)
+    await flush()
+    expect(calls).toEqual(['👀', '😱', '🤔'])
+
+    // Only finalize() ends.
+    ctrl.finalize('done')
+    await flush()
+    expect(calls).toEqual(['👀', '😱', '🤔', '👍'])
+  })
+
+  it('finalize("error") terminates with 😱 (#1713)', async () => {
+    const { emit, calls } = makeEmitter()
+    const ctrl = new StatusReactionController(emit)
+    ctrl.setQueued()
+    await flush()
+
+    ctrl.finalize('error')
+    await flush()
+    expect(calls).toEqual(['👀', '😱'])
+
+    // Subsequent calls are no-ops — terminal.
     ctrl.setThinking()
     vi.advanceTimersByTime(5000)
     await flush()
     expect(calls).toEqual(['👀', '😱'])
   })
 
-  it('issue #132: setSilent is terminal and uses 🙊 (distinct from 👍 done)', async () => {
+  it('working transitions are bidirectional — thinking → tool → thinking (#1713)', async () => {
     const { emit, calls } = makeEmitter()
     const ctrl = new StatusReactionController(emit)
     ctrl.setQueued()
     await flush()
-    ctrl.setTool('Bash')
-    vi.advanceTimersByTime(800)
+
+    ctrl.setThinking()
+    vi.advanceTimersByTime(3500)
     await flush()
+    expect(calls).toEqual(['👀', '🤔'])
 
-    // Turn ends without producing a reply.
-    ctrl.setSilent()
+    ctrl.setTool('Bash')
+    vi.advanceTimersByTime(3500)
     await flush()
-    // 🙊 is in the Telegram bot reaction whitelist (speak-no-evil monkey).
-    // The choice signals "agent ran tools but said nothing" — distinct
-    // from 👍 which the user reads as "agent acknowledged with a reply".
-    // setTool('Bash') resolves to the 'coding' state → 👨‍💻 (first variant).
-    expect(calls).toEqual(['👀', '👨‍💻', '🙊'])
+    expect(calls).toEqual(['👀', '🤔', '👨‍💻'])
 
-    // Subsequent calls are no-ops (terminal).
+    // Back to thinking — same state can re-enter.
     ctrl.setThinking()
-    vi.advanceTimersByTime(5000)
+    vi.advanceTimersByTime(3500)
     await flush()
-    expect(calls).toEqual(['👀', '👨‍💻', '🙊'])
+    expect(calls).toEqual(['👀', '🤔', '👨‍💻', '🤔'])
   })
 
+  // #1713: setSilent was deleted as dead code. The "turn ended without a
+  // reply" path now finalizes to 👍 like any other turn — `turn_end` is
+  // the terminal trigger, regardless of whether a reply landed. The
+  // distinct-silent-emoji concept was never wired into production
+  // anyway (no live callers as of the issue audit).
+
   it('promotes to stallSoft after 30s of no progress', async () => {
     const { emit, calls } = makeEmitter()
     const ctrl = new StatusReactionController(emit)
@@ -228,7 +257,7 @@ describe('StatusReactionController', () => {
     // Tick 25s, then signal progress
     vi.advanceTimersByTime(25000)
     ctrl.setThinking() // resets stall timers
-    vi.advanceTimersByTime(800)
+    vi.advanceTimersByTime(3500)
     await flush()
     // We should have queued + thinking, but no stall yet
     expect(calls).toEqual(['👀', '🤔'])
@@ -266,7 +295,7 @@ describe('StatusReactionController', () => {
     expect(calls).toEqual(['👍'])
 
     ctrl.setThinking() // wants 🤔, falls back through variants, then generic — none in allowed
-    vi.advanceTimersByTime(700)
+    vi.advanceTimersByTime(3500)
     await flush()
     // 🤔, 🤓, 👀 — none allowed; broad fallback hits 👍 but it's already current → no emit
     expect(calls).toEqual(['👍'])
@@ -289,7 +318,7 @@ describe('StatusReactionController', () => {
     await flush()
     // First call is in flight, blocked on firstPromise
 
-    ctrl.setDone() // also immediate (terminal)
+    ctrl.finalize() // also immediate (terminal)
     await flush()
 
     // The done call should be queued behind the in-flight queued call

package/telegram-plugin/tests/stream-reply-error-paths.test.ts

@@ -46,7 +46,6 @@ function makeDeps(
     disableLinkPreview: true,
     defaultFormat: 'html',
     logStreamingEvent: () => {},
-    endStatusReaction: () => {},
     historyEnabled: false,
     recordOutbound: () => {},
     writeError: () => {},

package/telegram-plugin/tests/stream-reply-handler.test.ts

@@ -41,7 +41,6 @@ function makeDeps(
     disableLinkPreview: true,
     defaultFormat: 'html',
     logStreamingEvent: () => {},
-    endStatusReaction: () => {},
     historyEnabled: false,
     recordOutbound: () => {},
     writeError: () => {},
@@ -180,21 +179,14 @@ describe('handleStreamReply', () => {
     expect(bot.api.sendMessage).toHaveBeenCalledTimes(1)
   })
 
-  it('done=true finalizes and fires terminal 👍 on default lane after finalize resolves', async () => {
-    // Bug Z fix: stream_reply(done=true) on the default (unnamed) lane
-    // now fires endStatusReaction('done') AFTER stream.finalize()
-    // resolves. This ties the 👍 emoji to actual Telegram delivery
-    // (the final draft edit landing) rather than to JSONL turn_end
-    // (which races the disconnect-flush and the dedup-suppress paths).
-    //
-    // Previously this test asserted endStatusReaction was NOT called,
-    // and the gateway turn_end handler was the sole 👍 emitter. That
-    // design left 👍 firing off either (a) a 500ms-lagged read of
-    // local history (turn-flush dedup branch), or (b) a disconnect
-    // event that may have fired before any verification of delivery.
+  it('done=true finalizes the stream but does NOT touch the reaction (#1713)', async () => {
+    // #1713: stream_reply done=true is a NON-EVENT for the status
+    // reaction. Stream completion is "I'm done speaking", not "turn
+    // over"; the model may continue with post-stream tool work. Only
+    // the gateway's turn_end IPC handler finalizes the reaction.
+    // This is a deliberate revert of the Bug Z fix (PR #602 follow-up).
     const state = makeState()
-    const endStatusReaction = vi.fn()
-    const deps = makeDeps(bot, { endStatusReaction })
+    const deps = makeDeps(bot)
 
     const pending = handleStreamReply(
       { chat_id: '1', text: 'final', done: true },
@@ -206,8 +198,6 @@ describe('handleStreamReply', () => {
 
     expect(result.status).toBe('finalized')
     expect(state.activeDraftStreams.size).toBe(0)
-    expect(endStatusReaction).toHaveBeenCalledTimes(1)
-    expect(endStatusReaction).toHaveBeenCalledWith('1', undefined, 'done')
   })
 
   it('done=true on a named lane does NOT fire terminal 👍', async () => {
@@ -216,8 +206,7 @@ describe('handleStreamReply', () => {
     // must not be allowed to claim turn-completion: a progress-lane
     // emit firing setDone would race the actual answer message.
     const state = makeState()
-    const endStatusReaction = vi.fn()
-    const deps = makeDeps(bot, { endStatusReaction })
+    const deps = makeDeps(bot)
 
     const pending = handleStreamReply(
       { chat_id: '1', text: 'progress snapshot', done: true, lane: 'progress' },
@@ -226,8 +215,6 @@ describe('handleStreamReply', () => {
     )
     await microtaskFlush()
     await pending
-
-    expect(endStatusReaction).not.toHaveBeenCalled()
   })
 
   it('done=true does NOT fire 👍 if finalize never produced a messageId', async () => {
@@ -236,8 +223,7 @@ describe('handleStreamReply', () => {
     // never landed, so 👍 must not fire. Pinning that the gating on
     // `getMessageId() != null` holds.
     const state = makeState()
-    const endStatusReaction = vi.fn()
-    const deps = makeDeps(bot, { endStatusReaction })
+    const deps = makeDeps(bot)
 
     await expect(
       handleStreamReply(
@@ -246,8 +232,6 @@ describe('handleStreamReply', () => {
         deps,
       ),
     ).rejects.toThrow(/exceeds Telegram's 4096-char limit/)
-
-    expect(endStatusReaction).not.toHaveBeenCalled()
   })
 
   it('done=true with historyEnabled records the final message row', async () => {

package/telegram-plugin/tests/streaming-e2e.test.ts

@@ -94,7 +94,6 @@ function setup(opts: { progressCardActive?: boolean } = {}): Fixture {
       disableLinkPreview: true,
       defaultFormat: 'html',
       logStreamingEvent: () => {},
-      endStatusReaction: () => {},
       historyEnabled: false,
       recordOutbound: () => {},
       writeError: () => {},

package/telegram-plugin/tests/streaming-orchestration.test.ts

@@ -413,7 +413,6 @@ function makeActivityDeps(
     disableLinkPreview: true,
     defaultFormat: 'text',
     logStreamingEvent: () => {},
-    endStatusReaction: () => {},
     historyEnabled: false,
     recordOutbound: () => {},
     writeError: () => {},

package/telegram-plugin/tests/subagent-handback-inbound-builder.test.ts

@@ -95,6 +95,28 @@ describe('buildSubagentHandbackInbound', () => {
     expect(inbound.text).toContain('…')
   })
 
+  it('carries meta.subagent_jsonl_id when jsonlAgentId is provided (#1719 dedup key)', () => {
+    const inbound = buildSubagentHandbackInbound({
+      ctx: {
+        chatId: '12345',
+        taskDescription: 'x',
+        resultText: 'y',
+        outcome: 'completed',
+        jsonlAgentId: 'jsonl-xyz',
+      },
+      nowMs: FIXED_NOW,
+    })
+    expect(inbound.meta.subagent_jsonl_id).toBe('jsonl-xyz')
+  })
+
+  it('omits meta.subagent_jsonl_id when jsonlAgentId is not provided (back-compat)', () => {
+    const inbound = buildSubagentHandbackInbound({
+      ctx: { chatId: '12345', taskDescription: 'x', resultText: 'y', outcome: 'completed' },
+      nowMs: FIXED_NOW,
+    })
+    expect(inbound.meta.subagent_jsonl_id).toBeUndefined()
+  })
+
   it('falls back to a placeholder when the description is blank', () => {
     const inbound = buildSubagentHandbackInbound({
       ctx: { chatId: '99', taskDescription: '   ', resultText: 'x', outcome: 'completed' },