switchroom 0.7.15 → 0.10.0

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

@@ -1,187 +0,0 @@
-/**
- * PR-C2 — additional golden snapshots for renderTwoZoneCard not
- * covered by two-zone-card-snapshot.test.ts:
- *
- *   1. silent-end + bg fleet running (silentEnd lifted above
- *      Background; the bg member still appears in the FLEET zone).
- *   2. stalled-close header (`stalledClose` precedence dominates).
- *   3. Parent zone "(+N earlier)" overflow when items.length >
- *      PARENT_BULLET_CAP (=8).
- *
- * fails when: phaseFor's precedence regresses (silentEnd no longer
- * lifted above background), the stalledClose label changes, or
- * PARENT_BULLET_CAP overflow rendering drops the "(+N earlier)" prefix.
- */
-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 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,
-  }
-}
-
-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,
-  }
-}
-
-const NOW = 100_000
-
-describe('PR-C2: two-zone card snapshot extras', () => {
-  it('silent-end + bg fleet still running → header is "Ended without reply", FLEET shows bg member', () => {
-    const fleet = new Map([
-      ['a', fm({
-        agentId: 'aaaaaa01', role: 'background', status: 'background',
-        toolCount: 7, lastActivityAt: NOW - 2000,
-        lastTool: { name: 'Bash', sanitisedArg: 'long.sh' },
-      })],
-    ])
-    const out = renderTwoZoneCard({
-      state: st({ stage: 'done', turnStartedAt: NOW - 30_000 }),
-      fleet,
-      now: NOW,
-      opts: { silentEnd: true },
-    })
-    expect(out).toBe(
-      '🙊 <b>Ended without reply</b> · ⏱ 00:30 · 🔧 7 · 🤖 1\n' +
-      '\n' +
-      '<b>FLEET (1)</b>\n' +
-      '⏸ background <code>aaaaaa</code> · 7t · Bash <code>long.sh</code> (2s ago)',
-    )
-  })
-
-  it('stalled-close header dominates regardless of fleet state', () => {
-    const fleet = new Map([
-      ['a', fm({ agentId: 'aaaaaa01', role: 'worker', status: 'running', toolCount: 3, lastActivityAt: NOW - 1000 })],
-    ])
-    const out = renderTwoZoneCard({
-      state: st({ stage: 'run', turnStartedAt: NOW - 60_000 }),
-      fleet,
-      now: NOW,
-      opts: { stalledClose: true },
-    })
-    // Header begins with the "Forced close" phase. We don't snapshot the
-    // full body — just lock down the header and the icon.
-    expect(out.startsWith('⚠ <b>Forced close</b> · ⏱ 01:00')).toBe(true)
-  })
-
-  it('parent zone overflow: "(+N earlier)" prefix when items > PARENT_BULLET_CAP=8', () => {
-    const items = Array.from({ length: 12 }, (_, i) => ({
-      tool: 'Read',
-      label: `f${i}.ts`,
-    }))
-    const out = renderTwoZoneCard({
-      state: st({ stage: 'run', turnStartedAt: NOW - 5000, items }),
-      fleet: new Map(),
-      now: NOW,
-    })
-    // 12 items, cap 8 → 4 hidden.
-    expect(out).toContain('(+4 earlier)')
-    // The visible bullets are the LAST 8 (slice(-8) → f4..f11).
-    // f11 is the in-flight bullet (stage=run, last index) → ◉.
-    expect(out).toContain('◉ f11.ts')
-    expect(out).toContain('● f4.ts')
-    // f3 (the latest hidden) must not appear as a bullet.
-    expect(out).not.toContain('f3.ts')
-    // No <code> wrapping around row labels anymore.
-    expect(out).not.toContain('<code>f11.ts</code>')
-  })
-
-  it('parent zone: in-flight last bullet uses ◉ <plain>; earlier use ● <plain>', () => {
-    const items = [
-      { tool: 'Read', label: 'a.ts' },
-      { tool: 'Read', label: 'b.ts' },
-      { tool: 'Bash', label: 'ls' },
-    ]
-    const out = renderTwoZoneCard({
-      state: st({ stage: 'run', turnStartedAt: NOW - 5000, items }),
-      fleet: new Map(),
-      now: NOW,
-    })
-    // last item active — plain text, no <b>, no <code>, no tool prefix
-    expect(out).toContain('◉ ls')
-    expect(out).not.toContain('◉ <b>')
-    // earlier items — plain text only, no tool prefix
-    expect(out).toContain('● a.ts')
-    expect(out).toContain('● b.ts')
-    expect(out).not.toContain('Read <code>')
-    // No <code> wrapping anywhere on parent rows.
-    expect(out).not.toContain('<code>ls</code>')
-    expect(out).not.toContain('<code>a.ts</code>')
-  })
-
-  it('parent zone: when stage=done all bullets render as ● (no active marker)', () => {
-    const items = [
-      { tool: 'Read', label: 'a.ts' },
-      { tool: 'Bash', label: 'ls' },
-    ]
-    const out = renderTwoZoneCard({
-      state: st({ stage: 'done', turnStartedAt: NOW - 5000, items }),
-      fleet: new Map(),
-      now: NOW,
-    })
-    expect(out).toContain('● a.ts')
-    expect(out).toContain('● ls')
-    expect(out).not.toContain('◉')
-  })
-
-  it('parent zone: row with no label falls back to humanised tool name', () => {
-    const items = [
-      { tool: 'TodoWrite', label: '' },
-      { tool: 'Edit', label: '' },
-    ]
-    const out = renderTwoZoneCard({
-      state: st({ stage: 'run', turnStartedAt: NOW - 5000, items }),
-      fleet: new Map(),
-      now: NOW,
-    })
-    expect(out).toContain('● updating tasks')
-    expect(out).toContain('◉ editing file')
-  })
-
-  it('parent zone: row with no label on mcp tool uses mcpDisplayName', () => {
-    const items = [
-      { tool: 'mcp__switchroom-telegram__reply', label: '' },
-    ]
-    const out = renderTwoZoneCard({
-      state: st({ stage: 'run', turnStartedAt: NOW - 5000, items }),
-      fleet: new Map(),
-      now: NOW,
-    })
-    expect(out).toContain('◉ Telegram: reply')
-  })
-
-  it('parent zone: HTML in label is escaped (no raw <code> styling)', () => {
-    const items = [
-      { tool: 'Bash', label: 'echo <hi>' },
-    ]
-    const out = renderTwoZoneCard({
-      state: st({ stage: 'done', turnStartedAt: NOW - 5000, items }),
-      fleet: new Map(),
-      now: NOW,
-    })
-    expect(out).toContain('● echo &lt;hi&gt;')
-  })
-})

