switchroom 0.20.3 → 0.20.5

package/telegram-plugin/tests/progress-update.test.ts

@@ -8,6 +8,11 @@
  * (failed 9/1931) for the original symptom.
  */
 import { describe, it, expect, beforeEach, afterEach, spyOn, type Mock } from 'bun:test'
+import {
+  progressFallbackAtCap,
+  recordProgressFallbackSend,
+  _resetProgressFallbackCap,
+} from '../gateway/progress-fallback-cap.js'
 
 // Mock state shared across tests (simulates the module-level state in server.ts / gateway.ts)
 const progressUpdateLastSent = new Map<string, number>()
@@ -25,17 +30,24 @@ type ProgressUpdateResult =
 
 /**
  * Simplified progress_update implementation for testing.
- * Returns the same shape as the real tool handler.
+ * Mirrors the real tool handler's ORDERING (gateway.ts `executeProgressUpdate`):
+ * check caps → send (may throw) → count the delivery only AFTER it lands. The
+ * turn-less fallback path calls the REAL cap module, not a copy.
+ *
+ * `send` is an injectable seam so a test can make the send throw and assert no
+ * slot is consumed (Fix 2). It defaults to a successful send.
  */
 function executeProgressUpdate(args: {
   chat_id: string
   text: string
   message_thread_id?: number
+  send?: () => number
 }): ProgressUpdateResult {
   const { chat_id, message_thread_id } = args
   let { text } = args
   const threadId = message_thread_id
   const key = statusKey(chat_id, threadId)
+  const send = args.send ?? (() => Math.floor(Math.random() * 100000))
 
   // Truncate to 300 chars
   if (text.length > 300) {
@@ -53,20 +65,30 @@ function executeProgressUpdate(args: {
     }
   }
 
-  // Turn cap: max 5 calls per turn
+  // Attention cap: max 5 deliveries per turn atom, else a rolling fallback
+  // window when no turn atom exists. Checked BEFORE the send; the count is
+  // advanced only after a successful send (below).
   const turnStart = activeTurnStartedAt.get(key)
-  if (turnStart != null) {
-    const currentCount = progressUpdateTurnCount.get(key) ?? 0
-    if (currentCount >= 5) {
-      return { ok: false, reason: 'turn_limit' }
-    }
-    progressUpdateTurnCount.set(key, currentCount + 1)
+  const atCap =
+    turnStart != null
+      ? (progressUpdateTurnCount.get(key) ?? 0) >= 5
+      : progressFallbackAtCap(key, now)
+  if (atCap) {
+    return { ok: false, reason: 'turn_limit' }
   }
 
+  // Send. A throw here must NOT consume a slot — it propagates before any
+  // bookkeeping runs.
+  const message_id = send()
+
   progressUpdateLastSent.set(key, now)
+  if (turnStart != null) {
+    progressUpdateTurnCount.set(key, (progressUpdateTurnCount.get(key) ?? 0) + 1)
+  } else {
+    recordProgressFallbackSend(key, now)
+  }
 
-  // Mock message_id
-  return { ok: true, message_id: Math.floor(Math.random() * 100000) }
+  return { ok: true, message_id }
 }
 
 // Manual time mocking — bun:test compatible (bun lacks vi.setSystemTime).
@@ -81,6 +103,7 @@ describe('progress_update tool', () => {
     progressUpdateLastSent.clear()
     progressUpdateTurnCount.clear()
     activeTurnStartedAt.clear()
+    _resetProgressFallbackCap()
     mockNow = 1000
     dateSpy = spyOn(Date, 'now').mockImplementation(() => mockNow)
   })
@@ -220,7 +243,7 @@ describe('progress_update tool', () => {
     expect(progressUpdateTurnCount.get(key2)).toBe(1)
   })
 
-  it('when no active turn, still rate-limits but does not increment counter', () => {
+  it('when no active turn, still rate-limits but does not increment the turn counter', () => {
     // No activeTurnStartedAt entry for this chat
     const r1 = executeProgressUpdate({ chat_id: '999', text: 'First' })
     expect(r1.ok).toBe(true)
@@ -229,8 +252,81 @@ describe('progress_update tool', () => {
     const r2 = executeProgressUpdate({ chat_id: '999', text: 'Second' })
     expect(r2.ok).toBe(false)
 
-    // Counter should not have been incremented (no active turn)
+    // The per-turn counter is untouched on the turn-less path (the fallback
+    // window carries the count instead).
     const key = statusKey('999')
     expect(progressUpdateTurnCount.get(key)).toBeUndefined()
   })
+
+  // Fix 1: with NO turn atom, the fallback rolling window still caps at 5.
+  it('null-turn-atom context caps at 5 sends per window (Fix 1)', () => {
+    // No activeTurnStartedAt entry — the pre-fix code applied no cap here at
+    // all, so this loop would let a 6th (and every subsequent) send through.
+    for (let i = 1; i <= 5; i++) {
+      advance(25_000) // clear the 20s floor each time
+      const r = executeProgressUpdate({ chat_id: '888', text: `Update ${i}` })
+      expect(r.ok).toBe(true)
+    }
+    advance(25_000)
+    const r6 = executeProgressUpdate({ chat_id: '888', text: 'Update 6' })
+    expect(r6.ok).toBe(false)
+    if (!r6.ok) {
+      expect(r6.reason).toBe('turn_limit')
+    }
+  })
+
+  // Fix 2: a thrown send must NOT consume a cap slot (turn-scoped path).
+  it('a thrown send does not consume a turn-cap slot (Fix 2)', () => {
+    const key = statusKey('777')
+    activeTurnStartedAt.set(key, 1000)
+    progressUpdateTurnCount.set(key, 0)
+
+    // A send that throws: the cap was checked, but nothing was delivered.
+    expect(() =>
+      executeProgressUpdate({
+        chat_id: '777',
+        text: 'boom',
+        send: () => {
+          throw new Error('telegram 500')
+        },
+      }),
+    ).toThrow('telegram 500')
+
+    // Slot NOT consumed — pre-fix the counter incremented before the send.
+    expect(progressUpdateTurnCount.get(key)).toBe(0)
+
+    // A subsequent successful send still has its full budget and counts once.
+    advance(25_000)
+    const r = executeProgressUpdate({ chat_id: '777', text: 'real' })
+    expect(r.ok).toBe(true)
+    expect(progressUpdateTurnCount.get(key)).toBe(1)
+  })
+
+  // Fix 2 composed with Fix 1: a thrown send on the turn-less path records
+  // nothing in the fallback window either.
+  it('a thrown send does not consume a fallback-window slot (Fix 2 × Fix 1)', () => {
+    // Five throwing sends on the turn-less path.
+    for (let i = 0; i < 5; i++) {
+      advance(25_000)
+      expect(() =>
+        executeProgressUpdate({
+          chat_id: '666',
+          text: 'boom',
+          send: () => {
+            throw new Error('telegram 500')
+          },
+        }),
+      ).toThrow('telegram 500')
+    }
+    // The window is still empty — five throws consumed no slots, so five real
+    // sends are still allowed.
+    for (let i = 1; i <= 5; i++) {
+      advance(25_000)
+      const r = executeProgressUpdate({ chat_id: '666', text: `real ${i}` })
+      expect(r.ok).toBe(true)
+    }
+    advance(25_000)
+    const capped = executeProgressUpdate({ chat_id: '666', text: 'over' })
+    expect(capped.ok).toBe(false)
+  })
 })

package/telegram-plugin/tests/silence-poke-card-render.test.ts

@@ -0,0 +1,300 @@
+/**
+ * #4330 — a visibly-updating pinned activity card must not be treated as
+ * silence by the 300s terminal fallback.
+ *
+ * The bug (user-reported, with screenshot): the framework fired the terminal
+ * unwedge — "⚠️ no output for 5 min — the framework ended that stalled turn"
+ * — on a HEALTHY turn whose pinned "→ Working… · Nm · N tools" status card
+ * WAS actively updating the whole time. The card edits are driven by
+ * `feedHeartbeatTick` (the 0-label climb / labelled-step elapsed re-render)
+ * through `drainActivitySummary`'s editMessageText, and that transport path
+ * had NO `noteProduction`/`noteOutbound` site — deliberately, because the
+ * heartbeat climbs on pure wall clock and an unbounded clock RESET would keep
+ * a genuinely hung turn alive forever (the #1556 class). So when every defer
+ * signal (in-flight tool, pending async dispatch, alive shells, compaction)
+ * read false at the 300s tick, the fallback tore down the very card the user
+ * was watching and re-asked their message.
+ *
+ * The fix: `drainActivitySummary` stamps `silencePoke.noteCardRender` on
+ * every card render that actually lands (open or non-shed edit); tick()
+ * DEFERS the terminal fallback while the last landed render is younger than
+ * `CARD_RENDER_FRESH_MS`, bounded by `fallbackHardCeiling` exactly like the
+ * #1292/#3519/#4058 defers. These tests drive the REAL tick loop (and, for
+ * the wiring case, the REAL narrative-lane transport) and assert outcomes:
+ *   - card renders arriving faster than the fresh window → NO fire past 300s;
+ *   - renders that keep coming forever → STILL fires at the hard ceiling
+ *     (a hung turn's heartbeat keeps climbing, so the net must stay bounded);
+ *   - a genuinely silent turn (no renders, no tool, no reply) → STILL fires
+ *     at 300s (the safety net is not disabled);
+ *   - renders that STOP → the fallback fires once silence ≥ threshold and
+ *     the last render has aged out (no unearned extension);
+ *   - wiring: a card edit through the REAL `createNarrativeLane` drain
+ *     defers the fallback for its status key.
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import { readFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+import { tmpdir } from 'node:os'
+import { createNarrativeLane } from '../gateway/narrative-lane.js'
+import type { CurrentTurn, NarrativeLaneDeps } from '../gateway/gateway.js'
+import * as silencePoke from '../silence-poke.js'
+import {
+  startTurn,
+  noteCardRender,
+  __tickForTests,
+  __setDepsForTests,
+  __getStateForTests,
+  __resetAllForTests,
+  DEFAULT_THRESHOLDS,
+  CARD_RENDER_FRESH_MS,
+  type SilencePokeMetric,
+  type FrameworkFallbackContext,
+  type ThresholdsMs,
+} from '../silence-poke.js'
+
+const HARD_CEILING = 900_000 // SILENCE_FALLBACK_HARD_MS default
+
+interface TestFixtures {
+  emitted: SilencePokeMetric[]
+  fallbacks: FrameworkFallbackContext[]
+}
+
+function setupDeps(opts?: { thresholdsMs?: ThresholdsMs }): TestFixtures {
+  const fixtures: TestFixtures = { emitted: [], fallbacks: [] }
+  __setDepsForTests({
+    emitMetric: (e) => fixtures.emitted.push(e),
+    onFrameworkFallback: (ctx) => { fixtures.fallbacks.push(ctx) },
+    thresholdsMs: opts?.thresholdsMs
+      ?? { ...DEFAULT_THRESHOLDS, fallbackHardCeiling: HARD_CEILING },
+    // Mirror production wiring: the callback path is active (liveness-wiring
+    // always wires isLegitimatelyWorking), returning false = "no tool work".
+    isLegitimatelyWorking: () => false,
+  })
+  return fixtures
+}
+
+beforeEach(() => {
+  __resetAllForTests()
+  delete process.env.SWITCHROOM_DISABLE_SILENCE_POKE
+  delete process.env.SWITCHROOM_SILENCE_DEFER_INFLIGHT_TOOLS
+})
+
+afterEach(() => {
+  __resetAllForTests()
+})
+
+describe('silence-poke — #4330 card-render defer (outcome)', () => {
+  it('a turn whose ONLY output is card renders faster than the fresh window is NOT torn down past 300s', () => {
+    const fx = setupDeps()
+    startTurn('chat:1', 0)
+    // The heartbeat edits the card every ~6s; simulate a card that keeps
+    // visibly updating for 10 minutes with no reply, no tool, no draft.
+    for (let t = 6_000; t <= 600_000; t += 6_000) {
+      noteCardRender('chat:1', t)
+      __tickForTests(t)
+    }
+    // Pre-fix this fired at the first tick with silence >= 300_000 — the
+    // exact "framework ended that stalled turn" false positive.
+    expect(fx.fallbacks).toHaveLength(0)
+    expect(fx.emitted).toHaveLength(0)
+  })
+
+  it('card renders that keep coming forever STILL fire the fallback at the hard ceiling (bounded defer)', () => {
+    const fx = setupDeps()
+    startTurn('chat:2', 0)
+    // A hung turn: the framework heartbeat keeps climbing the card on pure
+    // wall clock even though the model is dead. The defer must stay bounded.
+    let fired: number | null = null
+    for (let t = 6_000; t <= 1_200_000; t += 6_000) {
+      noteCardRender('chat:2', t)
+      __tickForTests(t)
+      if (fx.fallbacks.length > 0 && fired == null) fired = t
+    }
+    expect(fx.fallbacks).toHaveLength(1)
+    expect(fired).not.toBeNull()
+    expect(fired!).toBeGreaterThanOrEqual(HARD_CEILING)
+    // Fires promptly AT the ceiling, not some window after it.
+    expect(fired!).toBeLessThanOrEqual(HARD_CEILING + 6_000)
+  })
+
+  it('a genuinely silent turn (no card renders, no tool, no reply) STILL fires at 300s — the net is intact', () => {
+    const fx = setupDeps()
+    startTurn('chat:3', 0)
+    __tickForTests(299_000)
+    expect(fx.fallbacks).toHaveLength(0)
+    __tickForTests(300_000)
+    expect(fx.fallbacks).toHaveLength(1)
+    expect(fx.emitted.at(-1)).toMatchObject({ kind: 'silence_fallback_sent' })
+  })
+
+  it('card renders that STOP do not extend the window — fallback fires once the last render ages out', () => {
+    const fx = setupDeps()
+    startTurn('chat:4', 0)
+    // Card updated until t=100s (turn wedged after; heartbeat drain stuck /
+    // card torn down), then nothing.
+    for (let t = 6_000; t <= 100_000; t += 6_000) {
+      noteCardRender('chat:4', t)
+      __tickForTests(t)
+    }
+    // At 305s: silence (never reset by noteCardRender) is 305s >= 300s and
+    // the last render is 200s+ old — well past CARD_RENDER_FRESH_MS. Fires.
+    __tickForTests(305_000)
+    expect(fx.fallbacks).toHaveLength(1)
+    expect(fx.fallbacks[0]!.silenceMs).toBe(305_000)
+  })
+
+  it('noteCardRender never resets the silence clock or re-arms a fired fallback', () => {
+    setupDeps()
+    startTurn('chat:5', 0)
+    noteCardRender('chat:5', 250_000)
+    const s = __getStateForTests('chat:5')!
+    expect(s.lastOutboundAt).toBeNull() // clock untouched — defer only
+    expect(s.lastCardRenderAt).toBe(250_000)
+    expect(s.fallbackFired).toBe(false)
+  })
+})
+
+// ── wiring proof: the REAL narrative-lane card drain stamps the defer ─────
+
+const CHAT = '1001'
+
+function makeLane() {
+  const noop = () => {}
+  let nextId = 3000
+  const calls: Array<{ method: string }> = []
+  const api = {
+    sendRichMessage: async () => {
+      calls.push({ method: 'sendRichMessage' })
+      return { message_id: ++nextId }
+    },
+    editMessageText: async () => {
+      calls.push({ method: 'editMessageText' })
+      return {}
+    },
+    deleteMessage: async () => true,
+  }
+  const fakeEA = {
+    mayDrain: () => true,
+    openOrEditCard: (_p: string, fn: () => void) => fn(),
+    finalizeCard: (fn: () => void) => fn(),
+    markSubstantiveFinalDelivered: (fn: () => void) => fn(),
+  }
+  const deps = {
+    ACTIVITY_CARD_STORE_PATH: `${tmpdir()}/silence-card-render-activity-cards.json`,
+    CLEAR_STATUS_ON_COMPLETION: false,
+    FEED_HEARTBEAT_ENABLED: false,
+    FEED_HEARTBEAT_MIN_STALE_MS: 6000,
+    FEED_LIVENESS_OPEN_ENABLED: false,
+    FEED_LIVENESS_OPEN_MS: 5000,
+    PIN_STATUS_WHILE_WORKING: false,
+    POST_ANSWER_LIVENESS_STALE_MS: 90000,
+    STATIC: false,
+    activeDraftStreams: new Map(),
+    activityCardPersistEnabled: false,
+    activityCardStoreFs: { readFileSync: () => '', writeFileSync: noop, mkdirSync: noop, renameSync: noop, unlinkSync: noop },
+    bot: { api },
+    cardDrainGate: (_t: unknown, _ea: unknown, run: () => void) => run(),
+    currentTurnMap: { get: () => null, byKey: new Map() },
+    earlyLivenessOpenTimers: new Map(),
+    emissionAuthorityFor: () => fakeEA,
+    feedOpenGateDeps: () => ({ hasOutboundDeliveredSince: () => false, historyEnabled: false, finalAnswerMinChars: 200 }),
+    getCurrentTurn: () => null,
+    reconcileStatusPin: noop,
+    robustApiCall: (fn: () => Promise<unknown>) => fn(),
+    // Same key shape silence-poke is driven with below.
+    statusKey: (c: string, t?: number | null) => `${c}:${t ?? ''}`,
+  } as unknown as NarrativeLaneDeps
+  const lane = createNarrativeLane(deps)
+  return { lane, calls }
+}
+
+function makeLaneTurn(lane: ReturnType<typeof createNarrativeLane>): CurrentTurn {
+  const turn = {
+    turnId: 'turn-card-render-1',
+    sessionChatId: CHAT,
+    sessionThreadId: undefined,
+    sourceMessageId: null,
+    registryKey: null,
+    startedAt: Date.now() - 3000,
+    currentModel: null,
+    totalTokens: 0,
+    labeledToolCount: 0,
+    mirrorLines: [] as string[],
+    foregroundSubAgents: new Map<string, string[]>(),
+    activityPendingRender: null as string | null,
+    activityLastSentRender: null as string | null,
+    activityMessageId: null as number | null,
+    activityInFlight: null as Promise<void> | null,
+    activityEverOpened: false,
+    activityDrainFailures: 0,
+    finalAnswerEverDelivered: false,
+    finalAnswerDelivered: false,
+    replyCalled: false,
+    capturedText: [] as string[],
+    lastReplyText: '',
+    answerStream: null,
+    liveness: { recentlyStreaming: () => false, onStreamEvent: () => {}, note: () => {} },
+  } as unknown as CurrentTurn
+  ;(turn as { narrativeGate?: unknown }).narrativeGate = lane.makeNarrativeGate(turn)
+  return turn
+}
+
+describe('silence-poke — #4330 wiring: the REAL card drain defers the fallback', () => {
+  it('a card render landed through drainActivitySummary defers a due fallback; without it the fallback fires', async () => {
+    const key = `${CHAT}:`
+    const now = Date.now()
+    // Real wall clock end-to-end: tiny fallback threshold, real
+    // CARD_RENDER_FRESH_MS (the lane stamps Date.now()).
+    const fx = setupDeps({
+      thresholdsMs: { fallback: 1_000, fallbackHardCeiling: HARD_CEILING },
+    })
+
+    // Control first: a turn past the threshold with NO card render fires.
+    startTurn(key, now - 5_000)
+    __tickForTests(now)
+    expect(fx.fallbacks).toHaveLength(1)
+
+    // Now the same shape, but a card render lands through the REAL lane
+    // transport before the tick — the fallback must be deferred.
+    __resetAllForTests()
+    const fx2 = setupDeps({
+      thresholdsMs: { fallback: 1_000, fallbackHardCeiling: HARD_CEILING },
+    })
+    startTurn(key, Date.now() - 5_000)
+    const { lane, calls } = makeLane()
+    const turn = makeLaneTurn(lane)
+    lane.showNarrativeStep(turn, 'Compiling the release notes')
+    await turn.activityInFlight
+    expect(calls.filter((c) => c.method === 'sendRichMessage')).toHaveLength(1)
+    const st = __getStateForTests(key)!
+    expect(st.lastCardRenderAt).not.toBeNull() // the drain stamped it
+    __tickForTests(Date.now())
+    expect(fx2.fallbacks).toHaveLength(0) // deferred: the card just moved
+
+    // And the defer stays bounded: past the hard ceiling it fires anyway,
+    // even with a render landed inside the fresh window at fire time.
+    const tFinal = Date.now() + HARD_CEILING + CARD_RENDER_FRESH_MS
+    noteCardRender(key, tFinal - 1_000) // card still "moving" at the ceiling
+    __tickForTests(tFinal)
+    expect(fx2.fallbacks).toHaveLength(1)
+  })
+})
+
+// ── structural: progress_update (a model-driven user-visible send inside the
+//    gateway IIFE, not instantiable in-process — same pattern as
+//    silence-liveness-wiring.test.ts) must reset the silence clock ──────────
+
+describe('silence-poke — #4330 progress_update liveness wiring (structural)', () => {
+  it('the progress_update handler calls silencePoke.noteOutbound after the send lands', () => {
+    const gatewaySrc = readFileSync(resolve(__dirname, '..', 'gateway', 'gateway.ts'), 'utf-8')
+    const start = "if (!args.chat_id) throw new Error('progress_update: chat_id is required')"
+    const end = '`ask_user` MCP tool'
+    const block = (gatewaySrc.split(start)[1] ?? '').split(end)[0] ?? ''
+    expect(block.length).toBeGreaterThan(100) // sanity: slice found the handler
+    // A progress_update is a fresh user-visible outbound the model authored —
+    // it must reset the 300s silence clock exactly like a reply send does
+    // (outbound-send-path.ts). Pre-#4330 only signalTracker was ticked, so a
+    // turn narrating solely via progress_update was torn down as "silent".
+    expect(block).toMatch(/silencePoke\.noteOutbound\(key, Date\.now\(\)\)/)
+  })
+})

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

@@ -165,3 +165,49 @@ describe('buildSubagentHandbackInbound', () => {
     expect(inbound.meta.message_thread_id).toBeUndefined()
   })
 })
+
+// ─── msg-6897 misroute regression (2026-08-04): meta.chat_id is LOAD-BEARING ──
+// The gateway's enqueue handler (`beginTurn`, stream-render.ts) gates the
+// ENTIRE turn-atom mint — `recordTurnStart` (the `turns` row) AND
+// `writeTurnActiveMarker` (the #2085 dispatch-time stamp source) — on
+// `ev.chatId`, which is parsed from the channel XML's `chat_id` attribute,
+// rendered ONLY from meta (bridge.ts onInbound → mcp.notification meta).
+// Without meta.chat_id a handback turn registers NO surface, so a worker
+// dispatched from inside it has a NULL parent_turn_key (no marker to stamp
+// from, no turn window for the backfill) and its card/handback misroutes to
+// the owner DM with the thread stripped. Mirrors the real-inbound shape
+// (inbound-router.ts buildInboundEnvelope meta.chat_id) and the
+// resume_interrupted builder's identical fix.
+describe('buildSubagentHandbackInbound — meta.chat_id turn registration (msg-6897)', () => {
+  it('carries the origin chat as meta.chat_id so the handback turn mints a turn atom', () => {
+    const inbound = buildSubagentHandbackInbound({
+      ctx: {
+        chatId: '-1004223464247',
+        threadId: 77,
+        taskDescription: 'Topic-dispatched work',
+        resultText: 'done',
+        outcome: 'completed',
+      },
+      nowMs: FIXED_NOW,
+    })
+    expect(inbound.meta.chat_id).toBe('-1004223464247')
+    // The thread carrier must still ride alongside — chat_id + thread_id is
+    // the full origin surface the minted turn (and any worker dispatched
+    // inside it) inherits.
+    expect(inbound.meta.message_thread_id).toBe('77')
+  })
+
+  it('carries meta.chat_id for DM-shaped chats too (no thread)', () => {
+    const inbound = buildSubagentHandbackInbound({
+      ctx: {
+        chatId: '12345',
+        taskDescription: 'x',
+        resultText: 'y',
+        outcome: 'failed',
+      },
+      nowMs: FIXED_NOW,
+    })
+    expect(inbound.meta.chat_id).toBe('12345')
+    expect(inbound.meta.message_thread_id).toBeUndefined()
+  })
+})

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

@@ -353,3 +353,29 @@ describe('decideSubagentProgress', () => {
     }
   })
 })
+
+// ─── msg-6897 misroute regression (2026-08-04): meta.chat_id is LOAD-BEARING ──
+// Same turn-registration contract as the handback builder (see
+// subagent-handback-inbound-builder.test.ts): without meta.chat_id the
+// progress turn's channel XML has no chat_id, the gateway mints no turn atom
+// (no `turns` row, no `turn-active.json`), and a worker dispatched from
+// inside the progress turn can never be attributed to its chat/topic.
+describe('buildSubagentProgressInbound — meta.chat_id turn registration (msg-6897)', () => {
+  it('carries the origin chat as meta.chat_id', () => {
+    const inbound = buildSubagentProgressInbound({
+      ctx: {
+        chatId: '-1004223464247',
+        threadId: 77,
+        subagentJsonlId: 'stem1',
+        taskDescription: 'Topic work',
+        latestSummary: 'still going',
+        elapsedMs: 6 * 60_000,
+        bucketIdx: 1,
+        progressIntervalMs: 5 * 60_000,
+      },
+      nowMs: 1_700_000_000_000,
+    })
+    expect(inbound.meta.chat_id).toBe('-1004223464247')
+    expect(inbound.meta.message_thread_id).toBe('77')
+  })
+})