switchroom 0.7.15 → 0.10.0

package/telegram-plugin/tests/two-zone-card-lifecycle.test.ts

@@ -1,128 +0,0 @@
-/**
- * P1 of #662 — lifecycle integration. Drive the real driver with
- * TWO_ZONE_CARD=1 set; assert the rendered HTML for a turn with 2
- * fleet members contains expected substrings (header phase, parent
- * bullets, fleet rows, fleet count).
- *
- * Uses the same lightweight harness pattern as
- * progress-card-driver-fleet-shadow.test.ts — no Telegram bot, just
- * record the emit calls and inspect their HTML payload.
- */
-
-import { describe, it, expect, beforeEach, afterEach } 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 emits: Array<{ chatId: string; payload: string }> = []
-  const driver = createProgressDriver({
-    emit: (args) => {
-      // Parent card emits only — sub-agent per-agent cards carry agentId.
-      if ((args as { agentId?: string }).agentId == null) {
-        emits.push({ chatId: args.chatId, payload: args.html })
-      }
-    },
-    minIntervalMs: 0,
-    coalesceMs: 0,
-    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,
-    emits,
-    advance: (ms: number) => {
-      now += ms
-      const due = timers.filter((t) => t.fireAt <= now)
-      for (const t of due) {
-        t.fn()
-        if (t.repeat) {
-          t.fireAt = now + t.repeat
-        } else {
-          const i = timers.indexOf(t)
-          if (i >= 0) timers.splice(i, 1)
-        }
-      }
-    },
-    flush: () => {
-      // Pump any pending timers
-      const due = timers.filter((t) => t.fireAt <= now)
-      for (const t of due) t.fn()
-    },
-  }
-}
-
-const enqueue = (chatId: string): SessionEvent => ({
-  kind: 'enqueue',
-  chatId,
-  messageId: '1',
-  threadId: null,
-  rawContent: `<channel chat_id="${chatId}">go</channel>`,
-})
-
-describe('two-zone-card lifecycle (TWO_ZONE_CARD=1)', () => {
-  let prevFlag: string | undefined
-  beforeEach(() => {
-    prevFlag = process.env.TWO_ZONE_CARD
-    process.env.TWO_ZONE_CARD = '1'
-  })
-  afterEach(() => {
-    if (prevFlag === undefined) delete process.env.TWO_ZONE_CARD
-    else process.env.TWO_ZONE_CARD = prevFlag
-  })
-
-  it('renders two-zone card with fleet rows when flag is on', () => {
-    const { driver, emits, advance } = harness()
-    const CHAT = 'c1'
-    driver.ingest(enqueue(CHAT), null)
-
-    const events: SessionEvent[] = [
-      { kind: 'tool_use', toolUseId: 'p1', toolName: 'Read', input: { file_path: '/tmp/foo.ts' } },
-      { kind: 'sub_agent_started', agentId: 'sa1', firstPromptText: 'do work', subagentType: 'worker' },
-      { kind: 'sub_agent_started', agentId: 'sa2', firstPromptText: 'review', subagentType: 'reviewer' },
-      { kind: 'sub_agent_tool_use', agentId: 'sa1', toolUseId: 't1', toolName: 'Grep', input: { pattern: 'TODO' } },
-    ]
-    for (const ev of events) driver.ingest(ev, CHAT)
-    // Drain the coalesce/min-interval setTimeout queue so deferred
-    // sub-agent emits flush. Each ingest schedules a 0-delay timer
-    // that is only invoked when fake time advances.
-    advance(0)
-
-    // Find the most recent emitted payload — it should be a two-zone card.
-    const last = emits[emits.length - 1]
-    expect(last).toBeDefined()
-    const html = last.payload
-    // Header substrings
-    expect(html).toMatch(/Working/)
-    // Fleet zone present with count
-    expect(html).toContain('FLEET (2)')
-    expect(html).toContain('worker')
-    expect(html).toContain('reviewer')
-    // Fleet ids (6 chars)
-    expect(html).toContain('sa1')
-    expect(html).toContain('sa2')
-  })
-})

