switchroom 0.7.15 → 0.10.0

package/telegram-plugin/tests/turn-flush-card-takeover.test.ts

@@ -1,218 +0,0 @@
-/**
- * #654 regression tests — deterministic double-message fix via card
- * takeover.
- *
- * Bug: when an agent's turn took longer than `initialDelayMs` (60s) AND
- * the agent emitted assistant text without calling `reply` /
- * `stream_reply` (turn-flush path), the user saw TWO outbound Telegram
- * messages — the pinned progress card AND the turn-flush bubble — for
- * one logical reply.
- *
- * Root cause: the gateway's turn-flush path issued a fresh
- * `bot.api.sendMessage` even when a progress card was already on screen
- * for that turn. The driver's `forceCompleteTurn` couldn't help because
- * once the deferred-emit timer had fired, no path existed to retract
- * the posted card — `flush()` would only edit it to "Done".
- *
- * Fix: add a `takeOverCard` method to the driver that:
- *   - cancels the pending deferred-emit timer if not yet fired
- *   - sets `cardTakenOver = true` so subsequent `flush()` calls
- *     short-circuit (no further "Done" edit)
- *   - returns `{ wasEmitted, turnKey }` so the caller (turn-flush)
- *     can look up the pinned messageId and rewrite it in place via
- *     `editMessageText` instead of creating a second message.
- *
- * The harness gap that hid the bug: no existing test wired a real
- * driver into a long-turn scenario. `turn-flush-safety.test.ts`
- * covered `decideTurnFlush()` only; `real-gateway-i6` covered turn-
- * flush replay/dedup but never modeled a card already on screen.
- *
- * These tests pin the driver-level contract. The gateway integration
- * is exercised in the bridged scenario at the bottom of this file.
- */
-
-import { describe, it, expect } from 'vitest'
-import { createProgressDriver } from '../progress-card-driver.js'
-import type { SessionEvent } from '../session-tail.js'
-
-function harness(opts?: { initialDelayMs?: number }) {
-  let now = 1000
-  const timers: Array<{ fireAt: number; fn: () => void; ref: number; repeat?: number }> = []
-  let nextRef = 0
-  const emits: Array<{
-    chatId: string
-    threadId?: string
-    turnKey: string
-    html: string
-    done: boolean
-    isFirstEmit: boolean
-  }> = []
-
-  const driver = createProgressDriver({
-    emit: (a) => emits.push(a),
-    minIntervalMs: 0,
-    coalesceMs: 0,
-    initialDelayMs: opts?.initialDelayMs ?? 60_000,
-    promoteAfterMs: 999_999,
-    now: () => now,
-    setTimeout: (fn, ms) => {
-      const ref = nextRef++
-      timers.push({ fireAt: now + ms, fn, ref })
-      return { ref }
-    },
-    clearTimeout: (handle) => {
-      const target = (handle as { ref: number }).ref
-      const idx = timers.findIndex((t) => t.ref === target)
-      if (idx !== -1) timers.splice(idx, 1)
-    },
-    setInterval: (fn, ms) => {
-      const ref = nextRef++
-      timers.push({ fireAt: now + ms, fn, ref, repeat: ms })
-      return { ref }
-    },
-    clearInterval: (handle) => {
-      const target = (handle as { ref: number }).ref
-      const idx = timers.findIndex((t) => t.ref === target)
-      if (idx !== -1) timers.splice(idx, 1)
-    },
-  })
-
-  const advance = (ms: number): void => {
-    now += ms
-    for (;;) {
-      timers.sort((a, b) => a.fireAt - b.fireAt)
-      const next = timers[0]
-      if (!next || next.fireAt > now) break
-      if (next.repeat != null) {
-        next.fireAt += next.repeat
-        next.fn()
-      } else {
-        timers.shift()
-        next.fn()
-      }
-    }
-  }
-
-  return { driver, emits, advance }
-}
-
-let nextMsgId = 1
-function enqueue(chatId: string, text = 'q', threadId: string | null = null): SessionEvent {
-  return {
-    kind: 'enqueue',
-    chatId,
-    messageId: String(nextMsgId++),
-    threadId,
-    rawContent: `<channel chat_id="${chatId}">${text}</channel>`,
-  } as unknown as SessionEvent
-}
-
-describe('takeOverCard — #654 regression', () => {
-  it('returns wasEmitted=false when card has not yet emitted (pre-60s turn)', () => {
-    // Fast-turn case: turn-flush fires before the deferred-emit timer.
-    // Driver suppresses the card; turn-flush sends fresh.
-    const { driver } = harness({ initialDelayMs: 60_000 })
-    driver.ingest(enqueue('c1'), 'c1')
-    // Don't advance — timer still pending.
-
-    const result = driver.takeOverCard({ chatId: 'c1' })
-    expect(result.wasEmitted).toBe(false)
-    expect(result.turnKey).not.toBeNull()
-    expect(typeof result.turnKey).toBe('string')
-  })
-
-  it('returns wasEmitted=true when deferred-emit timer has fired (the #654 path)', () => {
-    // Slow-turn case: the card has been emitted to the chat. takeOverCard
-    // signals that the caller should edit-in-place rather than send fresh.
-    const { driver, emits, advance } = harness({ initialDelayMs: 60_000 })
-    driver.ingest(
-      enqueue('c1'),
-      'c1',
-    )
-    advance(60_000)
-    expect(emits.length).toBeGreaterThan(0) // card emitted
-
-    const result = driver.takeOverCard({ chatId: 'c1' })
-    expect(result.wasEmitted).toBe(true)
-    expect(typeof result.turnKey).toBe('string')
-    expect(result.turnKey).toContain('c1')
-  })
-
-  it('cancels the pending deferred-emit timer (no late card emission)', () => {
-    // After takeOverCard cancels the timer, advancing past the original
-    // delay must NOT produce a card emit.
-    const { driver, emits, advance } = harness({ initialDelayMs: 60_000 })
-    driver.ingest(
-      enqueue('c1'),
-      'c1',
-    )
-    expect(emits.length).toBe(0) // suppressed by initial delay
-
-    driver.takeOverCard({ chatId: 'c1' })
-    advance(120_000) // way past 60s
-
-    expect(emits.length).toBe(0) // timer was cancelled — no late emit
-  })
-
-  it('blocks subsequent flushes — driver.ingest(turn_end) does NOT emit a "Done" edit', () => {
-    // The bug case: after card is on screen, gateway calls takeOverCard,
-    // then session-tail dispatches turn_end which the driver ingests.
-    // Without the cardTakenOver guard, turn_end would call flush(forceDone)
-    // → editMessageText("Done") — wasted edit. With the guard, no emit.
-    const { driver, emits, advance } = harness({ initialDelayMs: 60_000 })
-    driver.ingest(
-      enqueue('c1'),
-      'c1',
-    )
-    advance(60_000)
-    const emitsAfterCard = emits.length
-    expect(emitsAfterCard).toBeGreaterThan(0)
-
-    driver.takeOverCard({ chatId: 'c1' })
-
-    // Now simulate the driver receiving turn_end (as session-tail would
-    // dispatch synchronously upstream of the gateway's turn-flush block).
-    driver.ingest(
-      { kind: 'turn_end', durationMs: 70_000 } as unknown as SessionEvent,
-      'c1',
-    )
-    expect(emits.length).toBe(emitsAfterCard) // no additional edits
-  })
-
-  it('idempotent — second call returns same shape, no double-cancel side-effects', () => {
-    const { driver, emits, advance } = harness({ initialDelayMs: 60_000 })
-    driver.ingest(
-      enqueue('c1'),
-      'c1',
-    )
-    advance(60_000)
-    const emitsAfter1 = emits.length
-
-    const r1 = driver.takeOverCard({ chatId: 'c1' })
-    const r2 = driver.takeOverCard({ chatId: 'c1' })
-    expect(r1).toEqual(r2)
-    expect(emits.length).toBe(emitsAfter1)
-  })
-
-  it('returns null turnKey when no active card exists for (chatId, threadId)', () => {
-    const { driver } = harness({ initialDelayMs: 60_000 })
-    const result = driver.takeOverCard({ chatId: 'never-enqueued' })
-    expect(result).toEqual({ wasEmitted: false, turnKey: null })
-  })
-
-  it('routes by chatId+threadId — separate chats do not clobber each other', () => {
-    const { driver } = harness({ initialDelayMs: 60_000 })
-    driver.ingest(enqueue('c1'), 'c1')
-    driver.ingest(enqueue('c2'), 'c2')
-
-    // Take over c1 — c2's card must remain untouched.
-    const r1 = driver.takeOverCard({ chatId: 'c1' })
-    expect(r1.turnKey).toContain('c1')
-    expect(r1.turnKey).not.toContain('c2')
-
-    // c2 still has its own active card, distinct turnKey.
-    const r2 = driver.takeOverCard({ chatId: 'c2' })
-    expect(r2.turnKey).toContain('c2')
-    expect(r2.turnKey).not.toContain('c1')
-  })
-})