package/telegram-plugin/tests/two-zone-stuck-edit-throttle.test.ts

@@ -1,149 +0,0 @@
-/**
- * P3 of #662 — stuck escalation respects the edit throttle.
- *
- * Tests that stuck-detection adds at most one extra emit beyond the
- * heartbeat baseline. Compares two 100s runs: one where keep-alive
- * events prevent the member from going stuck, one where it does.
- * The difference should be ≤1 (the stuck transition itself).
- */
-
-import { describe, it, expect } from 'vitest'
-import { createProgressDriver } from '../progress-card-driver.js'
-import type { SessionEvent } from '../session-tail.js'
-
-interface Timer {
-  fireAt: number
-  fn: () => void
-  ref: number
-  repeat?: number
-}
-
-function createHarness() {
-  let now = 1000
-  const timers: Timer[] = []
-  let nextRef = 0
-  const emits: Array<{ html: string; isFirstEmit: boolean }> = []
-  const driver = createProgressDriver({
-    emit: (e) => {
-      emits.push({ html: e.html, isFirstEmit: e.isFirstEmit })
-    },
-    minIntervalMs: 500,
-    coalesceMs: 400,
-    initialDelayMs: 0,
-    promoteAfterMs: 999_999,
-    heartbeatMs: 5000,
-    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)
-    },
-  })
-  function advance(ms: number) {
-    const target = now + ms
-    while (true) {
-      const due = timers
-        .filter((t) => t.fireAt <= target)
-        .sort((a, b) => a.fireAt - b.fireAt)
-      if (due.length === 0) break
-      const t = due[0]
-      now = t.fireAt
-      t.fn()
-      if (t.repeat) {
-        t.fireAt = now + t.repeat
-      } else {
-        const idx = timers.indexOf(t)
-        if (idx !== -1) timers.splice(idx, 1)
-      }
-    }
-    now = target
-  }
-  return { driver, advance, emits, getNow: () => now }
-}
-
-const enqueue = (chatId: string): SessionEvent => ({
-  kind: 'enqueue',
-  chatId,
-  messageId: '1',
-  threadId: null,
-  rawContent: `<channel chat_id="${chatId}">go</channel>`,
-})
-
-const toolUse = (toolUseId: string): SessionEvent => ({
-  kind: 'sub_agent_tool_use',
-  agentId: 'sa1',
-  toolUseId,
-  toolName: 'Read',
-  input: { file_path: '/tmp/x' },
-})
-
-function runHarness(keepAlive: boolean): { emitCount: number } {
-  const { driver, advance, emits, getNow } = createHarness()
-  const CHAT = 'c1'
-  driver.ingest(enqueue(CHAT), null)
-  driver.ingest(
-    { kind: 'sub_agent_started', agentId: 'sa1', firstPromptText: 'work', subagentType: 'worker' },
-    CHAT,
-  )
-  const startEmits = emits.length
-
-  // Run 100s total. If keepAlive, dispatch tool_use events at 30s intervals
-  // to keep lastActivityAt fresh and prevent the member from going stuck.
-  // Otherwise, let it go stuck at ~60s.
-  if (keepAlive) {
-    for (let elapsed = 0; elapsed < 100_000; elapsed += 30_000) {
-      driver.ingest(toolUse(`tu-${elapsed}`), CHAT)
-      advance(30_000)
-    }
-  } else {
-    advance(100_000)
-  }
-
-  return { emitCount: emits.length - startEmits }
-}
-
-describe('P3 stuck escalation — edit throttle', () => {
-  it('stuck-detection adds at most one extra emit beyond heartbeat baseline', () => {
-    // Baseline: 100s with keep-alive events every 30s. Member never goes
-    // stuck. Heartbeat fires ~20 times due to elapsed-time changes (by
-    // design, matches #314's elapsed-ticker JTBD).
-    const baseline = runHarness(true)
-
-    // With stuck transition: 100s with no keep-alive. Member crosses stuck
-    // threshold at ~60s; markStuck flips status once.
-    const stuck = runHarness(false)
-
-    // The delta should be 0 or 1 — the stuck transition is content-changing
-    // so it could add one emit, but it likely lands on a heartbeat tick that
-    // was emitting anyway.
-    // The stuck path must not emit a storm — at most one extra emit
-    // beyond the keep-alive baseline. (The keep-alive baseline can be
-    // HIGHER than the stuck path because each tool_use event is itself
-    // content-changing; that's fine — we only care that stuck-detection
-    // doesn't ADD emits beyond the heartbeat-driven elapsed updates.)
-    expect(stuck.emitCount).toBeLessThanOrEqual(baseline.emitCount + 1)
-  })
-
-  it('stuck transition does not produce a runaway edit storm', () => {
-    // Sanity: 100s of pure silence (no keep-alive) emits well under the
-    // ~20-tick heartbeat ceiling plus a single stuck transition. This
-    // catches a regression where markStuck would re-fire every tick.
-    const stuck = runHarness(false)
-    expect(stuck.emitCount).toBeLessThanOrEqual(25)
-  })
-})