package/telegram-plugin/tests/two-zone-card-sanitise.test.ts

@@ -1,58 +0,0 @@
-/**
- * P1 of #662 — renderer output never reintroduces raw absolute paths
- * or bearer-shaped tokens. Most coverage lives in fleet-state.test.ts;
- * this asserts the *renderer* basenames/redacts via the FleetMember's
- * sanitised values (i.e. it doesn't re-pull from raw input anywhere).
- */
-
-import { describe, it, expect } from 'vitest'
-import { renderTwoZoneCard } from '../two-zone-card.js'
-import type { FleetMember } from '../fleet-state.js'
-import type { ProgressCardState } from '../progress-card.js'
-
-const baseState: ProgressCardState = {
-  turnStartedAt: 1,
-  items: [],
-  narratives: [],
-  stage: 'run',
-  thinking: false,
-  subAgents: new Map(),
-  pendingAgentSpawns: new Map(),
-  tasks: [],
-}
-
-function fm(over: Partial<FleetMember>): FleetMember {
-  return {
-    agentId: 'aaaaaaaaaaaa',
-    role: 'agent',
-    startedAt: 0,
-    toolCount: 1,
-    lastActivityAt: 1000,
-    lastTool: null,
-    status: 'running',
-    terminalAt: null,
-    errorSeen: false,
-    originatingTurnKey: 'k',
-    ...over,
-  }
-}
-
-describe('two-zone-card sanitise', () => {
-  it('does not contain raw absolute path under /etc/secrets', () => {
-    const fleet = new Map([['a', fm({
-      lastTool: { name: 'Read', sanitisedArg: 'foo.key' }, // already sanitised by fleet-state
-    })]])
-    const out = renderTwoZoneCard({ state: baseState, fleet, now: 2000 })
-    expect(out).not.toContain('/etc/secrets')
-    expect(out).toContain('foo.key')
-  })
-
-  it('does not contain bearer-shaped tokens (sanitised upstream)', () => {
-    const fleet = new Map([['a', fm({
-      lastTool: { name: 'Bash', sanitisedArg: 'curl -H "Authorization: [redacted]" https://api' },
-    })]])
-    const out = renderTwoZoneCard({ state: baseState, fleet, now: 2000 })
-    expect(out).toContain('[redacted]')
-    expect(out).not.toMatch(/Bearer\s+[A-Za-z0-9]{16,}/)
-  })
-})

package/telegram-plugin/tests/two-zone-card-snapshot.test.ts