package/telegram-plugin/tests/turn-flush-prose-recovery.test.ts

@@ -1,78 +0,0 @@
-/**
- * Tests for the prose-recovery helper used by the turn-flush backstop
- * to bridge the divergence between the gateway's `capturedText`
- * accumulator and the progress-card driver's narrative state. See #51.
- */
-
-import { describe, it, expect } from 'vitest'
-import type { ProgressCardState, NarrativeStep } from '../progress-card.js'
-import { recoverProseFromProgressCard } from '../turn-flush-prose-recovery.js'
-
-function narrative(id: number, text: string): NarrativeStep {
-  return { id, text, state: 'done', startedAt: 0, toolCount: 0 }
-}
-
-function stateWith(narratives: NarrativeStep[]): ProgressCardState {
-  return {
-    turnStartedAt: 0,
-    items: [],
-    stage: 'idle',
-    thinking: false,
-    narratives,
-    subAgents: new Map(),
-    pendingAgentSpawns: new Map(),
-  } as unknown as ProgressCardState
-}
-
-describe('recoverProseFromProgressCard', () => {
-  it('returns empty string for undefined state', () => {
-    expect(recoverProseFromProgressCard(undefined)).toBe('')
-  })
-
-  it('returns empty string when there are no narratives', () => {
-    expect(recoverProseFromProgressCard(stateWith([]))).toBe('')
-  })
-
-  it('returns empty string when the narratives field is missing', () => {
-    // Defensive: partial state (e.g. older persisted shape) must not throw.
-    const partial = { turnStartedAt: 0, items: [], stage: 'idle', thinking: false } as unknown as ProgressCardState
-    expect(recoverProseFromProgressCard(partial)).toBe('')
-  })
-
-  it('joins narrative text in order, newline-separated', () => {
-    const state = stateWith([
-      narrative(1, 'Reading the file.'),
-      narrative(2, 'Found the issue.'),
-      narrative(3, 'Patching gateway.ts.'),
-    ])
-    expect(recoverProseFromProgressCard(state)).toBe(
-      'Reading the file.\nFound the issue.\nPatching gateway.ts.',
-    )
-  })
-
-  it('skips empty-string narratives but preserves order of the rest', () => {
-    const state = stateWith([
-      narrative(1, 'first'),
-      narrative(2, ''),
-      narrative(3, 'third'),
-    ])
-    expect(recoverProseFromProgressCard(state)).toBe('first\nthird')
-  })
-
-  it('trims surrounding whitespace from the joined result', () => {
-    const state = stateWith([narrative(1, '   prose with edges   ')])
-    expect(recoverProseFromProgressCard(state)).toBe('prose with edges')
-  })
-
-  it('recovers the original incident — single narrative line that should have flushed', () => {
-    // Mirrors the #45/#51 incident transcript: the assistant emitted
-    // prose-as-step but never called reply. Recovery must surface that
-    // text so the flush backstop can send it.
-    const state = stateWith([
-      narrative(1, 'Just the caption swap — the Klanker body stays.'),
-    ])
-    expect(recoverProseFromProgressCard(state)).toBe(
-      'Just the caption swap — the Klanker body stays.',
-    )
-  })
-})