package/telegram-plugin/tests/two-zone-stuck-header-escalation.test.ts

@@ -1,101 +0,0 @@
-/**
- * P3 of #662 — header escalation data side.
- *
- * P1's renderer reads fleet member statuses to compute the ⚠ Stalled
- * header phase. P3's job is just to make sure the data correctly
- * reflects "every running member is stuck" once the threshold passes.
- */
-
-import { describe, it, expect } from 'vitest'
-import { createProgressDriver } from '../progress-card-driver.js'
-import type { SessionEvent } from '../session-tail.js'
-
-interface Timer {
-  fireAt: number
-  fn: () => void
-  ref: number
-  repeat?: number
-}
-
-function harness() {
-  let now = 1000
-  const timers: Timer[] = []
-  let nextRef = 0
-  const driver = createProgressDriver({
-    emit: () => {},
-    minIntervalMs: 500,
-    coalesceMs: 400,
-    initialDelayMs: 0,
-    promoteAfterMs: 999_999,
-    heartbeatMs: 5000,
-    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)
-    },
-  })
-  function advance(ms: number) {
-    const target = now + ms
-    while (true) {
-      const due = timers
-        .filter((t) => t.fireAt <= target)
-        .sort((a, b) => a.fireAt - b.fireAt)
-      if (due.length === 0) break
-      const t = due[0]
-      now = t.fireAt
-      t.fn()
-      if (t.repeat) {
-        t.fireAt = now + t.repeat
-      } else {
-        const idx = timers.indexOf(t)
-        if (idx !== -1) timers.splice(idx, 1)
-      }
-    }
-    now = target
-  }
-  return { driver, advance }
-}
-
-const enqueue = (chatId: string): SessionEvent => ({
-  kind: 'enqueue',
-  chatId,
-  messageId: '1',
-  threadId: null,
-  rawContent: `<channel chat_id="${chatId}">go</channel>`,
-})
-
-describe('P3 stuck escalation — header escalation (data side)', () => {
-  it('two simultaneously idle members both flip to stuck after 60s', () => {
-    const { driver, advance } = harness()
-    const CHAT = 'c1'
-    driver.ingest(enqueue(CHAT), null)
-    driver.ingest(
-      { kind: 'sub_agent_started', agentId: 'sa1', firstPromptText: 'a', subagentType: 'worker' },
-      CHAT,
-    )
-    driver.ingest(
-      { kind: 'sub_agent_started', agentId: 'sa2', firstPromptText: 'b', subagentType: 'worker' },
-      CHAT,
-    )
-    advance(61_000)
-    const fleet = driver.peekFleet(CHAT)!
-    expect(fleet.get('sa1')!.status).toBe('stuck')
-    expect(fleet.get('sa2')!.status).toBe('stuck')
-  })
-})