@@ -1,133 +0,0 @@
-/**
- * P1 of #662 — golden output for 5 canonical card states.
- *
- * Uses explicit `toBe()` rather than `toMatchSnapshot()` so the same
- * test file passes under both vitest (Core tests CI step) and bun
- * (Plugin tests CI step) — the two snapshot formats are incompatible.
- */
-
-import { describe, it, expect } from 'vitest'
-import { renderTwoZoneCard } from '../two-zone-card.js'
-import type { FleetMember } from '../fleet-state.js'
-import type { ProgressCardState } from '../progress-card.js'
-
-function st(over: Partial<ProgressCardState> & { stage: ProgressCardState['stage'] }): ProgressCardState {
-  return {
-    turnStartedAt: 0,
-    items: [],
-    narratives: [],
-    stage: over.stage,
-    thinking: false,
-    subAgents: new Map(),
-    pendingAgentSpawns: new Map(),
-    tasks: [],
-    ...over,
-  }
-}
-
-function fm(over: Partial<FleetMember>): FleetMember {
-  return {
-    agentId: 'aaaaaa00',
-    role: 'agent',
-    startedAt: 0,
-    toolCount: 0,
-    lastActivityAt: 0,
-    lastTool: null,
-    status: 'running',
-    terminalAt: null,
-    errorSeen: false,
-    originatingTurnKey: 'k',
-    ...over,
-  }
-}
-
-const NOW = 60_000
-
-describe('two-zone-card snapshots', () => {
-  it('empty fleet — clean clerk-style card', () => {
-    const out = renderTwoZoneCard({
-      state: st({ stage: 'run', turnStartedAt: NOW - 5000 }),
-      fleet: new Map(),
-      now: NOW,
-    })
-    expect(out).toBe('⚙️ <b>Working…</b> · ⏱ 00:05 · 🔧 0')
-  })
-
-  it('3 members mixed', () => {
-    const fleet = new Map([
-      ['a', fm({ agentId: 'aaaaaa01', role: 'researcher', status: 'running', toolCount: 4, lastActivityAt: NOW - 2000, lastTool: { name: 'Grep', sanitisedArg: 'TODO' } })],
-      ['b', fm({ agentId: 'bbbbbb02', role: 'worker', status: 'done', toolCount: 8, lastActivityAt: NOW - 10_000, terminalAt: NOW - 10_000 })],
-      ['c', fm({ agentId: 'cccccc03', role: 'reviewer', status: 'stuck', toolCount: 2, lastActivityAt: NOW - 70_000, lastTool: { name: 'Read', sanitisedArg: 'big.ts' } })],
-    ])
-    const out = renderTwoZoneCard({
-      state: st({ stage: 'run', turnStartedAt: NOW - 30_000 }),
-      fleet,
-      now: NOW,
-    })
-    expect(out).toBe(
-      '⚙️ <b>Working…</b> · ⏱ 00:30 · 🔧 14 · 🤖 3\n' +
-      '\n' +
-      '<b>FLEET (3)</b>\n' +
-      '↻ researcher <code>aaaaaa</code> · 4t · Grep <code>TODO</code> (2s ago)\n' +
-      '✓ worker <code>bbbbbb</code> · 8t · done 10s ago\n' +
-      '⚠ reviewer <code>cccccc</code> · 2t · idle 1m10s ago',
-    )
-  })
-
-  it('all-done with completed receipts', () => {
-    const fleet = new Map([
-      ['a', fm({ agentId: 'aaaaaa01', role: 'worker', status: 'done', toolCount: 5, lastActivityAt: NOW - 10_000, terminalAt: NOW - 10_000 })],
-      ['b', fm({ agentId: 'bbbbbb02', role: 'reviewer', status: 'done', toolCount: 3, lastActivityAt: NOW - 5000, terminalAt: NOW - 5000 })],
-    ])
-    const out = renderTwoZoneCard({
-      state: st({ stage: 'done', turnStartedAt: NOW - 20_000 }),
-      fleet,
-      now: NOW,
-    })
-    expect(out).toBe(
-      '✅ <b>Done</b> · ⏱ 00:20 · 🔧 8 · 🤖 2\n' +
-      '\n' +
-      '<b>FLEET (2)</b>\n' +
-      '✓ reviewer <code>bbbbbb</code> · 3t · done 5s ago\n' +
-      '✓ worker <code>aaaaaa</code> · 5t · done 10s ago',
-    )
-  })
-
-  it('all-stuck', () => {
-    const fleet = new Map([
-      ['a', fm({ agentId: 'aaaaaa01', role: 'worker', status: 'stuck', toolCount: 1, lastActivityAt: NOW - 90_000, lastTool: { name: 'Bash', sanitisedArg: 'sleep 999' } })],
-      ['b', fm({ agentId: 'bbbbbb02', role: 'worker', status: 'stuck', toolCount: 1, lastActivityAt: NOW - 80_000, lastTool: { name: 'Bash', sanitisedArg: 'sleep 999' } })],
-    ])
-    const out = renderTwoZoneCard({
-      state: st({ stage: 'run', turnStartedAt: NOW - 95_000 }),
-      fleet,
-      now: NOW,
-    })
-    expect(out).toBe(
-      '⚠ <b>Stalled</b> · ⏱ 01:35 · 🔧 2 · 🤖 2\n' +
-      '\n' +
-      '<b>FLEET (2)</b>\n' +
-      '⚠ worker <code>bbbbbb</code> · 1t · idle 1m20s ago\n' +
-      '⚠ worker <code>aaaaaa</code> · 1t · idle 1m30s ago',
-    )
-  })
-
-  it('background — parent done, background sub still running', () => {
-    const fleet = new Map([
-      ['a', fm({ agentId: 'aaaaaa01', role: 'worker', status: 'done', toolCount: 5, lastActivityAt: NOW - 30_000, terminalAt: NOW - 30_000 })],
-      ['b', fm({ agentId: 'bbbbbb02', role: 'background', status: 'background', toolCount: 12, lastActivityAt: NOW - 1000, lastTool: { name: 'Bash', sanitisedArg: 'long-job.sh' } })],
-    ])
-    const out = renderTwoZoneCard({
-      state: st({ stage: 'done', turnStartedAt: NOW - 90_000 }),
-      fleet,
-      now: NOW,
-    })
-    expect(out).toBe(
-      '⏸ <b>Background</b> · ⏱ 01:30 · 🔧 17 · 🤖 2\n' +
-      '\n' +
-      '<b>FLEET (2)</b>\n' +
-      '⏸ background <code>bbbbbb</code> · 12t · Bash <code>long-job.sh</code> (1s ago)\n' +
-      '✓ worker <code>aaaaaa</code> · 5t · done 30s ago',
-    )
-  })
-})