package/telegram-plugin/tests/two-zone-bg-carry-full-lifecycle.test.ts

@@ -1,131 +0,0 @@
-/**
- * PR-C2 — full lifecycle of background sub-agent carry across two
- * consecutive parent turns.
- *
- *   Turn A: enqueue → spawn bg sub-agent → parent reply + turn_end
- *           (parent done, bg still running → phase=Background on A's card).
- *   Turn B: enqueue (carries the still-running bg member into B's fleet).
- *           B's phase starts as Working (parent active again).
- *   Background sub-agent emits during B → still Working.
- *   Background sub-agent reaches sub_agent_turn_end during B → fleet
- *           now empty of running members; B's phase resolves cleanly.
- *
- * fails when: a refactor drops the originatingTurnKey routing of a bg
- * sub-agent's events back to its origin chat, OR when the bg member
- * isn't carried into turn B's fleet on enqueue.
- */
-import { describe, it, expect } from 'vitest'
-import { phaseFor } from '../two-zone-card.js'
-import { makeHarness, enqueue } from './_progress-card-harness.js'
-
-describe('PR-C2: two-zone bg-carry full lifecycle (turn A → turn B → bg done)', () => {
-  it('phase transitions A=Background, B=Working, B-after-bg-done=Done', () => {
-    const { driver, advance, getNow, completions } = makeHarness({
-      minIntervalMs: 500,
-      coalesceMs: 400,
-      promoteAfterMs: 999_999,
-    })
-    const CHAT = 'cA'
-
-    // ── Turn A: spawn bg sub-agent, parent replies, turn_end. ──────────
-    driver.ingest(enqueue(CHAT), null)
-    driver.ingest(
-      {
-        kind: 'tool_use',
-        toolName: 'Agent',
-        toolUseId: 'tu1',
-        input: { prompt: 'bg work', run_in_background: true },
-      },
-      CHAT,
-    )
-    driver.ingest({ kind: 'sub_agent_started', agentId: 'saBG', firstPromptText: 'bg work' }, CHAT)
-    driver.ingest({ kind: 'tool_use', toolName: 'mcp__switchroom-telegram__reply' }, CHAT)
-    driver.recordOutboundDelivered(CHAT)
-    driver.ingest({ kind: 'turn_end', durationMs: 500 }, CHAT)
-
-    // After parent turn_end, the originating chatState is held in
-    // pendingCompletion because saBG is still running.
-    const fleetAfterA = driver.peekFleet(CHAT)!
-    expect(fleetAfterA.has('saBG')).toBe(true)
-    expect(fleetAfterA.get('saBG')!.status).toBe('background')
-
-    // Phase resolution for A: parentDone=true + bg running → Background.
-    {
-      const all = (driver as unknown as {
-        peekAllFleets?: () => Array<{ turnKey: string; fleet: Map<string, unknown>; state?: unknown }>
-      }).peekAllFleets?.() ?? []
-      // Find turn A — it's the one whose fleet contains saBG and whose
-      // turnKey ends in :1.
-      const a = all.find((e) => e.turnKey.endsWith(':1'))
-      expect(a).toBeDefined()
-    }
-    // Capture A's turnKey for the deferred-completion assertion below.
-    const turnKeyA = (driver as unknown as {
-      peekAllFleets?: () => Array<{ turnKey: string; fleet: Map<string, unknown> }>
-    }).peekAllFleets!().find((e) => e.fleet.has('saBG'))!.turnKey
-
-    // ── Turn B: fresh enqueue. The bg member carries forward. ─────────
-    advance(50)
-    driver.ingest(enqueue(CHAT), null)
-    const fleetB = driver.peekFleet(CHAT)!
-    // Carry: saBG should still be reachable somewhere in the driver's
-    // fleets (either on B's fresh state or A's still-pending one).
-    const allFleets = (driver as unknown as {
-      peekAllFleets?: () => Array<{ turnKey: string; fleet: Map<string, { status: string }> }>
-    }).peekAllFleets?.() ?? []
-    const sawBG = allFleets.some((f) => f.fleet.has('saBG'))
-    expect(sawBG).toBe(true)
-
-    // B parent is in flight — phaseFor should resolve to Working… because
-    // parentDone=false for B regardless of bg state.
-    const phaseB = phaseFor(
-      {
-        turnStartedAt: getNow(),
-        items: [],
-        narratives: [],
-        stage: 'run',
-        thinking: false,
-        subAgents: new Map(),
-        pendingAgentSpawns: new Map(),
-        tasks: [],
-      },
-      fleetB,
-      getNow(),
-      {},
-    )
-    expect(phaseB.label).toBe('Working…')
-
-    // ── BG sub-agent emits during B (proves routing still works). ────
-    advance(20)
-    driver.ingest(
-      {
-        kind: 'sub_agent_tool_use',
-        agentId: 'saBG',
-        toolUseId: 'bgt1',
-        toolName: 'Read',
-        input: { file_path: '/tmp/x.txt' },
-      },
-      CHAT,
-    )
-
-    // ── BG sub-agent finishes during B. ──────────────────────────────
-    advance(20)
-    driver.ingest({ kind: 'sub_agent_turn_end', agentId: 'saBG' }, CHAT)
-
-    // Turn A's pendingCompletion should now resolve (saBG no longer
-    // running). Turn B's fleet should drop its bg copy too.
-    const allAfter = (driver as unknown as {
-      peekAllFleets?: () => Array<{ turnKey: string; fleet: Map<string, { status: string }> }>
-    }).peekAllFleets?.() ?? []
-    for (const entry of allAfter) {
-      const m = entry.fleet.get('saBG')
-      if (m == null) continue
-      // Whichever turn still holds saBG, it must be terminal (done/failed/killed)
-      expect(['done', 'failed', 'killed']).toContain(m.status)
-    }
-    // Critical: A's deferred completion MUST have fired now that saBG
-    // reached sub_agent_turn_end. Without this assertion the loop above
-    // trivially passes when allAfter is empty.
-    expect(completions).toContain(turnKeyA)
-  })
-})