package/telegram-plugin/tests/two-zone-stuck-per-member.test.ts

@@ -1,114 +0,0 @@
-/**
- * P3 of #662 — per-member stuck escalation.
- *
- * Drives the real createProgressDriver heartbeat tick across the 60s
- * threshold and asserts the fleet member's `status` flips
- * `running` → `stuck` exactly when `now - lastActivityAt > 60_000`.
- */
-
-import { describe, it, expect } from 'vitest'
-import { createProgressDriver } from '../progress-card-driver.js'
-import type { SessionEvent } from '../session-tail.js'
-
-interface Timer {
-  fireAt: number
-  fn: () => void
-  ref: number
-  repeat?: number
-}
-
-function harness(opts: { heartbeatMs?: number } = {}) {
-  let now = 1000
-  const timers: Timer[] = []
-  let nextRef = 0
-  const driver = createProgressDriver({
-    emit: () => {},
-    minIntervalMs: 500,
-    coalesceMs: 400,
-    initialDelayMs: 0,
-    promoteAfterMs: 999_999,
-    heartbeatMs: opts.heartbeatMs ?? 5000,
-    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)
-    },
-  })
-  function advance(ms: number) {
-    const target = now + ms
-    // Fire all due timers (including repeating heartbeat) up to target.
-    // Loop until no due timers remain to handle re-scheduled timers
-    // synthesised inside fired callbacks.
-    while (true) {
-      const due = timers
-        .filter((t) => t.fireAt <= target)
-        .sort((a, b) => a.fireAt - b.fireAt)
-      if (due.length === 0) break
-      const t = due[0]
-      now = t.fireAt
-      t.fn()
-      if (t.repeat) {
-        t.fireAt = now + t.repeat
-      } else {
-        const idx = timers.indexOf(t)
-        if (idx !== -1) timers.splice(idx, 1)
-      }
-    }
-    now = target
-  }
-  return { driver, advance, getNow: () => now, timers }
-}
-
-const enqueue = (chatId: string): SessionEvent => ({
-  kind: 'enqueue',
-  chatId,
-  messageId: '1',
-  threadId: null,
-  rawContent: `<channel chat_id="${chatId}">go</channel>`,
-})
-
-describe('P3 stuck escalation — per-member', () => {
-  it('fleet member stays running at 59s of idle', () => {
-    const { driver, advance } = harness({ heartbeatMs: 5000 })
-    const CHAT = 'c1'
-    driver.ingest(enqueue(CHAT), null)
-    driver.ingest(
-      { kind: 'sub_agent_started', agentId: 'sa1', firstPromptText: 'work', subagentType: 'worker' },
-      CHAT,
-    )
-    // Advance 59s — heartbeat fires multiple times but we are still
-    // within the 60s idle window, so no stuck transition should happen.
-    advance(59_000)
-    const m = driver.peekFleet(CHAT)!.get('sa1')!
-    expect(m.status).toBe('running')
-  })
-
-  it('fleet member flips to stuck at >60s of idle', () => {
-    const { driver, advance } = harness({ heartbeatMs: 5000 })
-    const CHAT = 'c1'
-    driver.ingest(enqueue(CHAT), null)
-    driver.ingest(
-      { kind: 'sub_agent_started', agentId: 'sa1', firstPromptText: 'work', subagentType: 'worker' },
-      CHAT,
-    )
-    advance(61_000)
-    const m = driver.peekFleet(CHAT)!.get('sa1')!
-    expect(m.status).toBe('stuck')
-  })
-})