package/telegram-plugin/tests/two-zone-concurrent-turns-isolation.test.ts

@@ -1,155 +0,0 @@
-/**
- * P2 of #662 — concurrent-chat isolation. Two distinct chats each
- * spawn a background sub-agent. Routing must keep their fleets
- * completely independent: a tool_use event for chat A's bg sub-agent
- * must never bleed into chat B's fleet, and vice versa.
- */
-
-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>`,
-})
-
-const enqueueWithThread = (chatId: string, threadId: string, msgId: string): SessionEvent => ({
-  kind: 'enqueue',
-  chatId,
-  messageId: msgId,
-  threadId,
-  rawContent: `<channel chat_id="${chatId}" thread_id="${threadId}">go</channel>`,
-})
-
-describe('P2: concurrent-chat fleet isolation', () => {
-  it('two chats with their own background sub-agents do not cross-pollinate', () => {
-    const { driver } = harness()
-
-    // Chat A
-    driver.ingest(enqueue('cA'), null)
-    driver.ingest(
-      {
-        kind: 'tool_use',
-        toolName: 'Agent',
-        toolUseId: 'tuA',
-        input: { prompt: 'pA', run_in_background: true },
-      },
-      'cA',
-    )
-    driver.ingest({ kind: 'sub_agent_started', agentId: 'saA', firstPromptText: 'pA' }, 'cA')
-
-    // Chat B
-    driver.ingest(enqueue('cB'), null)
-    driver.ingest(
-      {
-        kind: 'tool_use',
-        toolName: 'Agent',
-        toolUseId: 'tuB',
-        input: { prompt: 'pB', run_in_background: true },
-      },
-      'cB',
-    )
-    driver.ingest({ kind: 'sub_agent_started', agentId: 'saB', firstPromptText: 'pB' }, 'cB')
-
-    const fleetA = driver.peekFleet('cA')!
-    const fleetB = driver.peekFleet('cB')!
-    expect(fleetA.has('saA')).toBe(true)
-    expect(fleetA.has('saB')).toBe(false)
-    expect(fleetB.has('saB')).toBe(true)
-    expect(fleetB.has('saA')).toBe(false)
-    expect(fleetA.get('saA')!.status).toBe('background')
-    expect(fleetB.get('saB')!.status).toBe('background')
-  })
-
-  it('PR-C2: two threads in the SAME chat (different threadId, shared chatId) — no cross-talk in per-chat state maps', () => {
-    // Two forum-topic threads in the same Telegram chat. Same chatId,
-    // distinct threadId. The driver must key per-turn state on the
-    // composite (chatId, threadId) base — closing one thread's turn
-    // must not touch the other's, and bg sub-agents must not bleed
-    // between threads.
-    const { driver } = harness()
-
-    driver.ingest(enqueueWithThread('cShared', 'tA', '1'), null)
-    driver.ingest(
-      {
-        kind: 'tool_use', toolName: 'Agent', toolUseId: 'tuA',
-        input: { prompt: 'pA', run_in_background: true },
-      },
-      'cShared',
-    )
-    driver.ingest({ kind: 'sub_agent_started', agentId: 'saA', firstPromptText: 'pA' }, 'cShared')
-
-    driver.ingest(enqueueWithThread('cShared', 'tB', '2'), null)
-    driver.ingest(
-      {
-        kind: 'tool_use', toolName: 'Agent', toolUseId: 'tuB',
-        input: { prompt: 'pB', run_in_background: true },
-      },
-      'cShared',
-    )
-    driver.ingest({ kind: 'sub_agent_started', agentId: 'saB', firstPromptText: 'pB' }, 'cShared')
-
-    // peekFleet keys on (chatId, threadId).
-    const fleetA = driver.peekFleet('cShared', 'tA')!
-    const fleetB = driver.peekFleet('cShared', 'tB')!
-    expect(fleetA).toBeDefined()
-    expect(fleetB).toBeDefined()
-    expect(fleetA.has('saA')).toBe(true)
-    expect(fleetA.has('saB')).toBe(false)
-    expect(fleetB.has('saB')).toBe(true)
-    expect(fleetB.has('saA')).toBe(false)
-
-    // baseTurnSeqs must have distinct entries for the two threads.
-    const maps = (driver as unknown as {
-      _debugGetMaps?: () => { baseTurnSeqs: Map<string, number>; chats: Map<string, unknown> }
-    })._debugGetMaps!()
-    const baseKeys = [...maps.baseTurnSeqs.keys()]
-    // The two threads MUST resolve to distinct base keys (proves the
-    // composite (chatId, threadId) is honoured). The exact base-key
-    // format is (chatId:threadId) — assert distinctness without
-    // hard-coding the format.
-    expect(baseKeys.length).toBe(2)
-    expect(new Set(baseKeys).size).toBe(2)
-    // chats map: 2 in-flight turns.
-    expect(maps.chats.size).toBe(2)
-  })
-})

package/telegram-plugin/tests/two-zone-phasefor-precedence.test.ts

@@ -1,117 +0,0 @@
-/**
- * PR-A — phaseFor precedence: silent-end must be lifted above the
- * background/done branches but gated on parentDone (or stage===done) so
- * it can't fire while the parent is still in flight.
- *
- * Drives `phaseFor` across all combinations of
- * (parentDone, silentEnd, fleetRunning, stalledClose) and asserts the
- * resolved label.
- */
-
-import { describe, it, expect } from 'vitest'
-import { phaseFor } from '../two-zone-card.js'
-import type { FleetMember } from '../fleet-state.js'
-import type { ProgressCardState } from '../progress-card.js'
-
-function fm(id: string, status: FleetMember['status'], lastActivityAt: number = 100_000): FleetMember {
-  return {
-    agentId: id,
-    role: 'agent',
-    startedAt: 0,
-    toolCount: 0,
-    lastActivityAt,
-    lastTool: null,
-    status,
-    terminalAt: status === 'done' || status === 'failed' || status === 'killed' ? lastActivityAt : null,
-    errorSeen: status === 'failed',
-    originatingTurnKey: 'k',
-  }
-}
-
-function st(stage: ProgressCardState['stage']): ProgressCardState {
-  return {
-    turnStartedAt: 1,
-    items: [],
-    narratives: [],
-    stage,
-    thinking: false,
-    subAgents: new Map(),
-    pendingAgentSpawns: new Map(),
-    tasks: [],
-  }
-}
-
-const NOW = 100_000
-
-interface Row {
-  parentDone: boolean
-  silentEnd: boolean
-  fleetRunning: boolean
-  stalledClose: boolean
-  expected: string
-}
-
-// Truth table: 2^4 = 16 combinations of the four boolean inputs.
-// stalledClose dominates everything → Forced close.
-// silentEnd fires only when parentDone is true.
-// When silentEnd is gated off and parent is still running, fleetRunning
-// alone yields Working… (parent active); when parent is done +
-// fleetRunning we get Background; parentDone alone yields Done.
-const rows: Row[] = [
-  // stalledClose=true → always Forced close
-  { parentDone: false, silentEnd: false, fleetRunning: false, stalledClose: true, expected: 'Forced close' },
-  { parentDone: false, silentEnd: false, fleetRunning: true,  stalledClose: true, expected: 'Forced close' },
-  { parentDone: false, silentEnd: true,  fleetRunning: false, stalledClose: true, expected: 'Forced close' },
-  { parentDone: false, silentEnd: true,  fleetRunning: true,  stalledClose: true, expected: 'Forced close' },
-  { parentDone: true,  silentEnd: false, fleetRunning: false, stalledClose: true, expected: 'Forced close' },
-  { parentDone: true,  silentEnd: false, fleetRunning: true,  stalledClose: true, expected: 'Forced close' },
-  { parentDone: true,  silentEnd: true,  fleetRunning: false, stalledClose: true, expected: 'Forced close' },
-  { parentDone: true,  silentEnd: true,  fleetRunning: true,  stalledClose: true, expected: 'Forced close' },
-
-  // stalledClose=false
-  // parent in flight (parentDone=false)
-  { parentDone: false, silentEnd: false, fleetRunning: false, stalledClose: false, expected: 'Working…' },
-  { parentDone: false, silentEnd: false, fleetRunning: true,  stalledClose: false, expected: 'Working…' },
-  // silentEnd is GATED on parentDone — must not fire while parent in flight
-  { parentDone: false, silentEnd: true,  fleetRunning: false, stalledClose: false, expected: 'Working…' },
-  { parentDone: false, silentEnd: true,  fleetRunning: true,  stalledClose: false, expected: 'Working…' },
-
-  // parent done
-  { parentDone: true,  silentEnd: false, fleetRunning: false, stalledClose: false, expected: 'Done' },
-  { parentDone: true,  silentEnd: false, fleetRunning: true,  stalledClose: false, expected: 'Background' },
-  // silentEnd LIFTED above background/done — fires even when fleet still running
-  { parentDone: true,  silentEnd: true,  fleetRunning: false, stalledClose: false, expected: 'Ended without reply' },
-  { parentDone: true,  silentEnd: true,  fleetRunning: true,  stalledClose: false, expected: 'Ended without reply' },
-]
-
-describe('phaseFor precedence — (parentDone, silentEnd, fleetRunning, stalledClose)', () => {
-  it.each(rows)(
-    'parentDone=$parentDone silentEnd=$silentEnd fleetRunning=$fleetRunning stalledClose=$stalledClose → $expected',
-    ({ parentDone, silentEnd, fleetRunning, stalledClose, expected }) => {
-      const stage: ProgressCardState['stage'] = parentDone ? 'done' : 'run'
-      const fleet = new Map<string, FleetMember>()
-      if (fleetRunning) fleet.set('a', fm('a', 'running', NOW))
-      const opts: Record<string, unknown> = {}
-      if (silentEnd) opts.silentEnd = true
-      if (stalledClose) opts.stalledClose = true
-      // parentDone is conveyed via stage; also pass the explicit flag for parity
-      if (parentDone) opts.parentDone = true
-
-      const phase = phaseFor(st(stage), fleet, NOW, opts)
-      expect(phase.label).toBe(expected)
-    },
-  )
-
-  // PR-C2 reviewer follow-up: add an explicit row for FleetMember.status=
-  // 'background'. The truth-table above uses status='running' to model
-  // "fleet still running"; `anyFleetActive` also returns true for
-  // 'background' status, so a parentDone+background-only fleet should
-  // resolve to "Background" rather than "Done".
-  it('parentDone=true + fleet=[background-only] → Background (not Done)', () => {
-    const fleet = new Map<string, FleetMember>([
-      ['bg', fm('bg', 'background', NOW)],
-    ])
-    const phase = phaseFor(st('done'), fleet, NOW, { parentDone: true })
-    expect(phase.label).toBe('Background')
-  })
-})