package/telegram-plugin/tests/two-zone-bg-detection.test.ts

@@ -1,120 +0,0 @@
-/**
- * P2 of #662 — runInBackground detection.
- *
- * When the parent dispatches an Agent/Task tool with
- * `input.run_in_background: true`, the resulting fleet member must be
- * marked with `status: 'background'` instead of `running`. Foreground
- * dispatches (no flag, or false) stay `running`.
- */
-
-import { describe, it, expect } from 'vitest'
-import { createProgressDriver } from '../progress-card-driver.js'
-import type { SessionEvent } from '../session-tail.js'
-
-function harness() {
-  let now = 1000
-  const timers: Array<{ fireAt: number; fn: () => void; ref: number; repeat?: number }> = []
-  let nextRef = 0
-  const driver = createProgressDriver({
-    emit: () => {},
-    minIntervalMs: 500,
-    coalesceMs: 400,
-    initialDelayMs: 0,
-    promoteAfterMs: 999_999,
-    now: () => now,
-    setTimeout: (fn, ms) => {
-      const ref = nextRef++
-      timers.push({ fireAt: now + ms, fn, ref })
-      return { ref }
-    },
-    clearTimeout: (h) => {
-      const ref = (h as { ref: number }).ref
-      const idx = timers.findIndex((t) => t.ref === ref)
-      if (idx !== -1) timers.splice(idx, 1)
-    },
-    setInterval: (fn, ms) => {
-      const ref = nextRef++
-      timers.push({ fireAt: now + ms, fn, ref, repeat: ms })
-      return { ref }
-    },
-    clearInterval: (h) => {
-      const ref = (h as { ref: number }).ref
-      const idx = timers.findIndex((t) => t.ref === ref)
-      if (idx !== -1) timers.splice(idx, 1)
-    },
-  })
-  return { driver, advance: (ms: number) => { now += ms } }
-}
-
-const enqueue = (chatId: string): SessionEvent => ({
-  kind: 'enqueue',
-  chatId,
-  messageId: '1',
-  threadId: null,
-  rawContent: `<channel chat_id="${chatId}">go</channel>`,
-})
-
-describe('P2: runInBackground detection', () => {
-  it('marks fleet member status=background when Agent dispatched with run_in_background:true', () => {
-    const { driver } = harness()
-    driver.ingest(enqueue('c1'), null)
-    // Parent fires Agent tool_use with run_in_background=true.
-    driver.ingest(
-      {
-        kind: 'tool_use',
-        toolName: 'Agent',
-        toolUseId: 'tu1',
-        input: { prompt: 'do bg work', description: 'bg-job', run_in_background: true },
-      },
-      'c1',
-    )
-    // sub_agent_started arrives with matching prompt.
-    driver.ingest(
-      { kind: 'sub_agent_started', agentId: 'sa1', firstPromptText: 'do bg work', subagentType: 'worker' },
-      'c1',
-    )
-
-    const m = driver.peekFleet('c1')!.get('sa1')!
-    expect(m.status).toBe('background')
-  })
-
-  it('keeps status=running when Agent dispatched without run_in_background', () => {
-    const { driver } = harness()
-    driver.ingest(enqueue('c2'), null)
-    driver.ingest(
-      {
-        kind: 'tool_use',
-        toolName: 'Agent',
-        toolUseId: 'tu2',
-        input: { prompt: 'do fg work', description: 'fg-job' },
-      },
-      'c2',
-    )
-    driver.ingest(
-      { kind: 'sub_agent_started', agentId: 'sa2', firstPromptText: 'do fg work' },
-      'c2',
-    )
-    const m = driver.peekFleet('c2')!.get('sa2')!
-    expect(m.status).toBe('running')
-  })
-
-  it('keeps status=running when run_in_background is explicitly false', () => {
-    const { driver } = harness()
-    driver.ingest(enqueue('c3'), null)
-    driver.ingest(
-      {
-        kind: 'tool_use',
-        toolName: 'Agent',
-        toolUseId: 'tu3',
-        input: { prompt: 'p', run_in_background: false },
-      },
-      'c3',
-    )
-    driver.ingest(
-      { kind: 'sub_agent_started', agentId: 'sa3', firstPromptText: 'p' },
-      'c3',
-    )
-    const m = driver.peekFleet('c3')!.get('sa3')!
-    expect(m.status).toBe('running')
-  })
-})