package/telegram-plugin/tests/two-zone-stuck-recovery.test.ts

@@ -1,105 +0,0 @@
-/**
- * P3 of #662 — stuck → running recovery.
- *
- * After a member is marked stuck via the heartbeat tick, a new
- * sub_agent_tool_use event must reset status to running and refresh
- * lastActivityAt to the event's now.
- */
-
-import { describe, it, expect } from 'vitest'
-import { createProgressDriver } from '../progress-card-driver.js'
-import type { SessionEvent } from '../session-tail.js'
-
-interface Timer {
-  fireAt: number
-  fn: () => void
-  ref: number
-  repeat?: number
-}
-
-function harness() {
-  let now = 1000
-  const timers: Timer[] = []
-  let nextRef = 0
-  const driver = createProgressDriver({
-    emit: () => {},
-    minIntervalMs: 500,
-    coalesceMs: 400,
-    initialDelayMs: 0,
-    promoteAfterMs: 999_999,
-    heartbeatMs: 5000,
-    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)
-    },
-  })
-  function advance(ms: number) {
-    const target = now + ms
-    while (true) {
-      const due = timers
-        .filter((t) => t.fireAt <= target)
-        .sort((a, b) => a.fireAt - b.fireAt)
-      if (due.length === 0) break
-      const t = due[0]
-      now = t.fireAt
-      t.fn()
-      if (t.repeat) {
-        t.fireAt = now + t.repeat
-      } else {
-        const idx = timers.indexOf(t)
-        if (idx !== -1) timers.splice(idx, 1)
-      }
-    }
-    now = target
-  }
-  return { driver, advance, getNow: () => now }
-}
-
-const enqueue = (chatId: string): SessionEvent => ({
-  kind: 'enqueue',
-  chatId,
-  messageId: '1',
-  threadId: null,
-  rawContent: `<channel chat_id="${chatId}">go</channel>`,
-})
-
-describe('P3 stuck escalation — recovery', () => {
-  it('next sub_agent_tool_use after stuck flips status back to running and bumps lastActivityAt', () => {
-    const { driver, advance, getNow } = harness()
-    const CHAT = 'c1'
-    driver.ingest(enqueue(CHAT), null)
-    driver.ingest(
-      { kind: 'sub_agent_started', agentId: 'sa1', firstPromptText: 'work', subagentType: 'worker' },
-      CHAT,
-    )
-    advance(61_000)
-    const stuck = driver.peekFleet(CHAT)!.get('sa1')!
-    expect(stuck.status).toBe('stuck')
-
-    // Now a real tool event arrives — recovery.
-    driver.ingest(
-      { kind: 'sub_agent_tool_use', agentId: 'sa1', toolUseId: 't1', toolName: 'Read', input: { file_path: '/tmp/x.ts' } },
-      CHAT,
-    )
-    const recovered = driver.peekFleet(CHAT)!.get('sa1')!
-    expect(recovered.status).toBe('running')
-    expect(recovered.lastActivityAt).toBe(getNow())
-  })
-})