switchroom 0.19.31 → 0.19.32

package/telegram-plugin/session-tail.ts

@@ -93,6 +93,13 @@ export function findActiveSessionFile(projectsDir: string): string | null {
 export type SessionEvent =
   | { kind: 'enqueue'; chatId: string | null; messageId: string | null; threadId: string | null; rawContent: string; isSync?: boolean }
   | { kind: 'dequeue' }
+  // #3927 — `queue-operation` op `remove`: the queued item was folded into the
+  // ALREADY-RUNNING turn as a `queued_command` attachment rather than drained
+  // into a new turn. It is the OTHER terminal of an `enqueue` (the CLI writes
+  // exactly one of `dequeue` / `remove` per enqueue), and unlike `dequeue` it
+  // REPLAYS the enqueue's `content` byte-for-byte — which is what lets the
+  // gateway discard the right parked turn-start by identity.
+  | { kind: 'queue_remove'; rawContent: string }
   | { kind: 'thinking' }
   // Live model in use for the MAIN session, extracted from `message.model` on
   // each `type:"assistant"` transcript line (the exact model that served that
@@ -566,6 +573,12 @@ export function projectTranscriptLine(line: string): SessionEvent[] {
     if (op === 'dequeue') {
       return [{ kind: 'dequeue' }]
     }
+    // #3927 — the enqueue's OTHER terminal. Previously dropped, which left the
+    // gateway unable to tell "queued message folded into the running turn"
+    // (`remove`) from "queue drained into a new turn" (`dequeue`).
+    if (op === 'remove') {
+      return [{ kind: 'queue_remove', rawContent: (obj.content as string | undefined) ?? '' }]
+    }
     return []
   }
 

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

@@ -19,10 +19,14 @@
  * the duplicate. This is the exact duplicate-reply class the shared-singleton
  * injection (never a re-`new`) exists to kill.
  */
-import { describe, it, expect } from 'vitest'
+import { describe, it, expect, beforeEach } from 'vitest'
 import { readFileSync } from 'node:fs'
 import { tmpdir } from 'node:os'
-import { handleSessionEvent, type StreamRenderDeps } from '../gateway/stream-render.js'
+import {
+  handleSessionEvent,
+  __resetParkedTurnStartsForTest,
+  type StreamRenderDeps,
+} from '../gateway/stream-render.js'
 import {
   sendReply,
   type SendReplyGatewayDeps,
@@ -612,6 +616,9 @@ describe('structural — the singleton lives once in gateway, never in the modul
 // the assertion is the OUTCOME the user sees — chat actions on the wire — not
 // the call.
 describe('#3544 — turn-start typing is unconditional at the enqueue seam', () => {
+  // #3927's parked turn-start store is module-scope (one CLI session, one
+  // queue), so reset it between cases for determinism.
+  beforeEach(() => { __resetParkedTurnStartsForTest() })
   interface TypingRig {
     h: StreamHarness
     sent: Array<{ chatId: string; threadId: number | null }>
@@ -669,15 +676,23 @@ describe('#3544 — turn-start typing is unconditional at the enqueue seam', ()
 
   it('FLOOD GUARD: N turns arming on ONE chat inside the floor cost at most ONE chat action', () => {
     const rig = makeTypingRig({ adopts: false })
+    // #3927: a repeated bare `enqueue` no longer mints a turn — while one is
+    // live it PARKS, and the CLI's `dequeue` is what starts the next turn. This
+    // guard is about N turn STARTS coalescing, so drive real starts: the first
+    // enqueue mints (idle) and each later enqueue+dequeue pair mints one more.
+    const startTurn = () => {
+      handleSessionEvent(rig.h.deps, enqueue())
+      handleSessionEvent(rig.h.deps, { kind: 'dequeue' })
+    }
     // 12 arms on one chat inside a single floor window: a real-inbound arm
-    // (turn-start-surfaces) plus repeated enqueue seams / restarts.
+    // (turn-start-surfaces) plus repeated turn-start seams / restarts.
     rig.loop.start(CHAT, null) // stand-in for the real-inbound path's arm
-    for (let i = 0; i < 11; i++) handleSessionEvent(rig.h.deps, enqueue())
+    for (let i = 0; i < 11; i++) startTurn()
     expect(rig.sent).toHaveLength(1) // the floor coalesced all 12
     expect(rig.loop.activeCount()).toBe(1) // restart-safe: no interval pile-up
     // Crossing the floor lets exactly one more through, then the floor holds again.
     rig.clock.t += TYPING_FLOOR_MS
-    for (let i = 0; i < 5; i++) handleSessionEvent(rig.h.deps, enqueue())
+    for (let i = 0; i < 5; i++) startTurn()
     expect(rig.sent).toHaveLength(2)
     rig.loop.stopAll()
     rig.emitter.reset()

package/telegram-plugin/tests/turn-mint-defers-until-dequeue.test.ts

@@ -0,0 +1,196 @@
+/**
+ * #3927 FIX A — a QUEUE event is not a TURN-START event.
+ *
+ * Pre-fix, `case 'enqueue'` in stream-render.ts unconditionally minted a fresh
+ * `CurrentTurn` and swapped it into the per-topic slot, even with a turn
+ * already live. The claude CLI writes `{"type":"queue-operation","operation":
+ * "enqueue"}` at QUEUE time, so a message the operator sent mid-turn produced
+ * a brand-new card (reset `startedAt` / `toolCallCount` / `mirrorLines`) that
+ * then streamed the STILL-RUNNING previous turn's tool labels into it, while
+ * the real turn's card froze on its last edit.
+ *
+ * Ground truth (60 real agent transcripts, 372 enqueues): every enqueue is
+ * terminated by exactly one of
+ *   • `dequeue` — queue drained into a NEW turn (199/200 dequeues are directly
+ *     preceded by their enqueue; median gap 6 ms idle, 2–14 s when queued
+ *     behind a running turn), or
+ *   • `remove`  — folded into the ALREADY-RUNNING turn as a `queued_command`
+ *     attachment, replaying the enqueue's `content` byte-for-byte.
+ *
+ * These drive the REAL `handleSessionEvent` (extracted-module golden-harness
+ * oracle, same standard as `stream-render-golden.test.ts`).
+ */
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+import {
+  handleSessionEvent,
+  __resetParkedTurnStartsForTest,
+  __parkedTurnStartCountForTest,
+} from '../gateway/stream-render.js'
+import { projectTranscriptLine } from '../session-tail.js'
+import { CHAT, enqueue, inbound, makeHarness } from './turn-mint-harness.js'
+
+beforeEach(() => {
+  __resetParkedTurnStartsForTest()
+})
+
+describe('#3927 FIX A — a mid-turn enqueue parks; the turn mints on dequeue', () => {
+  it('a second enqueue while turn A is live opens NO card, does not steal the slot, ' +
+    'and later tool labels still land on A — then dequeue mints B', () => {
+    const h = makeHarness()
+
+    // ── message A arrives on an idle session: mints immediately (unchanged) ──
+    handleSessionEvent(h.deps, enqueue('501'))
+    handleSessionEvent(h.deps, { kind: 'dequeue' }) // the CLI's ms-later pair
+    const turnA = h.current()!
+    expect(turnA).not.toBeNull()
+    expect(turnA.sourceMessageId).toBe(501)
+    expect(h.cardsOpened).toHaveLength(1)
+    // The idle enqueue already minted, so the paired dequeue found nothing
+    // parked and was a no-op — NOT a second turn.
+    expect(h.cardsOpened[0]!.sourceMessageId).toBe(501)
+
+    // ── A does tool work ────────────────────────────────────────────────────
+    handleSessionEvent(h.deps, { kind: 'tool_label', toolName: 'Read', label: 'Reading config.ts' })
+    expect(turnA.labeledToolCount).toBe(1)
+
+    // ── the operator sends message B MID-TURN (no turn_end for A) ───────────
+    handleSessionEvent(h.deps, enqueue('502', 'also check the vault'))
+
+    // No second card. This is BUG 1: pre-fix a fresh card appeared here with
+    // reset stats while A's froze.
+    expect(h.cardsOpened).toHaveLength(1)
+    // The topic slot still points at A — object identity, not just shape.
+    expect(h.current()).toBe(turnA)
+    // This is BUG 2: pre-fix the slot pointed at B, whose card quoted B's
+    // message id while streaming A's still-running work.
+    expect(h.current()!.sourceMessageId).toBe(501)
+    expect(__parkedTurnStartCountForTest()).toBe(1)
+
+    // ── labels emitted AFTER B still belong to A's card ─────────────────────
+    handleSessionEvent(h.deps, { kind: 'tool_label', toolName: 'Bash', label: 'Running tests' })
+    expect(turnA.labeledToolCount).toBe(2)
+    expect(turnA.mirrorLines.join('\n')).toContain('Running tests')
+    expect(h.drains.every((d) => d.turnId === turnA.turnId)).toBe(true)
+
+    // ── A ends, the CLI drains the queue → B's turn mints NOW ───────────────
+    turnA.endedAt = Date.now()
+    handleSessionEvent(h.deps, { kind: 'dequeue' })
+    const turnB = h.current()!
+    expect(turnB).not.toBe(turnA)
+    expect(turnB.sourceMessageId).toBe(502)
+    expect(h.cardsOpened).toHaveLength(2)
+    expect(h.cardsOpened[1]!.sourceMessageId).toBe(502)
+    // Fresh stats belong to B and only B.
+    expect(turnB.labeledToolCount).toBe(0)
+    expect(turnB.mirrorLines).toEqual([])
+    expect(__parkedTurnStartCountForTest()).toBe(0)
+  })
+
+  it('a `remove` terminal discards the parked start, so a LATER dequeue cannot ' +
+    'mint a spurious turn for an already-folded message', () => {
+    const h = makeHarness()
+    handleSessionEvent(h.deps, enqueue('601'))
+    const turnA = h.current()!
+
+    // Queued mid-turn, then folded into A as a `queued_command` attachment.
+    const queued = enqueue('602', 'while you are in there…')
+    handleSessionEvent(h.deps, queued)
+    expect(__parkedTurnStartCountForTest()).toBe(1)
+    handleSessionEvent(h.deps, { kind: 'queue_remove', rawContent: queued.rawContent })
+    expect(__parkedTurnStartCountForTest()).toBe(0)
+
+    // A stray dequeue now must NOT resurrect 602 as its own turn.
+    handleSessionEvent(h.deps, { kind: 'dequeue' })
+    expect(h.current()).toBe(turnA)
+    expect(h.cardsOpened).toHaveLength(1)
+  })
+
+  it('dequeue pairs with the MOST RECENT parked start (evidence: max observed ' +
+    'gap to the newest enqueue is 14.2 s; to the oldest, hours)', () => {
+    const h = makeHarness()
+    handleSessionEvent(h.deps, enqueue('701'))
+    const turnA = h.current()!
+
+    handleSessionEvent(h.deps, enqueue('702'))
+    handleSessionEvent(h.deps, enqueue('703'))
+    expect(__parkedTurnStartCountForTest()).toBe(2)
+
+    turnA.endedAt = Date.now()
+    handleSessionEvent(h.deps, { kind: 'dequeue' })
+    expect(h.current()!.sourceMessageId).toBe(703)
+    expect(__parkedTurnStartCountForTest()).toBe(1)
+  })
+
+  it('a chat-less enqueue never parks (it can never mint a turn)', () => {
+    const h = makeHarness()
+    handleSessionEvent(h.deps, { kind: 'enqueue', chatId: null, messageId: null, threadId: null, rawContent: 'x' })
+    expect(__parkedTurnStartCountForTest()).toBe(0)
+    expect(h.current()).toBeNull()
+    expect(h.cardsOpened).toHaveLength(0)
+  })
+
+  it('a parked start expires after its TTL, so a dequeue that never arrives can ' +
+    'never mint a stale turn later', () => {
+    // RUNNER-AGNOSTIC CLOCK. This file dual-runs (vitest + `bun test`), and
+    // bun's vitest shim does NOT implement `vi.setSystemTime` — calling it
+    // threw `TypeError: vi.setSystemTime is not a function` and made bun-test
+    // deterministically red. The TTL is a pure elapsed-time comparison
+    // (`now - parkedAt > PARKED_TURN_START_TTL_MS`), so the absolute wall
+    // clock is irrelevant; only the 31-minute JUMP matters. `useFakeTimers()`
+    // + `advanceTimersByTime()` moves `Date.now()` by exactly that delta on
+    // BOTH runners (same insight as races.test.ts:275-281), so the assertion
+    // below really executes under bun instead of being guarded away.
+    vi.useFakeTimers()
+    try {
+      const h = makeHarness()
+      handleSessionEvent(h.deps, enqueue('1201'))
+      const turnA = h.current()!
+      handleSessionEvent(h.deps, enqueue('1202'))
+      expect(__parkedTurnStartCountForTest()).toBe(1)
+
+      // The CLI died mid-turn: neither `dequeue` nor `remove` ever arrives.
+      vi.advanceTimersByTime(31 * 60_000) // TTL is 30 min
+      turnA.endedAt = Date.now()
+      handleSessionEvent(h.deps, { kind: 'dequeue' })
+
+      // 1202 was pruned, not minted 31 minutes late.
+      expect(__parkedTurnStartCountForTest()).toBe(0)
+      expect(h.current()).toBe(turnA)
+      expect(h.cardsOpened).toHaveLength(1)
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+
+  it('the parked store is bounded — the 17th mid-turn enqueue evicts the oldest, ' +
+    'so a dequeue that never arrives cannot grow it without limit', () => {
+    const h = makeHarness()
+    handleSessionEvent(h.deps, enqueue('801'))
+    for (let i = 0; i < 40; i++) handleSessionEvent(h.deps, enqueue(String(900 + i)))
+    expect(__parkedTurnStartCountForTest()).toBe(16)
+    // The newest message — the one the user is actually waiting on — survived.
+    h.current()!.endedAt = Date.now()
+    handleSessionEvent(h.deps, { kind: 'dequeue' })
+    expect(h.current()!.sourceMessageId).toBe(939)
+  })
+})
+
+describe('#3927 — session-tail projects the `remove` queue operation', () => {
+  it('projects op=remove as queue_remove carrying the enqueue content verbatim', () => {
+    const content = inbound('901', 'queued while busy')
+    const evs = projectTranscriptLine(
+      JSON.stringify({ type: 'queue-operation', operation: 'remove', content }),
+    )
+    expect(evs).toEqual([{ kind: 'queue_remove', rawContent: content }])
+  })
+
+  it('still projects enqueue and dequeue unchanged', () => {
+    const content = inbound('902', 'hello')
+    expect(projectTranscriptLine(
+      JSON.stringify({ type: 'queue-operation', operation: 'enqueue', content }),
+    )).toEqual([{ kind: 'enqueue', chatId: CHAT, messageId: '902', threadId: null, rawContent: content }])
+    expect(projectTranscriptLine(
+      JSON.stringify({ type: 'queue-operation', operation: 'dequeue' }),
+    )).toEqual([{ kind: 'dequeue' }])
+  })
+})

package/telegram-plugin/tests/turn-mint-harness.ts

@@ -0,0 +1,155 @@
+/**
+ * Shared harness for the #3927 turn-mint tests (FIX A / FIX B). NOT a test file
+ * — it drives the REAL `handleSessionEvent` against fake gateway closures, the
+ * extracted-module golden-harness oracle used by `stream-render-golden.test.ts`.
+ */
+import { tmpdir } from 'node:os'
+import type { CurrentTurn, StreamRenderDeps } from '../gateway/gateway.js'
+
+export const CHAT = '1001'
+
+/** `<channel …>` envelope shaped like the real inbound wrapper the CLI queues. */
+export function inbound(messageId: string, text: string): string {
+  return (
+    `<channel source="switchroom-telegram" chat_id="${CHAT}" ` +
+    `message_id="${messageId}" user="tester">${text}</channel>`
+  )
+}
+
+export interface Harness {
+  deps: StreamRenderDeps
+  /** Every card the early-liveness open posted, in order (one per minted turn). */
+  cardsOpened: Array<{ turnId: string; sourceMessageId: number | null }>
+  /** Turns handed to `clearActivitySummary`, in order (FIX B's observable). */
+  finalized: CurrentTurn[]
+  /** `drainActivitySummary` calls: which turn's feed was drained, and its text. */
+  drains: Array<{ turnId: string; render: string | null }>
+  /** Ordered trace of surface effects: `finalize:<turnId>` / `open:<turnId>`. */
+  seq: string[]
+  current: () => CurrentTurn | null
+}
+
+export function makeHarness(): Harness {
+  let curTurn: CurrentTurn | null = null
+  const cardsOpened: Harness['cardsOpened'] = []
+  const finalized: CurrentTurn[] = []
+  const drains: Harness['drains'] = []
+  const seq: string[] = []
+  const noop = () => {}
+  const key = (c: string, t?: number | null) => `${c}:${t ?? 'main'}`
+
+  const deps = {
+    // config
+    ANSWER_LANE: { visibleEnabled: false },
+    CAPTURED_PROSE_DELIVERY_ENABLED: false,
+    CONTEXT_EXHAUSTION_COOLDOWN_MS: 600000,
+    DELIVERY_CONFIRM_ENABLED: false,
+    FEED_REOPEN_AFTER_ACK_ENABLED: false,
+    HANDBACK_PRETURN_ENABLED: false,
+    HISTORY_ENABLED: false,
+    LIVENESS_TERMINAL_HONESTY: true,
+    OBLIGATION_LEDGER_ENABLED: false,
+    ORPHANED_REPLY_STREAM_WINDOW_MS: 120000,
+    SILENCE_LIVENESS_PRODUCTION: false,
+    STATE_DIR: tmpdir(),
+    TURN_FLUSH_SAFETY_ENABLED: true,
+    TURN_PREVIEW_MAX: 200,
+    // state
+    activeDraftStreams: new Map(),
+    activeStatusReactions: new Map(),
+    activeTurnStartedAt: new Map(),
+    backstopDeliveryLedger: { has: () => false, record: noop },
+    bot: { api: {} },
+    deliveryQueue: {},
+    flushedTurnSupersede: { record: noop },
+    handbackPreturnSignal: { tryAdopt: () => null },
+    idleTracker: { noteEvent: noop },
+    lastPtyPreviewByChat: new Map(),
+    obligationLedger: { close: noop, noteTurnEnded: noop },
+    outboundDedup: { check: () => null, record: noop },
+    pendingCrossTurnGate: new Map(),
+    preambleSuppressor: { dropNow: noop, flushNow: noop, onText: noop, onTool: noop, reset: noop },
+    progressDriver: null,
+    reactionTransitionCounts: new Map(),
+    sessionModelSource: { noteTranscriptModel: noop },
+    suppressPtyPreview: new Set(),
+    toolFlightTracker: { inFlightCount: () => 0 },
+    typingWrapper: { drainAll: noop, onToolResult: noop, onToolUse: noop },
+    robustApiCall: (fn: () => Promise<unknown>) => fn(),
+    swallowingApiCall: async (fn: () => Promise<unknown>) => { try { return await fn() } catch { return undefined } },
+    // accessors
+    getCurrentTurn: () => curTurn,
+    setCurrentTurn: (t: CurrentTurn) => { curTurn = t },
+    getLastContextExhaustionWarningAt: () => 0,
+    setLastContextExhaustionWarningAt: noop,
+    getPendingPtyPartial: () => null,
+    setPendingPtyPartial: noop,
+    // closures we observe
+    clearActivitySummary: (t: CurrentTurn) => { finalized.push(t); seq.push(`finalize:${t.turnId}`) },
+    scheduleEarlyLivenessOpen: (t: CurrentTurn) => {
+      // Models the real early-open: ONE card per minted turn. Pre-fix this ran
+      // for every enqueue, which is exactly how the duplicate card appeared.
+      cardsOpened.push({ turnId: t.turnId, sourceMessageId: t.sourceMessageId })
+      seq.push(`open:${t.turnId}`)
+    },
+    drainActivitySummary: (t: CurrentTurn) => {
+      drains.push({ turnId: t.turnId, render: t.activityPendingRender })
+      return Promise.resolve()
+    },
+    // rest of the closure surface
+    cardDrainGate: (_t: unknown, _ea: unknown, run: () => void) => run(),
+    clearAnswerReadyFlushTimeout: noop,
+    closeActivityLane: noop,
+    closeProgressLane: noop,
+    completeProgressCardTurn: null,
+    composeTurnActivity: () => null,
+    confirmMemoryLegibility: noop,
+    deliverAnswer: async () => ({ sentIds: [], chunkCount: 0, delivered: false, exhausted: false }),
+    deliverCapturedProse: async () => {},
+    emissionAuthorityFor: () => ({
+      mayDrain: () => true,
+      openOrEditCard: (_p: string, run: () => void) => run(),
+      claimOrDowngradePing: (_i: unknown, _s: unknown, _a: unknown, disabled: () => void) => disabled(),
+      markSubstantiveFinalDelivered: (fn: () => void) => fn(),
+      finalizeCard: (fn: () => void) => fn(),
+    }),
+    emitTurnRecord: noop,
+    endCurrentTurnAtomic: () => null,
+    extractUserPromptPreview: () => null,
+    finalizeStatusReaction: noop,
+    flushPendingNarrativeAtTurnEnd: noop,
+    getPinnedProgressCardMessageId: null,
+    handlePtyPartial: noop,
+    isDmChatId: () => true,
+    isLegitimatelyWorking: () => false,
+    makeNarrativeGate: () => ({ show: noop, stage: noop, resolveOnTool: noop, flushAtTurnEnd: noop, teardown: noop }),
+    promoteQueuedStatus: noop,
+    purgeReactionTracking: noop,
+    redactOutboundText: (t: string) => t,
+    rememberRecentTurn: noop,
+    resetAnswerReadyFlushTimeout: noop,
+    resetOrphanedReplyTimeout: noop,
+    resolvePendingNarrativeOnTool: noop,
+    stagePendingNarrative: noop,
+    startTurnTypingLoop: noop,
+    statusKey: key,
+    streamKey: key,
+    surfaceMemoryLegibility: noop,
+    turnLiveForItsTopic: () => true,
+    turnsDb: null,
+    unpinProgressCardForChat: null,
+  } as unknown as StreamRenderDeps
+
+  return { deps, cardsOpened, finalized, drains, seq, current: () => curTurn }
+}
+
+export function enqueue(messageId: string | null, text = 'hi', threadId: string | null = null) {
+  return {
+    kind: 'enqueue' as const,
+    chatId: CHAT,
+    messageId,
+    threadId,
+    rawContent: messageId == null ? text : inbound(messageId, text),
+  }
+}
+

package/telegram-plugin/tests/turn-supersede-finalizes-prior-card.test.ts

@@ -0,0 +1,124 @@
+/**
+ * #3927 FIX B — a superseded turn must never be left holding an orphaned card.
+ *
+ * The turn-supersession teardown in `stream-render.ts` tore down the prior
+ * turn's `answerStream`, its orphaned-reply fuse and its `narrativeGate`, but
+ * NEVER called `clearActivitySummary(prior)`. So a clobbered turn's activity
+ * card was never finalized, never unpinned (`fg:<statusKey>` stayed claimed
+ * forever), froze on its last landed edit, and left NO `turn-lifecycle clear`
+ * line to explain it. Proof from the field: carrie's turn
+ * `-1004223464247:_#1078` has a `turn-lifecycle set reason=enqueue` at
+ * 2026-07-28T18:13:37.554Z and no `clear` anywhere in the log; its stale pinned
+ * card was still on screen in the operator's screenshot.
+ *
+ * ── Which path still supersedes, after FIX A ──────────────────────────────
+ * FIX A parks EVERY mid-turn enqueue, synthetic ones included — that is not a
+ * policy choice, it is what the claude CLI does (carrie's `obligation_represent`
+ * enqueue at 18:19:07.032Z was terminated by a `remove` at 18:19:59.794Z, i.e.
+ * folded into the running turn as a `queued_command` attachment, never by a
+ * `dequeue`). So an enqueue no longer preempts, and the case below asserts that
+ * explicitly.
+ *
+ * Supersession is still REACHABLE, though: a turn whose `turn_end` the gateway
+ * never observed (bridge death, transcript gap, unclean restart) leaves a
+ * live-looking atom in the slot, and the next genuine dequeue-driven turn start
+ * mints straight on top of it. That is the exact orphan carrie hit, and it is
+ * what FIX B finalizes.
+ */
+import { describe, it, expect, beforeEach } from 'vitest'
+import {
+  handleSessionEvent,
+  __resetParkedTurnStartsForTest,
+  __parkedTurnStartCountForTest,
+} from '../gateway/stream-render.js'
+import { enqueue, makeHarness } from './turn-mint-harness.js'
+
+/** A cron / handback / wake enqueue: no `message_id`, so `deriveTurnId` falls
+ *  back to `…#synthetic-<startedAt>`. */
+function syntheticEnqueue(chatId: string, text: string) {
+  return {
+    kind: 'enqueue' as const,
+    chatId,
+    messageId: null,
+    threadId: null,
+    rawContent: `<channel source="switchroom-telegram" source="cron">${text}</channel>`,
+  }
+}
+
+beforeEach(() => {
+  __resetParkedTurnStartsForTest()
+})
+
+describe('#3927 FIX B — superseding a live turn finalizes its card', () => {
+  it('a dequeue-driven mint on top of a never-ended turn calls clearActivitySummary ' +
+    'for the PRIOR turn, and does so BEFORE the successor opens its card', () => {
+    const h = makeHarness()
+
+    // Turn A starts and opens a card with real work on it.
+    handleSessionEvent(h.deps, enqueue('1078'))
+    const turnA = h.current()!
+    handleSessionEvent(h.deps, { kind: 'tool_label', toolName: 'Read', label: 'Reading the log' })
+    expect(turnA.labeledToolCount).toBe(1)
+    expect(h.finalized).toHaveLength(0)
+
+    // A's `turn_end` is NEVER observed — `endedAt` stays null and the atom
+    // stays in the slot (exactly carrie's `#1078`).
+    expect(turnA.endedAt).toBeNull()
+
+    // A later message is queued and the CLI drains it into a new turn.
+    handleSessionEvent(h.deps, enqueue('1086'))
+    expect(__parkedTurnStartCountForTest()).toBe(1)
+    handleSessionEvent(h.deps, { kind: 'dequeue' })
+
+    const turnB = h.current()!
+    expect(turnB).not.toBe(turnA)
+
+    // FIX B: the orphan was finalized — pre-fix there was NO call at all.
+    expect(h.finalized).toHaveLength(1)
+    expect(h.finalized[0]).toBe(turnA)
+
+    // …and it happened BEFORE the successor's card opened, so the old card is
+    // finalized/unpinned rather than left frozen above a fresh one.
+    expect(h.seq).toEqual([
+      `open:${turnA.turnId}`,
+      `finalize:${turnA.turnId}`,
+      `open:${turnB.turnId}`,
+    ])
+  })
+
+  it('a turn that ENDED normally is not re-finalized when its successor mints', () => {
+    const h = makeHarness()
+    handleSessionEvent(h.deps, enqueue('1090'))
+    const turnA = h.current()!
+    // turn-end.ts stamps `endedAt` and runs its own clearActivitySummary.
+    turnA.endedAt = Date.now()
+
+    handleSessionEvent(h.deps, enqueue('1091'))
+    // Idle by `endedAt`, so this mints straight away — and must NOT double-
+    // finalize A's already-closed card.
+    expect(h.current()).not.toBe(turnA)
+    expect(h.finalized).toHaveLength(0)
+  })
+
+  it('FIX A is uniform across sources: a SYNTHETIC (cron/handback) enqueue parks ' +
+    'behind a live turn instead of preempting it', () => {
+    const h = makeHarness()
+    handleSessionEvent(h.deps, enqueue('1100'))
+    const turnA = h.current()!
+
+    handleSessionEvent(h.deps, syntheticEnqueue('1001', 'time for the daily digest'))
+
+    // No preemption: no new card, no slot steal, no orphaned finalize.
+    expect(h.current()).toBe(turnA)
+    expect(h.cardsOpened).toHaveLength(1)
+    expect(h.finalized).toHaveLength(0)
+    expect(__parkedTurnStartCountForTest()).toBe(1)
+
+    // It mints on the CLI's own turn-start signal, like every other source.
+    turnA.endedAt = Date.now()
+    handleSessionEvent(h.deps, { kind: 'dequeue' })
+    expect(h.current()).not.toBe(turnA)
+    expect(h.current()!.turnId).toContain('#synthetic-')
+    expect(h.cardsOpened).toHaveLength(2)
+  })
+})