package/telegram-plugin/tests/two-zone-bg-done-when-all-terminal.test.ts

@@ -1,116 +0,0 @@
-/**
- * P2 of #662 — completion gate: a turn with both foreground (done) and
- * background (still running) sub-agents must NOT fire onTurnComplete
- * until the background member also reaches a terminal state. This is
- * the "✅ Done only when everything is actually done" invariant; the
- * v2 renderer uses the same predicate to choose between the
- * ⏸ Background and ✅ Done header phases.
- */
-
-import { describe, it, expect } from 'vitest'
-import { createProgressDriver } from '../progress-card-driver.js'
-import { hasLiveBackground } from '../fleet-state.js'
-import type { SessionEvent } from '../session-tail.js'
-
-function harness() {
-  let now = 1000
-  const timers: Array<{ fireAt: number; fn: () => void; ref: number; repeat?: number }> = []
-  let nextRef = 0
-  const completions: string[] = []
-  const driver = createProgressDriver({
-    emit: () => {},
-    minIntervalMs: 500,
-    coalesceMs: 400,
-    initialDelayMs: 0,
-    promoteAfterMs: 999_999,
-    onTurnComplete: (s) => completions.push(s.turnKey),
-    now: () => now,
-    setTimeout: (fn, ms) => {
-      const ref = nextRef++
-      timers.push({ fireAt: now + ms, fn, ref })
-      return { ref }
-    },
-    clearTimeout: (h) => {
-      const ref = (h as { ref: number }).ref
-      const idx = timers.findIndex((t) => t.ref === ref)
-      if (idx !== -1) timers.splice(idx, 1)
-    },
-    setInterval: (fn, ms) => {
-      const ref = nextRef++
-      timers.push({ fireAt: now + ms, fn, ref, repeat: ms })
-      return { ref }
-    },
-    clearInterval: (h) => {
-      const ref = (h as { ref: number }).ref
-      const idx = timers.findIndex((t) => t.ref === ref)
-      if (idx !== -1) timers.splice(idx, 1)
-    },
-  })
-  return { driver, completions, advance: (ms: number) => { now += ms } }
-}
-
-const enqueue = (chatId: string): SessionEvent => ({
-  kind: 'enqueue',
-  chatId,
-  messageId: '1',
-  threadId: null,
-  rawContent: `<channel chat_id="${chatId}">go</channel>`,
-})
-
-describe('P2: completion gates on background fleet members', () => {
-  it('hasLiveBackground reflects fleet status correctly', () => {
-    // isBackgroundDispatch is the sticky flag used by hasLiveBackground —
-    // status alone is no longer the gate (fixes #757).
-    const fleet = new Map([
-      ['a', { agentId: 'a', status: 'background' as const, terminalAt: null, isBackgroundDispatch: true } as never],
-      ['b', { agentId: 'b', status: 'done' as const, terminalAt: 2000, isBackgroundDispatch: false } as never],
-    ])
-    expect(hasLiveBackground(fleet as never)).toBe(true)
-    fleet.set('a', { agentId: 'a', status: 'done' as const, terminalAt: 3000, isBackgroundDispatch: true } as never)
-    expect(hasLiveBackground(fleet as never)).toBe(false)
-  })
-
-  it('foreground sub completes + background still running → no turn completion', () => {
-    const { driver, completions } = harness()
-    const CHAT = 'c1'
-    driver.ingest(enqueue(CHAT), null)
-    // Foreground Agent dispatch.
-    driver.ingest(
-      {
-        kind: 'tool_use',
-        toolName: 'Agent',
-        toolUseId: 'tuFg',
-        input: { prompt: 'fg', description: 'fg-job' },
-      },
-      CHAT,
-    )
-    driver.ingest({ kind: 'sub_agent_started', agentId: 'saFG', firstPromptText: 'fg' }, CHAT)
-    // Background Agent dispatch.
-    driver.ingest(
-      {
-        kind: 'tool_use',
-        toolName: 'Agent',
-        toolUseId: 'tuBg',
-        input: { prompt: 'bg', description: 'bg-job', run_in_background: true },
-      },
-      CHAT,
-    )
-    driver.ingest({ kind: 'sub_agent_started', agentId: 'saBG', firstPromptText: 'bg' }, CHAT)
-    driver.ingest({ kind: 'tool_use', toolName: 'mcp__switchroom-telegram__reply' }, CHAT)
-    driver.recordOutboundDelivered(CHAT)
-    // Foreground completes.
-    driver.ingest({ kind: 'sub_agent_turn_end', agentId: 'saFG' }, CHAT)
-    // Parent ends.
-    driver.ingest({ kind: 'turn_end', durationMs: 500 }, CHAT)
-
-    // Background still running → no completion fired.
-    expect(completions.length).toBe(0)
-    const fleet = driver.peekFleet(CHAT)!
-    expect(fleet.get('saFG')!.status).toBe('done')
-    expect(fleet.get('saBG')!.status).toBe('background')
-
-    // Background completes → completion fires.
-    driver.ingest({ kind: 'sub_agent_turn_end', agentId: 'saBG' }, CHAT)
-    expect(completions.length).toBe(1)
-  })
-})